AI Glossary
367+ production AI terms, organized by chapter.
Search across every term, or browse by chapter — from agentic AI and RAG to LLMOps, evaluation, and MCP.
60 results
AI AgentAn AI agent is a system that pursues a goal by repeatedly deciding on actions, executing them through tools or the environment, and observing the results to inform its next step. Unlike a single model call, an agent runs a loop — perceive, decide, act — and maintains enough state to make progress across many steps toward an objective.Agent LoopThe agent loop is the repeating cycle an agent runs: it reads the current context, decides on the next action (often a tool call or a message), executes that action, and feeds the observation back into context. The loop continues until a stopping condition is met, such as reaching the goal, exhausting a step budget, or hitting a guardrail.Tool-Calling AgentA tool-calling agent is an AI agent that extends a language model's capabilities by invoking external functions — such as web search, code execution, or database queries — and incorporating the results into its reasoning. The model emits a structured tool-call request, a runtime executes the function, and the returned observation is appended to context before the model continues.ReAct AgentA ReAct agent interleaves explicit reasoning traces with concrete actions in a single generation pass. The model writes a thought explaining its current reasoning, then emits an action to execute, then observes the result — all as natural-language text. This thought-action-observation pattern makes the agent's decision process transparent and often improves performance on multi-step tasks.Autonomy LevelAutonomy level describes how much independent decision-making authority an agent has before a human must review or approve its actions. A fully automated agent acts end-to-end without human approval; lower autonomy levels insert checkpoints where a human confirms plans, approves high-risk tool calls, or validates intermediate outputs before the agent proceeds.Agent RuntimeThe agent runtime is the infrastructure layer that hosts and drives the agent loop. It manages prompt assembly, tool dispatch, state persistence, retry logic, and stopping conditions. The runtime sits between the raw language model API and the rest of the system, translating model outputs into real function calls and feeding observations back into the next prompt turn.Human-in-the-LoopHuman-in-the-loop refers to design patterns where a human operator is inserted into an otherwise automated agent pipeline at defined checkpoints. The human may review proposed actions, approve sensitive tool calls, resolve ambiguities, or correct errors before the agent continues. HITL trades throughput for safety and is essential in high-stakes deployments where unchecked autonomous action carries significant risk.Agent TrajectoryAn agent trajectory is the complete sequence of states, actions, and observations that an agent produces while working toward a goal. Capturing trajectories is essential for debugging, evaluation, and training: they reveal exactly which steps the agent took, where it diverged from the expected path, and whether its reasoning was coherent at each decision point.Action SpaceThe action space is the set of all actions an agent is permitted to take at any given step. It typically includes tool calls, sub-agent invocations, and terminal actions such as returning a final answer or requesting human input. Constraining the action space is a key safety lever: a narrower space reduces the surface area for unintended or harmful behavior.Agent EnvironmentThe agent environment encompasses everything external to the model that the agent can observe and affect. It includes file systems, APIs, databases, web browsers, or any other interface through which the agent reads information and commits changes. The environment's state changes as the agent acts, and those changes may be irreversible, which makes careful action selection critical.Agent StateAgent state is the information the agent carries across loop iterations to maintain continuity. It can include the conversation history, scratchpad notes, tool outputs, task status, and any accumulated facts. Because language models are stateless by default, the runtime must explicitly serialize and inject state into each prompt so the agent can reason coherently across many steps.Deterministic vs Non-Deterministic Agent BehaviorA deterministic agent produces the same sequence of actions given the same inputs and state, making it reproducible and easier to test. A non-deterministic agent — which arises from sampling-based language model inference — may take different paths on identical inputs. Production systems often reduce temperature or use structured outputs to increase determinism while accepting that some variability is unavoidable with generative models.Agent EvaluationAgent evaluation measures whether an agent reliably achieves its goals across a representative set of tasks and edge cases. Unlike single-call evals, agent evals must account for multi-step behavior: intermediate action quality, tool use correctness, step efficiency, and final outcome accuracy all matter. Trajectory replay, sandbox execution, and LLM-as-judge scoring are common evaluation techniques.Agent PersonaAn agent persona is the identity, tone, and behavioral constraints assigned to an agent through its system prompt. Personas establish how the agent introduces itself, what communication style it adopts, and what boundaries it respects. In multi-agent systems, distinct personas help differentiate agents by function — for example, a cautious reviewer versus an exploratory researcher — and can improve task specialization.Step BudgetA step budget is a hard upper limit on the number of loop iterations or tool calls an agent is allowed to make during a single task run. It prevents runaway loops from consuming unbounded compute or accumulating costs. When the budget is exhausted, the runtime typically returns the best answer found so far or raises an error signaling that the task could not be completed within the allowed steps.Agentic WorkflowAn agentic workflow is a pipeline in which one or more AI agents, rather than hard-coded logic, drive the sequencing and execution of steps toward a goal. The workflow may include planning, tool use, branching on observations, and self-correction. Compared to a fixed automation, an agentic workflow can adapt dynamically to unexpected intermediate results without requiring explicit rule authoring for every scenario.Orchestration vs Single-AgentA single-agent architecture uses one model instance to reason, plan, and act across all subtasks. An orchestrated architecture uses a coordinating agent to decompose tasks and delegate work to specialized sub-agents. Orchestration enables parallelism and specialization but introduces coordination overhead, failure propagation risks, and more complex debugging. The right choice depends on task complexity and latency requirements.Agent ObservabilityAgent observability refers to the tooling and practices that give operators visibility into an agent's runtime behavior — including which tools were called, what arguments were used, how long each step took, and where errors occurred. Good observability surfaces structured traces, logs, and metrics so engineers can diagnose failures, audit decisions, and optimize performance without rerunning the entire task from scratch.Guardrailed AgentA guardrailed agent operates under a set of enforced constraints that prevent it from taking harmful, out-of-scope, or policy-violating actions. Guardrails can be implemented at the prompt level, in the runtime as action filters, or as a separate validation model that reviews proposed actions before execution. Unlike soft instructions, effective guardrails reject or flag disallowed actions regardless of what the reasoning trace requests.Agent MemoryAgent memory covers the mechanisms by which an agent retains and retrieves information across turns and sessions. In-context memory lives in the active prompt window and is lost when the context resets. External memory stores facts in a vector database or key-value store that the agent can query as needed. The choice of memory architecture affects recall accuracy, latency, and the agent's ability to maintain long-horizon coherence.Agent HandoffAn agent handoff is the transfer of task control from one agent to another in a multi-agent pipeline. The handing-off agent packages the current task context, completed work, and remaining objectives into a structured message that the receiving agent can pick up without loss of continuity. Clean handoffs require well-defined interface contracts so the receiving agent does not need to re-derive context from scratch.Agentic RAGAgentic RAG extends basic retrieval-augmented generation by giving an agent control over when, what, and how to retrieve information. Rather than a single retrieval step before generation, the agent can issue multiple targeted queries, evaluate retrieved passages, decide whether more retrieval is needed, and synthesize across multiple sources across many loop iterations — making retrieval an active, iterative part of reasoning rather than a one-shot lookup.Least-Privilege AgentA least-privilege agent is granted only the minimum tool permissions and data access required for its current task, and nothing more. By narrowing the action space, this design limits the blast radius if the agent is compromised, confused, or manipulated by a prompt injection. Permissions are scoped per task rather than granted broadly, so a misbehaving agent cannot reach resources outside its intended boundary.Dry-Run ModeDry-run mode lets an agent plan and log the actions it intends to take while suppressing execution of any side-effecting tools. Operators can review the proposed trajectory — the sequence of tool calls and arguments — before enabling live execution. This containment technique is valuable during development and rollout, surfacing unsafe or incorrect behavior without risking real-world consequences like sent emails or deleted files.Agent SandboxAn agent sandbox is an isolated execution environment that confines what an agent's tools can touch — restricting filesystem, network, and secret access to an allowed boundary. Even if the agent generates malicious or buggy code, the sandbox prevents it from reaching sensitive host resources. Sandboxing is a foundational containment control for agents that run code or interact with untrusted inputs.Self-Healing AgentA self-healing agent detects when a tool call or step has failed and attempts recovery on its own — retrying with adjusted arguments, choosing an alternative tool, or replanning around the obstacle. Rather than halting on the first error, it treats failures as feedback within the agent loop. This resilience improves task completion rates but must be bounded by a step budget to avoid endless retry loops.PlanningPlanning is the process by which an agent reasons about a sequence of steps needed to achieve a goal before committing to action. A planner considers available tools, preconditions, and likely outcomes to produce an ordered strategy rather than reacting greedily step-by-step. Explicit planning often reduces errors on complex tasks by catching contradictions and dead ends early rather than discovering them mid-execution.Task DecompositionTask decomposition breaks a high-level objective into smaller, independently executable subtasks. By reducing scope at each step, the agent can tackle problems that exceed the reasoning capacity of a single prompt. Effective decomposition identifies natural dependencies between subtasks and produces chunks small enough to be reliably solved while large enough to avoid excessive overhead from coordination.Chain-of-ThoughtChain-of-thought prompting elicits intermediate reasoning steps from a language model before it produces a final answer. By generating a verbal walkthrough of the reasoning process, the model externalizes computation that would otherwise happen implicitly inside a single forward pass, catching errors and improving accuracy on arithmetic, logic, and multi-hop knowledge questions. CoT is a cornerstone technique for making model reasoning inspectable and correctable.Tree of ThoughtsTree of Thoughts treats problem solving as a search over a tree where each node is a partial reasoning state. Rather than following a single linear chain of thought, the model generates multiple candidate continuations at each step, evaluates their promise, and explores the most viable branches. This enables backtracking and broader exploration of the solution space at the cost of more model calls.ReAct ReasoningReAct reasoning is a prompting strategy that interleaves natural-language thought traces with discrete action commands in the same generation. The model writes a thought about what it knows and what it needs, emits an action, receives an observation, and continues. This cycle makes the model's planning process legible and enables recovery from mistakes because each thought can incorporate the latest observation before the next action is chosen.ReflectionReflection is a deliberate self-evaluation step in which an agent reviews its own outputs, reasoning traces, or past actions and identifies mistakes, gaps, or improvements. A reflecting agent generates a critique of what went wrong and uses that critique to revise its plan or output. Reflection can be triggered automatically after each step or reserved for situations where the agent detects low confidence or task failure.Self-CritiqueSelf-critique is the technique of prompting a model to act as its own critic: after producing an initial output or plan, the model is asked to identify flaws, missing considerations, or logical errors. The critique is then used to generate a revised response. Self-critique can be implemented in a single prompt with sequential generation or across separate model calls, and it substantially reduces elementary errors in complex reasoning tasks.Plan-and-ExecutePlan-and-execute is an agent architecture that separates planning from execution into distinct phases. A planner model or prompt first produces a structured step-by-step plan for the entire task, then an executor agent works through the plan one step at a time, potentially invoking tools and updating state. This separation allows the planner to reason holistically before any side effects occur, and it makes each step's intent explicit for auditing.GoalA goal is the desired end state or outcome that an agent is tasked with achieving. Goals can be specified as success conditions, natural-language descriptions, or structured objectives. Clear goal specification is critical for agent performance: ambiguous goals lead to misaligned behavior, while overly rigid goal definitions may cause the agent to miss obviously correct alternative solutions that satisfy the true intent.SubgoalA subgoal is an intermediate milestone that an agent must achieve as part of reaching a larger goal. Decomposing a complex objective into subgoals gives the agent a clearer and more tractable sequence to work through, and it enables progress monitoring: reaching each subgoal confirms the agent is on track. Subgoals also facilitate replanning — when a subgoal fails, only that branch of the plan needs revision.BacktrackingBacktracking is the ability of an agent to abandon an unsuccessful reasoning path or action sequence and return to an earlier decision point to try an alternative approach. Backtracking is especially valuable when the agent recognizes it is stuck or that the current path contradicts a known constraint. It requires the agent to maintain a record of prior states or plan branches so it can resume from a valid earlier checkpoint.Hierarchical PlanningHierarchical planning organizes a task as nested layers of abstraction: high-level plans specify major phases of work, while lower-level plans spell out concrete actions within each phase. An agent executing a hierarchical plan can reason at the appropriate level of detail for each decision, delegating fine-grained choices to lower-level sub-plans. This mirrors how humans organize complex projects and helps agents avoid losing the big picture while managing tactical details.ReplanningReplanning occurs when an agent revises its plan in response to unexpected observations, tool failures, or changed conditions discovered during execution. Rather than blindly following a stale plan, the agent pauses, re-evaluates the current state against the goal, and generates an updated plan that accounts for what it has learned. Replanning is a key component of robust agent behavior in dynamic or uncertain environments.ScratchpadA scratchpad is a designated section of the model's generation — or an external text buffer — where the agent can write intermediate calculations, notes, or partial reasoning before committing to a final answer or action. The scratchpad externalizes working memory, allowing the model to perform multi-step computation more reliably than attempting to compress all reasoning into a single token prediction. It also makes intermediate reasoning visible for debugging.DeliberationDeliberation is the process of spending additional compute — through extra reasoning steps, candidate generation, or evaluation passes — to arrive at a higher-confidence decision before acting. Deliberating agents trade latency for accuracy, investing more effort when stakes are high or ambiguity is great. Test-time compute scaling, best-of-N sampling, and iterative refinement are all forms of deliberation commonly applied to planning-heavy tasks.HeuristicIn the context of agent planning, a heuristic is a rule of thumb or scoring function that estimates the promise of a partial plan or reasoning path without guaranteeing optimality. Heuristics guide search by prioritizing which branches to explore first, enabling practical planning under time or compute constraints. Language models implicitly encode learned heuristics in their parameters; explicit heuristics can also be injected via prompts or external scoring models.Least-to-Most PromptingLeast-to-most prompting is a technique that teaches a model to first solve the easiest subproblem, use that solution to tackle the next slightly harder one, and build up incrementally to the full problem. This scaffolded approach exploits the model's ability to condition on correct earlier steps, dramatically improving performance on compositional reasoning tasks where jumping directly to the answer is error-prone.Self-ConsistencySelf-consistency is a decoding strategy that samples multiple independent reasoning paths for the same question and aggregates the final answers — typically by majority vote — to select the most reliable response. Because different reasoning chains may reach the same correct answer through varied routes, the ensemble is more robust than any single chain. Self-consistency is especially effective on tasks with verifiable answers and moderate output variance.Plan VerificationPlan verification is the step of checking a generated plan for correctness, feasibility, and completeness before execution begins. Verification can be performed by a separate critic model, a symbolic checker, or a set of automated tests against the plan's preconditions and expected outcomes. Catching invalid plans early prevents wasted tool calls and side effects from actions that would never have succeeded.Task GraphA task graph is a directed acyclic graph in which nodes represent individual subtasks and edges represent dependency relationships between them. An agent or orchestrator can schedule independent subtasks in parallel and sequence dependent ones, reducing total wall-clock time and making parallelism explicit. Task graphs also serve as an audit trail, showing exactly which subtasks were completed, which failed, and how the final result was assembled.Means-Ends AnalysisMeans-ends analysis is a planning strategy that repeatedly compares the current state with the goal state, identifies the largest difference between them, and selects an action or operator that reduces that difference. Borrowed from classical AI, it drives step-by-step progress toward a goal by always attacking the most significant remaining gap. Agents apply it to decide which subgoal or tool call most advances the objective.Plan MonitoringPlan monitoring is the continuous check of whether execution is still tracking the intended plan and whether the plan's assumptions still hold. When an observed result diverges from what a step expected, monitoring triggers replanning or backtracking rather than blindly continuing. This closed-loop supervision keeps an agent robust in dynamic environments where earlier assumptions can become invalid partway through a task.Goal ConditioningGoal conditioning is the practice of keeping an explicit statement of the objective present in the agent's context so that every reasoning and action step is evaluated against it. By anchoring intermediate decisions to the stated goal, it reduces drift on long multi-step tasks where an agent might otherwise wander off-objective. It also makes it easier to detect when a step no longer serves the original intent.Cost-Aware PlanningCost-aware planning weighs the expected token, latency, and tool-invocation cost of candidate plans, not just their likelihood of success. An agent may prefer a shorter, cheaper path that is slightly less certain over an exhaustive one, or reserve expensive tools for steps that truly need them. Making cost an explicit factor keeps autonomous agents economical without sacrificing acceptable task quality.Function CallingFunction calling is a model capability that allows a language model to emit a structured request to invoke a named function with typed arguments, rather than free-form text. The runtime intercepts the request, executes the function, and returns the result as an observation. Function calling makes tool integration reliable by replacing text parsing with a machine-readable protocol, and it is the foundation of most production tool-use implementations.Tool SchemaA tool schema is the formal description of a tool that the language model receives at inference time: it includes the tool's name, a natural-language description of what it does, and a typed parameter specification — typically expressed as JSON Schema. The model uses the schema to decide whether to call a tool and to produce correctly structured arguments. A well-written schema is one of the most important levers for improving tool-selection accuracy.Tool RouterA tool router is the logic — implemented in prompt, code, or a dedicated model — that selects which tool to invoke given the current state of the agent's task. Simple routers let the model choose freely from all available tools; more sophisticated routers filter the candidate set based on task context or enforce policies about which tools are permitted in a given situation, reducing the chance of irrelevant or unsafe tool selection.Structured OutputStructured output is the practice of constraining a model's generation to conform to a defined schema — such as JSON, XML, or a typed Pydantic model — rather than producing free-form text. It eliminates brittle text parsing and makes downstream processing deterministic. Structured output can be achieved through schema-guided decoding at the logit level, careful prompting, or a combination of both, and it is widely used for tool arguments, API responses, and data extraction.JSON ModeJSON mode is a model inference setting that guarantees the output is syntactically valid JSON. It does not guarantee semantic correctness or schema conformance — only that the text parses without error. JSON mode is useful when a downstream consumer requires parseable output but when the full structure cannot be specified in advance. For strict schema adherence, schema-guided decoding or function calling with explicit parameter types is preferred.Parallel Tool CallsParallel tool calls allow a model to emit multiple tool invocation requests in a single generation step, which the runtime then executes concurrently before returning all results together. This dramatically reduces latency when subtasks are independent — for example, querying two databases simultaneously. The model must correctly identify which calls are independent; sequential dependencies cannot be parallelized and must remain ordered.Tool ResultA tool result is the data returned by a tool execution that is fed back into the model's context as an observation. The model then incorporates this information into its next generation. Tool results must be serialized to text or structured content that the model can process; for binary data like images or large files, results are typically summarized or referenced by a handle rather than embedded verbatim in the prompt.Argument ValidationArgument validation is the process of checking that the arguments a model supplies in a tool call conform to the tool's schema — verifying required fields are present, types match, and values fall within acceptable ranges. Validation can happen in the runtime before dispatching the call, in the tool itself, or at both layers. Returning clear, structured validation errors to the model often enables it to self-correct and retry with valid arguments.API ToolAn API tool is a tool that wraps an external HTTP API, exposing one or more endpoints as callable functions within an agent's action space. The tool handles authentication, serialization, and error normalization so the agent can invoke real-world services — such as weather data, CRM systems, or payment processors — with typed arguments and reliable return values, without the model needing to know raw HTTP details.Code Execution ToolA code execution tool allows an agent to run programs — typically Python or shell scripts — in a sandboxed environment and receive the output as a tool result. This capability makes agents dramatically more powerful for numeric computation, data analysis, file manipulation, and algorithm implementation, because the agent can offload computation to a deterministic interpreter rather than attempting to simulate it through language model inference alone.
Browse by chapter
Agentic AI Foundations & Architectures
Core building blocks of autonomous AI agents — agent loops, roles, and system shapes.
26 terms
Agent Planning & Reasoning
How agents decompose goals, plan steps, and reason toward outcomes.
24 terms
Tool Use & Function Calling
Connecting models to tools, APIs, and structured function calls.
24 terms
Memory, Context & State
Short- and long-term memory, context windows, and state management for agents.
20 terms
Multi-Agent Systems & Orchestration
Coordinating multiple agents — roles, communication, and orchestration patterns.
20 terms
RAG & Grounded Generation
Retrieval-augmented generation — chunking, retrieval, reranking, and grounded answers.
29 terms
Vector Databases & Retrieval
Embeddings, vector indexes, similarity search, and hybrid retrieval.
25 terms
MCP & Integration
Model Context Protocol and patterns for tool-connected, integrated AI apps.
21 terms
MLOps, LLMOps & Observability
Deploying, monitoring, evaluating, and improving models in production.
30 terms
Evaluation, Guardrails & Safety
Measuring quality, adding guardrails, and testing for regressions and failures.
30 terms
Prompt Engineering
Designing reliable prompts, templates, and reusable prompting patterns.
24 terms
Fine-Tuning & Alignment
Adapting models with fine-tuning, preference optimization, and alignment.
23 terms
LLM Core & Architecture
Transformer internals, attention, tokenization, and decoding.
24 terms
Classical AI, NLP & Linguistics
Foundational NLP and machine-learning concepts that underpin modern systems.
22 terms
AI Safety, Ethics & Risk
Bias, robustness, misuse, and responsible-AI concepts.
25 terms