Glossary
Every agent term and abbreviation, expanded and explained in one place — from ACI and blast radius to ReAct, MCP, trajectory, and idempotency
Glossary
How to use this page
Every term and abbreviation used anywhere in this section, expanded and explained in plain language. Organised A–Z. Where a concept has a full explanation elsewhere, the entry links to it.
| Property | Value |
|---|---|
| Level | All levels — reference |
| Reading time | Reference; skim or search |
| Prerequisites | None |
| You will understand | Every piece of agent vocabulary you are likely to encounter |
A
| Term | Expansion | Meaning |
|---|---|---|
| ACI | Agent-Computer Interface | The surface an agent actually sees: tool names, descriptions, schemas, and error messages. Improving it usually returns more than changing the model |
| Action | — | Anything the agent does outside its own text. In practice, a tool call |
| Agent | — | A model that decides its own next step, in a loop, using tools, until it reaches a goal. See What Is an Agent? |
| Agentic workflow | — | A confusing term used for both real agents and fixed pipelines with model calls in them. Ask which one is meant |
| Approval gate | — | A point where a person must confirm before an action executes. Reserved for irreversible or expensive actions, because gating everything destroys the attention it depends on |
| Autonomy | — | How much the agent decides without a human. A dial, set by what a wrong action costs — not a switch |
B
| Term | Expansion | Meaning |
|---|---|---|
| Backoff | — | Increasing the delay between retries so a struggling dependency is not hammered |
| Blast radius | — | How much damage one mistaken action can do. Grow it only as fast as your evidence: read-only, then bounded writes, then money |
C
| Term | Expansion | Meaning |
|---|---|---|
| Cap | — | A hard limit enforced by your code — iterations, tokens, cost, wall-clock. A limit in the prompt is a request, not a cap |
| Chaining | — | Fixed steps run in a fixed order. A workflow pattern, not an agent |
| Circuit breaker | — | Stopping calls to a tool that is failing for everyone, until it recovers |
| Compaction | — | Replacing an old, verbose transcript with a compact summary so a long run stays inside the context window. See Context Engineering |
| Context engineering | — | Deciding what goes into the prompt, in what order, at every step. The main lever on agent quality after tools |
| Context window | — | The maximum tokens a model can process in one call — prompt plus output |
| Cost per task | — | The cost metric that matters. Per-call cost looks healthy while an agent takes fifteen steps to do a two-step job |
| Critic | — | A model or check that reviews another model's output. See Evaluator-optimizer |
D
| Term | Expansion | Meaning |
|---|---|---|
| Decomposition | — | Breaking a goal into named subtasks before working on them. See Planning & Reasoning |
| Delegation | — | An orchestrator handing a subtask to a specialist agent |
| Done criteria | — | The explicit definition of a finished task. Missing criteria are the most common cause of loops and of stopping too early |
| Drift | Goal drift | Losing track of the original goal partway through a run, usually because it is buried in the middle of a long transcript |
E
| Term | Expansion | Meaning |
|---|---|---|
| Episodic memory | — | Records of specific past events — this user, this ticket, this decision — as opposed to general facts |
| Evaluation set | — | The labelled cases an agent is tested against: input, expected outcome, and often the expected trajectory. Must be run several times per case |
| Evaluator-optimizer | — | A pattern where one model produces and another critiques, looping until the critique passes. Expensive; use where quality outranks cost |
| Exit condition | — | See Done criteria, and the caps that stop a run regardless |
F
| Term | Expansion | Meaning |
|---|---|---|
| Function calling | — | The mechanism by which a model requests that your code run a named function with structured arguments. See Tools & Function Calling |
G
| Term | Expansion | Meaning |
|---|---|---|
| Guardrail | — | A check in code that blocks unsafe input, output, or action. Enforced in the harness, never merely requested in the prompt |
H
| Term | Expansion | Meaning |
|---|---|---|
| Hallucination | — | A fluent, confident, false statement. In agents it most often follows a tool failure the model read as data |
| Handoff | — | Passing control and context from an agent to another agent or to a person. A designed path with a summary and the trace attached, not an error message |
| Harness | — | Your code around the model: the loop, the tool executor, the caps, the logging. Where every real control lives |
| Human in the loop | HITL | A person approving or reviewing an action before it takes effect |
I
| Term | Expansion | Meaning |
|---|---|---|
| Idempotency key | — | An identifier that makes a repeated call a no-op. Essential because agents retry on their own initiative and cannot tell a lost response from a failed action |
| Iteration cap | — | The maximum number of loop passes before the run stops. Typically 10–25. Raising it is rarely the fix for an agent that keeps hitting it |
L
| Term | Expansion | Meaning |
|---|---|---|
| Least privilege | — | Each tool holds the narrowest access that works, scoped per tool rather than per agent |
| Long-term memory | — | Facts that persist across sessions — preferences, past decisions, account history — stored in a database and retrieved when relevant. See Memory |
| Loop rate | — | How often runs end by hitting the iteration cap. Should be near zero; a rise is an early alarm |
| Lost in the middle | — | The tendency of models to attend less reliably to material in the middle of a long context. Why appending everything makes agents worse, not better |
M
| Term | Expansion | Meaning |
|---|---|---|
| MCP | Model Context Protocol | An open standard for exposing tools and data sources to models, so integrations are written once rather than per application |
| Memory | — | Everything you build to compensate for the model remembering nothing between calls. Working, short-term, and long-term |
| Multi-agent system | — | Several coordinating agents. Multiplies cost, latency, and failure modes — justified only when one agent has measurably failed. See Multi-Agent Systems |
N
| Term | Expansion | Meaning |
|---|---|---|
| Non-determinism | — | The same input can take a different path on every run. Why a single passing test proves almost nothing |
O
| Term | Expansion | Meaning |
|---|---|---|
| Observation | — | The result of a tool call, appended to the conversation as the input to the next decision |
| Orchestrator | — | An agent that plans and delegates to worker agents. A single point of failure by construction |
| Outcome | — | Whether the agent reached the right result. Half of evaluation; the other half is trajectory |
P
| Term | Expansion | Meaning |
|---|---|---|
| Parallel tool calls | — | Several independent tool requests issued in one step and executed concurrently. Cuts wall-clock time without changing step count |
| Plan-and-execute | — | Writing the whole plan first, then carrying it out — with revision allowed. Usually worth it past about three steps |
| Prompt caching | — | Reusing the processed form of an unchanging prompt prefix across calls. Large saving for agents, because the system prompt and tool definitions repeat on every step of every task |
| Prompt injection | — | Malicious instructions hidden in content the agent reads — a web page, an email, a ticket. Not fully solvable by prompting; managed by limiting what a successful injection can reach |
R
| Term | Expansion | Meaning |
|---|---|---|
| ReAct | Reason + Act | The think–act–observe loop: the model reasons, requests a tool, reads the result, and repeats. The default single-agent pattern. See The Agent Loop |
| Reflection | — | An agent reviewing its own output or progress before continuing. Cheap quality gain on quality-sensitive work |
| Router | — | A classifier that sends each request down one of several paths. Often the highest-return component in an agent system, because it keeps easy traffic off the expensive path |
| Runaway | — | A loop that keeps going and keeps spending. Prevented by caps, not by instructions |
S
| Term | Expansion | Meaning |
|---|---|---|
| Sandbox | — | An isolated environment for running model-generated code: no network, no persistent storage, no credentials, hard CPU and time limits |
| Scratchpad | — | Space where the model writes its reasoning before acting. The reasoning half of ReAct |
| Short-term memory | — | The current conversation, carried across turns within a session |
| Step | — | One pass of the loop: one model call, and usually one or more tool calls. The unit that drives both latency and cost |
| Stop reason | — | Why a run ended: finished, capped, errored, or handed off. Log it; a truncated run that answered anyway is otherwise invisible |
| Structured output | — | Model output constrained to a schema, so your code can consume it without parsing prose |
| Subagent | — | An agent invoked by another agent to handle one narrow job |
| System prompt | — | The standing instructions sent on every call: role, rules, and what "done" means |
T
| Term | Expansion | Meaning |
|---|---|---|
| Task success rate | — | Fraction of tasks completed correctly. The headline metric; everything else explains it |
| Token | — | The unit models read and bill by. Roughly ¾ of a word in English |
| Tool | — | A function the model can request that your code run. Without tools you do not have an agent |
| Tool description | — | The natural-language text telling the model what a tool does and when to use it. It is a prompt, not documentation — and it is the main cause of wrong tool choices |
| Tool schema | — | The structured definition of a tool's parameters. Enums and required fields prevent a whole class of bad arguments |
| Trace | — | The logged record of a run: every thought, tool call, argument, result, duration, and token count. Without it, agents are not debuggable |
| Trajectory | — | The path an agent actually took. Measured alongside outcome, because a right answer reached by a poor route will not stay right |
| Turn | — | One exchange with the user. A single turn may contain many agent steps |
W
| Term | Expansion | Meaning |
|---|---|---|
| Worker | — | An agent given one narrow job by an orchestrator. Also called a specialist |
| Working memory | — | The state of the current task: the goal, the plan, what has been tried, what has been found. Distinct from the raw transcript |
| Workflow | — | A fixed sequence of steps, possibly with model calls inside. Predictable, cheap, testable — and the right answer far more often than "agent" is |
The Terms Most Often Confused
Pairs worth keeping straight
Agent vs Workflow
A workflow runs steps you wrote down in advance; an agent decides its own path at run time. The distinction is not about sophistication — it is about who chooses the sequence. If you can write the steps down, a workflow gives you the same result cheaper, faster, and testable, which is why most systems described as agents should not be.
Outcome vs Trajectory
Outcome is whether the final result was right; trajectory is whether the route there made sense. They come apart constantly: an agent that guesses and happens to be correct scores a perfect outcome and will fail the next similar task. Measuring only outcome means you cannot tell a reliable agent from a lucky one.
Trace vs Trajectory
The trajectory is the path the agent took; the trace is your logged record of it. The trajectory exists whether or not you captured it — which is exactly the problem when you did not. One is the behaviour, the other is the evidence.
Working memory vs Long-term memory
Working memory is the state of the task in front of you — goal, plan, findings — and it is thrown away when the task ends. Long-term memory is what survives: preferences, history, decisions, stored externally and retrieved when relevant. Conflating them produces either an agent that forgets mid-task or a database full of transcript noise.
Orchestrator vs Router
A router classifies once and sends the request down a single path; it then steps out of the way. An orchestrator stays in charge, decomposing the task, delegating subtasks, and assembling the results. A router is cheap and nearly always worth adding; an orchestrator is a multi-agent system with all the cost and failure modes that implies.
Guardrail vs Prompt instruction
A guardrail is enforced by your code and the model cannot talk it out of anything. A prompt instruction is a request the model usually honours and that injected text can override. "Do not access other accounts" in a system prompt is an instruction; the same check inside the tool is a guardrail. Only one of them is a control.
Tool error vs Empty result
"Nothing matched your query" and "the service is down" mean opposite things and demand opposite responses, yet both often arrive as an empty list. The agent then reasons confidently from a non-fact. Make failures structurally distinguishable from genuine emptiness — it removes a whole family of confident wrong answers.
Reflection vs Evaluator-optimizer
Reflection is an agent reviewing its own work inside its own loop — cheap, and it catches obvious problems. An evaluator-optimizer uses a separate critic with its own context, which catches things the author is blind to but doubles the cost and adds a second thing that can be wrong. Start with reflection.
Where to Go Next
You have completed the agent fundamentals. The natural next step is to build something:
| Path | Start here |
|---|---|
| Build your first agent | Tool Calling Agent |
| Add the core patterns | ReAct Agent and Planning Agent |
| Study coordination | Orchestration Patterns and Multi-Agent System |
| See complete production systems | Case Studies |
Designing an Agent System
A complete worked example — gathering requirements, deciding whether you need an agent at all, sizing the run, choosing every component with reasons, and planning the rollout
Orchestration Patterns
A map of the main agent orchestration patterns — routing, chaining, parallelization, orchestrator-workers, and evaluator-optimizer — and which project on this site teaches each