Taxonomy of Open Source, AI & Agentic AI

Frameworks for Openness

Openness in AI is not binary. A release can be open in some respects and closed in others, so the community has built frameworks to describe degrees of openness rather than settling for “open” vs “closed.”

Open Source AI Definition (OSAID) 1.0

Published by the Open Source Initiative in October 2024. It defines an Open Source AI system as one granting the freedoms to use, study, modify, and share for any purpose, and requires the preferred form for modification: sufficiently detailed data information, the source code used to train and run the system, and the model parameters. It requires data information rather than the raw dataset in every case — an ongoing point of community debate.

Model Openness Framework (MOF)

A graded standard that classifies a release by which components ship under open licenses — code, datasets and data documentation, weights, evaluations, cards, and papers — into three tiers:

• Class III — Open Model: weights plus basic documentation.
• Class II — Open Tooling: adds training and evaluation code.
• Class I — Open Science: the most complete tier, adding training data and full documentation.

Produced by the Generative AI Commons (LF AI & Data) to replace the binary label with a verifiable one.

OpenMDW

A permissive license, introduced through the Linux Foundation, for distributing models together with their weights, data, code, and documentation under clear, standardized terms.

Open weights ≠ Open Source AI

The most common confusion in the field. Publishing downloadable parameters is necessary but not sufficient for Open Source AI: many “open” models release weights under restrictive licenses while withholding training data, training code, or commercial and modification rights.

Open AI Ecosystem: Fundamental Terms

Open Source

Traditionally, software released under licenses satisfying recognized open-source criteria.

Open Source AI

Under OSI's Open Source AI Definition 1.0, an AI system must permit users to use, study, modify, and share, and provide the preferred forms needed to meaningfully exercise those freedoms.

Open-weight model

A model whose trained parameters are publicly obtainable. This does not necessarily mean Open Source AI. Weights may be published while training data remains undisclosed, training code is unavailable, modification is contractually restricted, or commercial usage is restricted. OSI explicitly distinguishes publishing weights from satisfying its broader Open Source AI requirements.

Source-available AI

Some source artifacts are visible, but the applicable license does not grant all traditional open-source freedoms.

Open model

An imprecise umbrella term. It may mean open source, open weights, openly downloadable, or open research model. Because of ambiguity, the specific licensing/access model should be stated.

Proprietary model

Model controlled under restrictive ownership or access terms.

Closed-weight model

Model whose parameters are not publicly released.

API-only model

Model accessible through an API but not ordinarily distributed as executable weights.

Open Data Terminology

Open dataset

Dataset distributed under terms permitting broad use and redistribution.

Public dataset

Publicly accessible dataset. Public does not necessarily mean legally open.

Training-data transparency

Disclosure of information about training sources.

Dataset card

Documentation describing a dataset. Often includes provenance, intended use, limitations, licensing, and composition.

Data license

Legal terms governing dataset usage.

Model Licensing

Model license

Legal terms governing model use.

Software license

License governing source code. Examples include Apache-2.0, MIT, and BSD.

Copyleft

License requirements that modifications or derivatives remain under compatible terms.

Permissive license

License permitting broad reuse with relatively limited conditions.

Noncommercial license

License restricting commercial use. Such restrictions generally mean the artifact does not satisfy conventional Open Source definitions.

Research-only license

License limiting use to research.

Responsible AI license

License adding behavioral or use restrictions. These may support policy goals but can conflict with traditional open-source criteria if they restrict fields of endeavor or purposes.

Model Distribution

Model repository

Hosting location for model artifacts.

Model hub

Platform hosting many models, datasets, and related artifacts.

Artifact registry

Repository for versioned software or AI artifacts.

Model version

Specific release of a model.

Model lineage

Relationship among base models, fine-tunes, merges, and descendants.

Fork

Modified derivative distributed separately.

Open AI Governance

Open governance

Community-driven governance model for projects or ecosystems.

Maintainer

Person or organization responsible for a project.

Contributor

Person submitting improvements.

Upstream

Original or authoritative project.

Downstream

Project depending on or deriving from another project.

Fork

Independent derivative of a project.

Pull request / merge request

Proposed code or documentation change.

Community model

Model developed or maintained with community participation.

Reproducibility

Reproducibility

Ability to repeat an experiment and obtain comparable results.

Replicability

Reimplementing a process independently and obtaining similar conclusions. Terminology varies somewhat by research discipline.

Training recipe

Detailed specification of the training process, including dataset mixture, optimizer, learning rate, batch size, epochs/steps, architecture, and initialization.

Hyperparameter

Configurable training variable not directly learned as a model parameter.

