Vocabulary for building AI agents that plan, act, and recover from failure in production systems.
An AI system that can autonomously take a sequence of actions to complete a goal, rather than just producing a single response. It decides what to do next based on observations from previous steps.
Information an agent can store and retrieve across steps or even across sessions. Typically categorized as in-context memory (inside the prompt), external memory (a database), and episodic memory (records of past interactions).
The repeated cycle an agent runs: observe the current state, think about what to do next, take an action, observe the result, repeat — until the goal is met or a stopping condition is hit.
A prompting technique where the model is instructed (or trained) to write out its reasoning step by step before producing a final answer, which tends to improve accuracy on complex tasks.
Deliberately designing what goes into the model's context — system prompt, retrieved docs, tool outputs, prior turns — rather than treating the prompt as an afterthought.
The maximum amount of text (measured in tokens) an LLM can process in a single call. Everything the agent knows about the current task must fit inside this window.
A fixed-length list of numbers (a vector) that encodes the meaning of a piece of text so that semantically similar texts end up with numerically similar vectors.
A test suite that runs an agent against a fixed set of tasks and scores its outputs automatically, so changes to a prompt or model can be compared side by side.
A backup model an application switches to automatically when the primary model is unavailable, rate-limited, or returns a bad response.
A model output formatted as a structured call to a specific tool with named arguments, instead of plain text describing what it wants to do.
Tying a model's claims to a verifiable source, like a document or a tool result, instead of letting it answer purely from its own trained knowledge.
Constraints put around an agent's behavior to prevent harmful, out-of-scope, or unintended actions. Can be implemented as input/output filters, tool restrictions, or a separate validator model.
A model confidently generating information that sounds plausible but is fabricated or wrong. In agentic systems this is especially dangerous because the agent may act on false information.
A design pattern where the agent pauses at defined checkpoints and waits for a human to review or approve before continuing — rather than running fully autonomously.
A property of an action where running it twice with the same input has the same effect as running it once, so a retry after a timeout can't cause double damage.
Logic that notices when an agent is repeating the same action or getting the same result over and over, so the system can break out instead of burning budget indefinitely.
An open standard (introduced by Anthropic) that defines a common interface for connecting LLMs to external tools and data sources, so any compliant tool can plug into any compliant agent without custom integration code.
An architecture where multiple specialized agents collaborate on a task, each handling a different sub-problem, with some orchestrating mechanism routing work between them.
The ability to see what an agent actually did step by step after the fact, through logs, traces, and metrics, rather than just its final answer.
A component (often itself an LLM) that manages the overall workflow: deciding which sub-agent or tool to invoke next, passing outputs between steps, and tracking progress toward the goal.
The component or step that decides what sequence of actions an agent should take, kept separate from the steps that actually execute those actions.
Storing a prefix of a prompt (like a long system prompt or document) on the provider's side so repeated calls skip re-processing it, cutting cost and latency.
An attack where malicious content in the agent's environment (e.g. a web page it reads, a document it processes) contains instructions designed to hijack the agent's behavior.
A pattern where relevant documents or data are fetched from an external store at query time and injected into the context window, so the model can answer using up-to-date or domain-specific knowledge it wasn't trained on.
A cap on how many requests or tokens an agent can send in a given window, enforced by the API provider or the app itself, to avoid overload or runaway cost.
A prompting pattern where the model alternates between Reasoning (thinking out loud) and Acting (calling a tool). Each cycle of thought → action → observation tightens the agent's approach.
A pass where an agent reviews its own previous output or action result and decides whether to revise it, retry it, or move on.
Code that automatically re-attempts a failed action a limited number of times, usually with a growing delay between tries, before giving up.
A setting that controls how much randomness goes into picking a model's next word, where low values make output predictable and high values make it more varied.
An isolated execution environment where an agent's actions, like running generated code, are contained and can't touch the real system or network.
Limiting exactly which actions and data an agent's tools are allowed to touch, so a bug or bad decision can only cause damage within that narrow boundary.
A model of an agent's workflow as a fixed set of states with defined transitions between them, so at any point there's exactly one current state and a known set of next moves.
Sending a model's response back piece by piece as it's generated, instead of waiting for the whole thing to finish before showing anything.
Model output constrained to a fixed schema, like a defined JSON shape, so downstream code can parse it without guessing at the format.
A smaller agent spun up by a parent process to handle one narrow piece of a larger task, then reports its result back and shuts down.
A hidden instruction block prepended to every conversation that tells the model its role, constraints, available tools, and behavioral rules. It's the developer's primary way of shaping agent behavior.
Breaking a large, ambiguous goal into smaller ordered subtasks that can each be handled with a single reasoning step or tool call.
The rule that tells an agent when to stop looping and return a final answer, whether that's reaching the goal, hitting a step limit, or running out of budget.
The planned or enforced limit on how many tokens an agent is allowed to use across a task — balancing capability (more tokens = more thinking) against cost and latency.
A structured definition (usually JSON Schema) that describes a tool's name, what it does, and what parameters it accepts. The model reads this to know how and when to call the tool.
The ability of an LLM to call predefined functions or external APIs as part of generating a response. The model outputs a structured call (e.g. search(query='...')) and the host application actually executes it.
A database optimized for storing and searching high-dimensional numerical vectors. In agentic systems it's used to find semantically similar documents quickly — the backbone of most RAG implementations.