Reference shelf

Glossary

Every agent term, crisply defined and cross-linked.

Written by Claude Opus 4.8

Every core term in this course, defined crisply. Filter to find one fast, or skim it end to end to see how the pieces connect.

A2A: Agent-to-agent interoperability. Protocols that let agents built by different teams or vendors discover and call each other.
Agent: A system that uses an LLM to decide its own actions in a loop, calling tools and reacting to results, rather than following a fixed script.
Agent loop: The core cycle an agent repeats: reason about the goal, act through a tool, observe the result, and decide whether it is done.
Agentic RL: Reinforcement learning that trains a model on full multi-step tool-use trajectories, rewarding outcomes rather than single next tokens.
Chain of thought: Prompting or training the model to write intermediate reasoning steps before its answer, which improves accuracy on multi-step problems.
Chunking: Splitting documents into passages small enough to embed and retrieve precisely, while keeping each chunk coherent. It quietly decides RAG quality.
Computer use: An agent that operates a real computer or browser by reading the screen and issuing clicks and keystrokes, acting where no API exists.
Constrained decoding: Forcing the model to only emit tokens allowed by a grammar or schema at each step, guaranteeing valid structured output.
Context engineering: Deliberately managing what goes into the context window each turn: what to keep, summarize, retrieve, or drop, so the model has what it needs and no noise.
Context window: The finite budget of tokens a single model call can consider at once, covering the system prompt, history, retrieved data, and the response being written.
Embedding: A vector of numbers representing the meaning of text, so that similar meanings sit close together and can be compared by distance.
Episodic memory: A record of past interactions or runs the agent can recall later, giving it continuity across sessions.
Eval: A repeatable test that scores an agent's behavior on fixed cases, so you can measure quality and catch regressions instead of vibe-checking.
Few-shot: Including a handful of worked examples in the prompt so the model imitates the pattern, format, or style you want.
Function calling: The mechanism behind tool use: the model emits a structured call with a name and JSON arguments, your code runs it, and the result returns as an observation.
Guardrail: A validation layer around the agent loop that checks inputs and outputs against rules, blocking unsafe or malformed actions.
Handoff: Transferring control and relevant context from one agent to another better suited to the next part of the task.
Human in the loop: Inserting a person to approve, correct, or intervene at key steps, trading autonomy for safety on high-stakes actions.
Lethal trifecta: The dangerous combination of access to private data, exposure to untrusted content, and the ability to act or exfiltrate. Any two are safer than all three.
LLM-as-judge: Using a model to grade another model's output against a rubric, a cheap way to scale evaluation of open-ended tasks.
MCP: Model Context Protocol. An open standard for connecting agents to tools and data sources through a common interface, the USB-C of tool integration.
Multi-agent system: Several specialized agents working toward one goal, coordinated by routing, delegation, or conversation.
Observability: The ability to see inside a running agent: its reasoning, tool calls, inputs, outputs, cost, and latency, so you can debug and improve it.
Orchestration: The layer that decides which agent or step runs when, passes context between them, and manages handoffs.
Planning: Producing a sequence of steps toward a goal before or during execution, from simple plan-and-execute to tree search over options.
Prompt injection: An attack where untrusted content (a web page, a document, a tool result) carries instructions that hijack the agent's behavior.
RAG: Retrieval-augmented generation. Fetch relevant passages from an external store and put them in the prompt so the model answers from real, current data.
ReAct: Reasoning and Acting. The model writes a short thought before each action, so tool choices are explicit and the trace is debuggable.
Reasoning model: A model post-trained to spend extra tokens thinking before answering. It trades latency and cost for accuracy on hard problems.
Reflection: Having the agent critique its own output against the goal and revise, catching errors that a single forward pass would ship.
Reranking: A second, slower pass that reorders retrieved candidates by relevance to the query, improving precision after fast vector recall.
Sampling: How the model turns its probability distribution over next tokens into one chosen token, controlled by temperature, top-p, and top-k.
Semantic memory: Durable facts and knowledge the agent stores and retrieves, distinct from the moment-to-moment working context.
Semantic search: Finding text by meaning rather than exact keywords, by embedding the query and returning the nearest stored vectors.
Structured output: Model output constrained to a machine-readable format, usually JSON conforming to a schema, so the calling program can parse it without guessing.
System prompt: The standing instructions that define an agent's role, tools, constraints, and output contract, separate from the per-turn user input.
Task decomposition: Breaking a large goal into smaller subtasks the agent can tackle one at a time, often delegated to workers.
Temperature: A sampling dial that scales how sharp the distribution is. Near zero is nearly deterministic; higher values make rarer tokens more likely.
Test-time compute: Spending more computation at inference (longer reasoning, sampling multiple answers) to raise quality, rather than training a bigger model.
Thinking budget: A cap on how many reasoning tokens a model may spend on a turn, trading accuracy against cost and latency.
Token: The unit a model reads and writes, roughly a word piece. Tokens are the unit of cost, latency, and context length.
Tool use: Letting the model call typed functions (search, code execution, an API) to affect the world, instead of only producing text.
Top-p: Nucleus sampling. Keep the smallest set of tokens whose probabilities sum to p, then sample within that set, trimming the unlikely tail.
Tracing: Recording the full step-by-step trace of an agent run (each call, tool, and result) as a linked timeline for inspection.
Vector database: A store that indexes embeddings for fast nearest-neighbor search, the retrieval engine behind semantic search and RAG.
Working memory: What the agent holds in its active context right now: the current task, recent steps, and tool results.