Random seed

Value controlling pseudorandom initialization or sampling.

Open Model Reproducibility Spectrum

A useful taxonomy ranges from query-only access up to a fully reproducible open-source system.

OSI's definition specifically emphasizes access to the preferred form of modification, including relevant data information, source code, and parameters.

Local AI

Local AI

Running AI workloads on hardware controlled by the user.

On-device AI

Inference running directly on a laptop, phone, edge device, or embedded system.

Edge AI

Models executing close to the source of data rather than centralized clouds.

Self-hosted AI

User or organization deploys the model on infrastructure it controls.

Air-gapped AI

AI environment isolated from external networks.

Private AI

Broad marketing/architecture term emphasizing protection or control of data. It does not describe one specific technical architecture.

Agent + Open Model Intersection

This is where the two taxonomies converge.

Open agent

Agent implementation distributed under an open-source software license.

Open-weight agent

Agent built around an openly downloadable model. The agent framework itself may or may not be open source.

Self-hosted agent

Agent whose model and orchestration infrastructure run on user-controlled infrastructure.

Local agent

Agent running primarily on a local machine.

Private agent

Agent configured so sensitive information remains inside controlled infrastructure.

Sovereign AI

Broad strategic term for AI infrastructure, models, data, and governance controlled within a particular organization, jurisdiction, or national ecosystem.

AI Artifact Taxonomy

A model ecosystem consists of more than weights.

Architecture

Structural design of the model, such as a transformer, state-space model, or mixture of experts.

Parameters

Learned numerical values.

Weights

The primary learned parameter tensors. OSI describes AI weights as learned parameters over the model architecture that contribute to producing outputs.

Biases

Specific learned parameters used by some network layers.

Checkpoint

Saved model state at a point during training.

Final checkpoint

Model artifact after completed training.

Intermediate checkpoint

Checkpoint created during training.

Optimizer state

Training-state information used by optimizers, which may include momentum, variance estimates, and learning-rate state.

Configuration

Parameters defining architecture or runtime behavior.

Tokenizer

Component converting text to and from token IDs.

Vocabulary

Set of tokens understood by a tokenizer.

Inference code

Software required to run the model.

Training code

Software used to train the model.

Evaluation code

Software used for benchmarking or validation.

Model Families

Foundation model

Large general-purpose model adaptable to many downstream tasks.

Base model

Model prior to instruction tuning or task specialization.

Pretrained model

Model trained through broad initial training.

Instruction-tuned model

Model further trained to follow human instructions.

Chat model

Model optimized for conversational interaction.

Reasoning model

Model optimized for complex multi-step reasoning.

Code model

Model specialized for programming tasks.

Embedding model

Model generating vector representations.

Reranker model

Model scoring document/query relevance.

Vision-language model — VLM

Model handling text and images.

Multimodal model

Model accepting or producing multiple modalities, such as text, images, audio, and video.

Speech model

Model handling spoken audio.

Diffusion model

Generative model commonly used for image, video, and audio generation.

Transformer Architecture Terms

Transformer

Neural architecture based heavily on attention mechanisms.

Attention

Mechanism allowing tokens to weight relationships to other tokens.

Self-attention

Attention among tokens within the same sequence.

Cross-attention

Attention between different sequences or modalities.

Multi-head attention

Multiple attention operations operating in parallel.

Causal attention

Attention restricted from seeing future tokens.

Attention head

One independent attention projection.

Feed-forward network — FFN

Neural sublayer following attention blocks.

Transformer block

Repeated unit containing attention and feed-forward layers.

Residual connection

Connection allowing layer inputs to bypass transformations.

Layer normalization

Normalization technique commonly used in transformers.

Model Size and Capacity

Parameter count

Number of learned parameters, commonly noted as 1B (one billion), 7B, 70B, or 400B.

Active parameters

Parameters used for a particular token or inference path. Especially relevant to Mixture-of-Experts models.

Total parameters

All parameters in the model.

Dense model

Most parameters participate in each inference pass.

Sparse model

Only some parameters are active.

MoE — Mixture of Experts

Architecture routing tokens to selected expert subnetworks. Related terms include expert, router, expert routing, top-k routing, and expert parallelism.

Training

Pretraining

Initial large-scale model training.

Continued pretraining

Additional pretraining on more or specialized data.

Domain-adaptive pretraining

Continued pretraining on a specific domain.

Post-training

Training after general pretraining.

Fine-tuning

Additional training targeting behavior or domain adaptation.

Supervised fine-tuning — SFT

Fine-tuning from input-output examples.

Instruction tuning

Fine-tuning based on instruction-response datasets.

Alignment and Preference Optimization

Alignment

Training or system design intended to shape model behavior toward desired objectives or constraints.

RLHF

Reinforcement Learning from Human Feedback.

RLAIF

Reinforcement Learning from AI Feedback.

Reward model

Model predicting preference or quality.

Preference dataset

Pairs or rankings representing preferred outputs.

DPO

Direct Preference Optimization. Preference alignment without a traditional RL loop.

PPO

Proximal Policy Optimization. Reinforcement-learning algorithm historically used in RLHF.

GRPO

A policy-optimization family increasingly associated with reasoning-model training.

Constitutional AI

Training/steering approach using explicit principles to critique or refine outputs.

Parameter-Efficient Fine-Tuning

PEFT

Parameter-Efficient Fine-Tuning. Modify only a small fraction of model parameters.

LoRA

Low-Rank Adaptation. Adds trainable low-rank matrices while keeping most base weights frozen.

QLoRA

LoRA fine-tuning performed against a quantized base model.

Adapter

Small trainable module attached to a larger frozen model.

Prefix tuning

Trainable vectors are prepended to model activations.

Prompt tuning

Trainable virtual prompt embeddings.

Delta weights

Parameter differences representing a model modification.

Model Merging

Model merge

Combining parameters or adaptations from multiple models.

Weight averaging

Averaging model parameters.

Task arithmetic

Manipulating parameter differences associated with learned tasks.

Adapter merging

Combining multiple LoRA or adapter modifications.

Frankenmodel

Informal term for a model assembled from parts or layers of multiple models.

Distillation

Knowledge distillation

Training a smaller or new model using outputs from a larger model.

Teacher model

Model generating supervision.

Student model

Model being trained from teacher-generated signals.

Synthetic distillation data

Training examples generated by another model.

Training Data

Training corpus

Complete data collection used during training.

Dataset

Structured collection of training or evaluation examples.

Data mixture

Combination of datasets and domains.

Data provenance

Information about where data originated.

Data lineage

Record of how data was processed and transformed.

Data curation

Selection and preparation of training data.

Deduplication

Removal of duplicate or near-duplicate examples.

Data filtering

Removing undesirable examples.

Data contamination

Training data accidentally contains evaluation questions or answers.

Synthetic data

Artificially generated training data.

Human-generated data

Data created directly by people.

Machine-generated data

Data produced by automated models or systems.

Model Documentation

Model card

Structured documentation describing a model. Typical topics include architecture, intended use, limitations, training, evaluation, and license.

System card

Broader documentation describing deployed AI system behavior and safety evaluation.

Technical report

Detailed research document explaining development and evaluation.

Datasheet for datasets

Documentation format for describing datasets.

Model File Formats

Safetensors

Tensor serialization format designed to avoid arbitrary-code execution inherent in some generic serialization mechanisms.

PyTorch checkpoint

Model serialized in PyTorch-compatible format.

GGUF

Popular file format for distributing quantized models, particularly in local inference ecosystems.

ONNX

Portable representation for machine-learning models and computation graphs.

TensorRT engine

Optimized representation for NVIDIA inference execution.

Quantization

Quantization

Representing model values with lower precision, to lower memory, raise throughput, speed inference, and reduce cost. Inference engines such as vLLM support multiple quantization families including FP8, INT8, INT4, GPTQ, AWQ, and GGUF.

FP32

32-bit floating point.

FP16

16-bit floating point.

BF16

Brain floating point.

FP8

8-bit floating point.

INT8

8-bit integer quantization.

INT4

4-bit integer quantization.

GPTQ

Post-training weight quantization method.

AWQ

Activation-aware weight quantization.

Quantization-aware training

Training designed to account for later low-precision inference.

Post-training quantization — PTQ

Quantizing after training.

Inference

Inference

Running a trained model to generate outputs.

Prefill

Processing the input prompt before autoregressive generation.

Decode

Generating output tokens.

Token generation

Producing individual output tokens.

Autoregressive decoding

Generating tokens sequentially based on preceding tokens.

Batch inference

Processing several requests simultaneously.

Online inference

Interactive or request-response serving.

Offline inference

Batch processing without interactive latency requirements.

Serving Infrastructure

Model server

Service exposing model inference.

Inference server

Runtime handling inference requests.

Serving engine

Software optimized for deploying models.

Continuous batching

Dynamically combining requests during generation. A core high-throughput serving technique supported by engines such as vLLM.

Dynamic batching

Grouping requests according to runtime arrival patterns.

Static batching

Batch fixed before processing starts.

PagedAttention

Memory-management technique associated with vLLM for efficiently handling attention KV memory.

Chunked prefill

Processing long prefill workloads in chunks.

Prefix caching

Reusing computations for repeated prompt prefixes.

KV Cache

KV cache

Cached attention key/value tensors generated for prior tokens. This avoids recomputing attention states during every decode step.

KV-cache memory

GPU or accelerator memory occupied by these tensors.

Cache eviction

Removing old cache entries.

Prefix cache

Cache reusable across requests that share prefixes.

Advanced Decoding

Greedy decoding

Always choose highest-probability next token.

Sampling

Sample tokens according to probability distribution.

Temperature

Controls randomness of token selection.

Top-k

Restrict sampling to the highest-probability k tokens.

Top-p / nucleus sampling

Sample from the smallest token set whose cumulative probability exceeds a threshold.

Beam search

Maintain multiple candidate sequences.

Speculative decoding

Use a secondary mechanism/model to propose multiple tokens that the primary model can verify. Modern inference engines support several speculative decoding techniques.

Draft model

Smaller model proposing speculative tokens.

Target model

Primary model validating proposed tokens.

Distributed Inference and Training

Data parallelism

Replicate model while distributing data.

Tensor parallelism

Split individual tensor operations across devices.

Pipeline parallelism

Different model layers execute on different devices.

Expert parallelism

Experts in MoE models distributed across devices.

Context parallelism

Long-sequence computation distributed across processors. Current vLLM documentation includes tensor, pipeline, data, expert, and context parallelism for inference.

Distributed training

Training across multiple compute devices or machines.

Multi-node training

Training across several physical servers.

Multi-GPU training

Training across several GPUs.

GPU and Accelerator Terms

GPU

Graphics Processing Unit.

TPU

Tensor Processing Unit.

NPU

Neural Processing Unit.

Accelerator

General term for specialized AI compute hardware.

VRAM

Memory attached to a GPU.

HBM

High-Bandwidth Memory.

CUDA

NVIDIA GPU software platform.

ROCm

AMD GPU software platform.

Kernels

Kernel

Low-level compute implementation executed on an accelerator.

Attention kernel

Optimized implementation of attention.

FlashAttention

Memory-efficient optimized attention family.

GEMM

General matrix multiplication. A core operation in neural-network inference.

Fused kernel

Multiple operations combined into one optimized kernel.

Performance Metrics

Latency

Time required for a request.

TTFT

Time to First Token.

TPOT

Time per Output Token.

Tokens per second

Generation throughput.

Requests per second

Server-level throughput.

Throughput

Amount of useful inference completed per unit of time.

GPU utilization

Percentage of accelerator capacity actively used.

Memory bandwidth

Rate at which data moves to and from accelerator memory.

Context-Length Terminology

Context window

Maximum token sequence available to a model during an inference operation.

Context length

Number of tokens within the active sequence.

Long-context model

Model engineered to process large sequences.

Context overflow

Input exceeds supported context.

Context truncation

Removing content to fit the context window.

Lost-in-the-middle effect

Model performance degradation when critical information appears deep inside long contexts.

Tokenization

Token

Atomic unit processed by a language model.

Tokenizer

Text-to-token conversion system.

BPE

Byte Pair Encoding. Common tokenizer construction technique.

SentencePiece

Tokenizer framework frequently used in open models.

Special token

Reserved token with structural meaning, such as beginning-of-sequence, end-of-sequence, or a tool-call marker.

Evaluation and Benchmarking

Benchmark

Standardized evaluation dataset or procedure.

Evaluation suite

Collection of benchmarks.

Accuracy

Proportion of correct outputs.

Pass@k

Probability that at least one of k generated solutions passes evaluation. Often used for coding.

Exact match

Prediction must exactly equal reference answer.

Human evaluation

People assess generated outputs.

LLM-as-a-judge

Another model evaluates output quality.

Arena evaluation

Models compared through user or judge preferences.

Contamination

Evaluation material appears in training data.

Benchmark saturation

Models approach the benchmark's useful performance ceiling.

Safety Evaluation

Red teaming

Actively testing systems for vulnerabilities or harmful behavior.

Adversarial evaluation

Testing with deliberately challenging inputs.

Jailbreak

Prompt designed to circumvent model behavioral controls.

Safety benchmark

Evaluation focused on undesirable or high-risk behavior.

Capability evaluation

Measurement of what a model can do.

Alignment evaluation

Measurement of how behavior conforms to desired constraints.

Small and Efficient Models

SLM

Small Language Model. Generally a relatively compact language model.

Compact model

Informal synonym for smaller model.

Edge model

Model optimized for constrained hardware.

Distilled model

Model trained from a larger teacher.

Quantized model

Model stored or executed using reduced numerical precision.

Model Routing

Model router

Component deciding which model handles a request.

Cascading

Try a cheaper model first and escalate when needed.

Model ensemble

Multiple models contribute to a result.

Mixture of models

Different complete models selected or combined dynamically. Do not confuse this with Mixture of Experts, which generally operates inside a single model architecture.

Agentic AI: Core Concepts

Agent

An AI agent is a software system in which an AI model participates in selecting actions or controlling the execution path toward an objective.

Input→Observe→Reason/Decide→Act→Observe result→Repeat

Typical properties include:

• goal-directed behavior
• multi-step execution
• tool selection
• environmental interaction
• state persistence
• error recovery
• planning or replanning
• termination criteria

Not every LLM application is an agent.

Related terms

Agentic system

A broader system containing one or more agents.

Agentic application

An application whose workflow includes meaningful model-controlled decisions.

Agentic workflow

A workflow containing some dynamic model-driven routing or action selection.

Agency

The degree to which a model controls workflow behavior.

Autonomy

How independently the system can operate without human intervention.

Bounded autonomy

Autonomy restricted by policies, permissions, scope, time, budget, tools, or approval gates.

Semi-autonomous agent

An agent that acts independently within defined boundaries but requires humans for certain steps.

Autonomous agent

An agent allowed to complete substantial sequences of actions without human approval.

Agent vs Workflow Terminology

This distinction is foundational.

Deterministic workflow

A predefined sequence where the developer decides the path.

Step A→Step B→Step C

Examples:

• ETL pipeline
• scripted chatbot
• traditional business process
• fixed API orchestration

AI workflow

A deterministic workflow containing AI inference. The model generates content, but does not meaningfully determine the workflow.

Upload PDF→Extract text→LLM summarizes→Save result

Agentic workflow

The model can select between possible actions.

Inspect request→decide whether to search web, query database, ask user, or calculate→execute→reassess

Fully dynamic agent loop

The model repeatedly determines what action should happen next until the goal is completed or a stop condition is reached.

The Agent Loop

Most agent architectures can be decomposed into the following stages.

Perception / Observation

The agent receives information about its environment.

Terms:

• observation
• environmental observation
• context
• state observation
• sensor input
• tool result
• event
• trigger
• signal
• feedback

Reasoning / Decision

The model determines what should happen next.

Terms:

• inference
• reasoning
• decision policy
• action selection
• deliberation
• decomposition
• routing
• planning
• replanning

Action

The agent affects the outside world.

Terms:

• tool call
• function call
• API call
• computer action
• command execution
• transaction
• side effect
• actuator
• write operation

Feedback

The agent receives the result of its previous action.

Terms:

• tool output
• execution result
• observation
• environment response
• reward
• verification result
• evaluator feedback

Termination

The system determines whether to stop.

Terms:

• stop condition
• termination criterion
• completion criterion
• success condition
• max-step limit
• timeout
• budget exhaustion
• escalation
• handoff

Reasoning and Planning Terms

Planning

Creating a sequence or structure of intended actions.

Planning types

Upfront planning

Plan before execution.

Dynamic planning

Plan evolves during execution.

Replanning

Revising the plan after receiving new information.

Hierarchical planning

High-level goals are decomposed into lower-level actions.

Task decomposition

Breaking a complex objective into subtasks.

Subgoal generation

Creating intermediate goals.

Plan-and-execute

One component generates a plan and another executes it.

Interleaved planning and execution

Planning happens repeatedly throughout execution.

Common Agent Reasoning Patterns

ReAct

Reason + Act. A model alternates between reasoning and external actions.

Think→Act→Observe→Think→Act

Plan-and-Execute

Two phases: a Planner produces a plan and an Executor carries it out, often followed by replanning.

Reflexion

The system evaluates previous performance and uses feedback to improve subsequent attempts.

Self-critique

The model evaluates its own generated solution.

Self-reflection

A broader process where the system analyzes prior behavior or outcomes.

Chain-of-Thought

Intermediate reasoning steps used internally during problem solving. Reasoning alone does not create agency; an agent generally needs some ability to take actions or control workflow behavior.

Tree-of-Thought

Exploring multiple reasoning branches.

Graph-of-Thought

Reasoning represented as a graph rather than a simple sequence or tree.

Best-of-N

Generate several candidates and choose among them.

Self-consistency

Generate several reasoning paths and aggregate or select among resulting answers.

Tool-Use Terminology

Tool use is one of the defining capabilities of modern agents.

Tool

An externally callable capability available to the model.

Examples:

• calculator
• search engine
• database
• CRM
• shell
• code interpreter
• browser
• email API

Function calling

The model emits a structured request corresponding to an application-defined function, for example get_weather(city="Denver").

Tool calling

A broader term encompassing function calls, APIs, plugins, shell commands, browser actions, and other actions.

Native tool calling

Tool invocation supported directly by the model/API protocol.

Structured output

Model output constrained to a schema, usually JSON, JSON Schema, a typed object, XML, or grammar-constrained output.

Tool schema

Definition describing the tool name, purpose, parameters, types, and required fields.

Tool registry

Catalog of tools available to an agent.

Tool discovery

Dynamically identifying tools that may be relevant.

Tool routing

Selecting the appropriate tool.

Tool chaining

Using multiple tools sequentially.

Tool composition

Combining capabilities from multiple tools into a higher-level operation.

Tool result grounding

Using actual tool output rather than model recollection as the factual basis for subsequent reasoning.

Environment Interaction

Environment

The external world the agent can observe or modify, such as the web, an OS, a database, an application, a robot, or a game environment.

Action space

All actions available to an agent.

Observation space

All information the agent can observe.

State

The relevant current condition of the agent and environment.

State transition

Change caused by an action.

Side effect

An action that modifies external state, such as sending email, deleting a file, transferring money, or creating a calendar event.

Browser and Computer Agents

Browser agent

Agent that interacts with websites. Capabilities may include navigation, form filling, search, clicking, downloads, and extraction.

Computer-use agent

Agent that operates graphical applications through mouse, keyboard, screenshots, or UI representations.

GUI agent

Agent interacting primarily through graphical user interfaces.

Vision-language-action model

Model integrating visual perception, natural-language reasoning, and actions. Often abbreviated VLA, especially in robotics.

Screen grounding

Associating model instructions with specific visual screen regions or UI elements.

Coding Agents

Coding agent

An agent capable of performing software engineering tasks, such as inspecting a repository, modifying code, running tests, executing shell commands, inspecting failures, and iterating.

Software engineering agent

A broader coding agent designed for repository-level tasks.

Repository agent

Agent working against an existing codebase.

Code execution

Running generated or selected program code.

Sandbox

An isolated environment limiting what code or agents can access.

Execution environment

Runtime in which agent-produced commands are executed.

Agent Memory

Memory is often divided into several types.

Working memory

Information active during the current task, usually represented by the model's context.

Short-term memory

Information retained temporarily across several steps.

Long-term memory

Information persisted across longer periods or sessions.

Episodic memory

Memories of specific past interactions or events, e.g. "Last week this deployment failed because port 8080 was occupied."

Semantic memory

Persistent knowledge abstracted from individual events, e.g. "Production deployments require approval."

Procedural memory

Knowledge about how to perform tasks.

Conversation memory

Information from prior dialogue.

User memory

Persistent information about a particular user.

Agent state

Structured persistent information describing the ongoing execution.

Memory Implementations

Context window

The tokens currently available to a model during inference.

Context engineering

Designing what information enters the model's context and how it is organized. This increasingly replaces the narrower concept of merely "prompt engineering."

Context management

Selecting, compressing, removing, or retrieving context.

Context compression

Reducing information while preserving relevant meaning.

Summarization memory

Compressing previous interactions into summaries.

Vector memory

Storing embeddings and retrieving semantically similar content.

Key-value memory

Structured memory indexed by explicit keys.

Graph memory

Memory represented through entities and relationships.

Retrieval and RAG

RAG

Retrieval-Augmented Generation. External information is retrieved and supplied to the model during inference.

Query→Retrieve→Rank→Context→Generate

Agentic RAG

An agent controls one or more retrieval decisions.

Determine information need→choose database→formulate query→retrieve→inspect→reformulate→retrieve again

Retriever

System that identifies potentially relevant information.

Dense retrieval

Retrieval based on vector embeddings.

Sparse retrieval

Lexical retrieval techniques such as BM25.

Hybrid retrieval

Combination of lexical and semantic retrieval.

Reranker

Model that rescales retrieved results for relevance.

Embedding

Vector representation of semantic or structural information.

Vector database

Database optimized for vector similarity retrieval.

Chunking

Splitting documents into retrievable sections.

Semantic search

Retrieval based primarily on semantic similarity.

Grounding

Connecting generated responses to external evidence.

Orchestration

Agent orchestration

Coordination of agents, tools, models, workflows, and state.

Orchestrator

Component responsible for coordinating execution.

Router

Component selecting a model, agent, tool, workflow, or knowledge source.

Dispatcher

Component assigning tasks to workers.

Scheduler

Determines when tasks execute.

Workflow engine

Infrastructure for executing defined processes.

State machine

Workflow modeled as explicit states and transitions.

Graph workflow

Workflow represented as nodes and edges.

DAG

Directed Acyclic Graph. Common representation of workflows where tasks have dependencies but do not loop. Agent systems often require richer graphs because agents frequently loop.

Multi-Agent Systems

Multi-agent system

A system containing multiple agents that interact.

Agent team

Group of agents cooperating toward a shared goal.

Agent swarm

A decentralized or loosely coordinated group of agents. The term is often used loosely and should not automatically imply swarm-intelligence algorithms.

Supervisor agent

Higher-level agent coordinating other agents.

Worker agent

Agent delegated a narrower task.

Specialist agent

Agent configured for a particular domain.

Manager-worker architecture

Manager decomposes and delegates tasks.

Hierarchical agents

Agents organized in levels.

Peer agents

Agents operating at equivalent organizational levels.

Agent delegation

One agent assigns work to another.

Agent handoff

Responsibility is transferred from one agent to another.

Agent collaboration

Multiple agents jointly solve a task.

Agent debate

Multiple agents independently reason and challenge proposed answers.

Consensus mechanism

Procedure for combining or selecting conclusions from multiple agents.

Blackboard architecture

Agents communicate indirectly through a shared state or workspace.

Human-Agent Interaction

Human-in-the-loop — HITL

A person actively participates in execution or decision-making.

Human-on-the-loop — HOTL

A system acts autonomously but a human supervises and can intervene.

Human-out-of-the-loop

Execution occurs without routine human intervention.

Approval gate

A step requiring human authorization.

Escalation

Agent transfers responsibility to a human or higher-authority process.

Intervention

Human overrides, stops, or modifies agent behavior.

Override

Mechanism allowing human control to supersede agent decisions.

Agent Permissions and Security

Least privilege

Give an agent only the permissions it requires.

Capability security

Access is granted through specific capabilities rather than broad authority.

Scoped credentials

Credentials restricted to defined resources or operations.

Permission boundary

Limit specifying actions an agent may perform.

Read-only tool

Tool unable to modify state.

Write-capable tool

Tool that can change external state.

Privileged action

Action carrying elevated risk, such as deletion, payments, or administrative changes.

Action confirmation

Explicit approval before consequential actions.

Sandbox escape

Unauthorized movement outside the intended execution environment.

Prompt and Agent Security Terms

Prompt injection

Instructions from untrusted content attempting to manipulate model behavior.

Direct prompt injection

Malicious instruction entered directly by a user.

Indirect prompt injection

Malicious instructions embedded in external content the agent reads, such as webpages, documents, emails, or database records.

Instruction hierarchy

Rules governing precedence among instructions.

Tool poisoning

Manipulation of tool metadata, descriptions, or outputs to induce harmful agent behavior.

Memory poisoning

Planting malicious or misleading content into persistent agent memory.

Retrieval poisoning

Manipulating information likely to be retrieved by a RAG system.

Data exfiltration

Unauthorized disclosure of information.

Confused deputy

An agent uses its privileges on behalf of an entity that lacks those privileges.

Agent Reliability

Hallucination

Generated information unsupported by evidence or reality.

Tool hallucination

Attempt to use nonexistent tools or unsupported parameters.

Planning failure

Plan is logically invalid or inadequate.

Execution failure

An intended action fails.

Error recovery

System adapts after failure.

Retry

Repeating an operation.

Backoff

Waiting increasingly long between retries.

Fallback

Alternative path used when preferred behavior fails.

Circuit breaker

Mechanism stopping repeated failing operations.

Idempotency

Repeated execution produces no additional side effects after the first successful operation. Important for agents that retry actions.

Agent Evaluation

Agent evaluation / Agent eval

Assessment of an agent's behavior and outcomes.

Task success rate

Percentage of tasks successfully completed.

Step success rate

Percentage of individual actions successfully executed.

Tool accuracy

How often the correct tool is chosen and invoked correctly.

Trajectory evaluation

Assessment of the sequence of actions taken.

End-state evaluation

Assessment based primarily on final outcome.

Path efficiency

Whether the agent reached the result efficiently.

Cost efficiency

Performance relative to compute or API cost.

Latency

Elapsed execution time.

Reliability

Consistency across repeated executions.

Robustness

Ability to operate under unusual, adversarial, or changing conditions.

Agent Observability

Trace

Record of an agent execution.

Span

Individual operation within a trace.

Agent trajectory

Sequence of observations, decisions, actions, and results.

Execution log

Detailed record of runtime events.

Tool trace

Record of tool calls and outputs.

Token usage

Tokens consumed by model inference.

Cost trace

Cost attributed to steps, tools, or models.

Agent telemetry

Operational metrics collected from agent activity.

Replay

Re-running or reconstructing a previous execution.

Agent Protocols and Interoperability

MCP — Model Context Protocol

A protocol architecture for exposing contextual resources, tools, and related capabilities to AI applications. Key vocabulary includes MCP client, MCP server, host, tools, resources, prompts, transports, and capability negotiation.

Agent-to-Agent protocol / A2A

A family of protocol concepts intended to allow agents or agentic systems to interact with one another. Typical concerns include agent discovery, capability representation, delegation, task status, artifact exchange, and authentication.

Agent interoperability

Ability for independently built agents and tools to work together.

Agent discovery

Finding another agent and determining its capabilities.

Capability declaration

Machine-readable description of what an agent can do.

Agent Identity

Agent identity

Persistent identity assigned to an agent.

Agent principal

The security identity under which the agent acts.

Delegated authority

Permissions given to an agent by a user or another system.

Service identity

Machine identity used for application authentication.

Agent credential

Authentication material used by an agent.

Agent Persistence

Persistent agent

Agent whose state survives individual execution sessions.

Long-running agent

Agent executing over extended periods.

Background agent

Agent executing independently of an active conversation.

Event-driven agent

Agent invoked by events.

Scheduled agent

Agent triggered according to time schedules.

Reactive agent

Agent triggered by changes in its environment.

Proactive agent

Agent initiates activity based on goals or predictions rather than waiting for direct instructions.

Agent Architecture Components

A production agent stack commonly contains layers that pass control from the user down to external systems and back through evaluation and observability.

1. User
2. Interface
3. Orchestrator
4. Model
5. Planner / Router
6. Tools + Retrieval + Memory
7. External Systems
8. Evaluation / Guardrails / Observability

Relevant terms include:

• inference layer
• orchestration layer
• tool layer
• memory layer
• knowledge layer
• policy layer
• evaluation layer
• observability layer
• identity layer
• execution layer

Agent Framework Terminology

Modern agent frameworks commonly expose concepts such as agent, tool, model, executor, graph, node, edge, workflow, state, memory, checkpoint, message, event, callback, trace, planner, router, handoff, and guardrail. Framework implementations differ considerably; for example, Hugging Face's smolagents distinguishes agents that express actions through generated code from agents that use structured tool calls, and models them as multi-step agents.

Guardrails

Guardrail

Mechanism constraining or validating AI behavior.

Input guardrail

Checks incoming requests.

Output guardrail

Checks generated content.

Tool guardrail

Controls tool usage.

Execution guardrail

Controls runtime behavior.

Policy engine

System evaluating actions against defined policies.

Schema validation

Checking structured output against an expected format.

Semantic validation

Checking whether output meaning satisfies constraints.

Verification

Verifier

System determining whether an answer or action is valid.

Critic

Model or component that identifies deficiencies.

Judge model

Model used to score or compare outputs.

Reward model

Model assigning reward estimates.

Process reward model

Evaluates intermediate reasoning or solution steps.

Outcome reward model

Evaluates final result.

Agent Economics

Cost per task

Total compute/API expenditure for completing a task.

Token cost

Inference expense tied to token usage.

Tool cost

Cost caused by external calls.

Compute budget

Maximum resources an agent may consume.

Token budget

Maximum allowed token usage.

Step budget

Maximum number of agent iterations.

Latency budget

Maximum acceptable execution time.

Production Agent Lifecycle

An enterprise agent often passes through a lifecycle from design to governance.

1. Design
2. Build
3. Evaluate
4. Secure
5. Deploy
6. Observe
7. Improve
8. Govern

Design

• task analysis
• workflow design
• tool design
• memory design

Build

• prompt engineering
• context engineering
• tool integration
• orchestration

Evaluate

• offline evals
• online evals
• regression testing
• adversarial testing

Deploy

• model serving
• agent runtime
• containerization

Operate

• observability
• tracing
• monitoring
• incident response

Govern

• access control
• audit
• policy
• data governance

Frequently Confused Terms

Compact Master Taxonomy

If you need a single mental map, the whole field reduces to this hierarchy.

Two corrections worth repeating: “open model,” “open-weight model,” and “Open Source AI” are not synonyms — OSAID requires broad freedoms plus code, parameters, and sufficient data information, not merely published weights. And “agent” is not a synonym for any LLM app: the practical threshold is whether model output materially controls what happens next.

Spotted something to add or refine? The vocabulary of open AI belongs to the community.