The Agentic AI Glossary, every term you need to know

The agentic AI vocabulary exploded fast and the terms are scattered everywhere, each assuming you already know the rest. This is one place to look them up. The most common agentic AI terms, defined in plain language and grouped by theme, from the agent loop and the harness to memory, retrieval, skills, safety, and evaluation. Built to be skimmed and bookmarked, not read in one sitting.

The agentic AI vocabulary exploded in a short span, scattered across papers, docs, and vendor blogs that each assume you already know the rest. This glossary pulls the most common terms into one place and defines each in plain language, grouped by theme rather than alphabetically. Foundations, reasoning patterns, tools and protocols, multi-agent architecture, the harness, context and memory, retrieval, skills, safety, operations, and the engineering disciplines. Built to be skimmed and looked up.

The vocabulary of agentic AI grew faster than anyone could keep up with. The terms live scattered across research papers, framework docs, and vendor blogs, and each source assumes you already know the other twenty words around the one you looked up. This is one place to look them up.

Every term below is defined in plain language and grouped with the ideas it relates to, rather than dumped in alphabetical order. Read a whole section and you learn a corner of the field. It is built to be skimmed and bookmarked, not read top to bottom. Skim the headers, find the cluster you are working in, and look up what you need. Where a term deserves a full treatment, it links to a deeper post, Welcome to Loop Engineering, The Technical Architecture of Agentic AI, Context Engineering is where AI Agents succeed or fail, and The Top 16 GenAI Patterns.

A quick way to read any unfamiliar term here is to ask what failure it prevents. Most of this vocabulary exists because something broke in production, and the word is the name of the fix.

Foundations

• AI Agent: A system that uses a language model as its reasoning engine to pursue a goal across many steps, deciding for itself what to do next. The defining feature is the loop, reason, act, observe, then reason again.
• Agentic AI: The broad term for AI systems that act with autonomy, taking actions in the world through tools rather than only producing text. The opposite of a system that just answers a single prompt.
• Agentic Workflow: A multi-stage process where agents, not hard-coded logic, carry out some or all of the steps. These sit on a spectrum of autonomy, and most real systems live deliberately in the middle.
• Large Language Model (LLM): The neural network that predicts text and, inside an agent, is the reasoning engine. On its own it only maps input tokens to output tokens; the agent is what surrounds it.
• Reasoning Engine: The role the model plays inside an agent. It is the component that decides what to do next given the current situation, rather than a database of answers.
• Autonomy Spectrum: The range from a developer defining every step (predictable, auditable) to the agent choosing the entire path at runtime (flexible, harder to govern). Every bit of control handed to the model is unpredictability you then manage.
• Agent vs Chatbot: A chatbot answers the question you asked. An agent decides which sub-questions to ask itself, which tools to use, and when the job is done. That control over its own flow is the dividing line.

Reasoning and acting patterns

These are the repeatable shapes of how an agent thinks and acts. Most modern agent loops are combinations of a few of them.

• ReAct (Reason + Act): The foundational pattern of interleaving reasoning steps with actions. The agent thinks, acts, observes the result, then thinks again. Most agent loops are descendants of this idea.
• Chain-of-Thought (CoT): Prompting the model to work through a problem step by step before answering, which improves reasoning on multi-step tasks by making the intermediate steps explicit.
• Tree-of-Thought (ToT): Exploring several reasoning branches in parallel and pruning the weak ones, rather than committing to a single chain. Useful when the first line of reasoning may be wrong.
• Reflection / Reflexion: The agent critiques its own output, identifies what is wrong, and revises. A self-review pass that catches errors a single attempt would ship.
• Planning / Plan-and-Execute: The agent first drafts a multi-step plan, then carries it out step by step, optionally replanning when reality diverges. Separates deciding what to do from doing it.
• Self-Correction Loop: Feeding a failure (a failed test, a broken build, a guardrail breach) back to the agent so it diagnoses and fixes its own work, often without a human seeing the error. A major driver of reliability in coding agents.
• Self-Ask: The agent breaks a hard question into smaller sub-questions it answers first, then composes the final answer from them.
• Tool-Use: The act of an agent calling an external function instead of answering from memory, then using the result to continue reasoning.

Tools and protocols

• Tool: A discrete function an agent can call, such as searching the web, querying a database, or sending an email. Tools are how an agent affects the world beyond generating text.
• Tool Registry: The catalogue of tools available to an agent, including their names, descriptions, and input schemas, which the agent reads to decide what it can do.
• Function Calling: The model capability of emitting a structured request to invoke a specific tool with specific arguments, rather than answering in free text. The mechanism most tool-use is built on.
• Structured Outputs: Constraining the model to return data in a required shape (such as valid JSON matching a schema) so downstream code can consume it reliably.
• MCP (Model Context Protocol): An open standard for connecting agents to external tools and data sources consistently. It costs more tokens than a raw call, but it is the right choice when you need authentication, multi-tenancy, governance, or reuse across teams.
• A2A (Agent-to-Agent): Protocols that let agents communicate and negotiate directly with each other rather than routing everything through a central coordinator. Matters more as systems move toward many independent agents.

Architecture and multi-agent roles

When one agent is not enough, these roles and shapes recur. Most map naturally onto how you would split work across a team of humans.

• Multi-Agent System: An architecture where several specialised agents collaborate, usually one coordinator directing focused workers. The motivation is that complex tasks overflow a single context window; the trade-off is that coordination becomes the real bottleneck.
• Orchestrator / Supervisor Agent: The agent that breaks a large task into pieces, assigns them to other agents, and assembles the results. It owns the high-level plan while delegating the detail.
• Sub-Agent / Worker Agent: A focused agent that handles one slice of a larger task with its own dedicated context window, so it is not distracted by the rest of the problem.
• Orchestrator-Worker Pattern: The most common production shape. One coordinator dispatches specialised sub-agents in parallel or in sequence, then combines their output.
• Sequential Pipeline: Agents chained so each builds on the previous one's artefact. One writes a spec, the next turns it into a plan, the third implements it. The chain enforces a clear order of operations.
• Debate / Conversational Pattern: Multiple agents iterate on or critique each other's work across rounds, catching errors a single pass would miss. Useful for review, fact-checking, and self-correction.
• Evaluator-Optimiser: Several agents attempt the same task independently and an evaluator agent picks the best output by a rubric. Expensive but effective when output quality is the main constraint.
• Handoff: The transfer of a task and its relevant context from one agent to another. A common point of failure, since context lost in the handoff causes the next agent to go wrong.
• Durable / Long-Running Agent: An agent built for tasks that outlast a single session, persisting state so a job lasting hours or days survives interruptions. Drags retries, timeouts, and durability into agent design.

The harness and execution

The harness is the software around the model that turns a capable model into a reliable agent. If the model is the brain, the harness is the hands and the roll cage.

• Agent Harness: The software infrastructure around the model that governs how it executes, managing tools, memory, state, validation, error recovery, and escalation. A prompt can only request a rule; the harness enforces it.
• Inner Harness: The execution scaffolding the model labs build into the model, native tool-calling, the raw context window, baseline safety. You get it for free. It is the floor, not the differentiator.
• Outer Harness: The custom layer your team builds on top, routing, testing, domain guardrails, memory, and business logic. The real competitive moat, because nobody can buy it off the shelf.
• Information, Execution, Feedback Layers: A way to split the harness by job. The information layer controls what the agent can see. The execution layer validates what it does. The feedback layer turns corrections into constraints for future runs.
• Loop Driver: The harness's central control loop. It decides when to call the model, when to invoke a tool, and when to stop, owning iteration limits and token budgets so agents neither loop forever nor quit early.
• Sandbox / Devbox: An isolated environment where an agent's actions (running code, editing files) execute safely without touching production. Lets agents do real work while containing mistakes.
• State Management: Tracking everything an agent has done so far, conversation history, tool results, the working plan, and intermediate outputs. The substrate that lets a run be paused, resumed, and debugged.
• Checkpointing (hibernate-and-wake): Saving an agent's state mid-task so a long job can pause and resume exactly where it left off, even if the work exceeds the context limit or spans days.

Context and memory

Almost every hard problem in agent design becomes a question about context. The core surprise is that more context is not automatically better.

• Context Window: The fixed span of tokens the model can attend to at once, effectively its working memory. Everything the agent knows in the moment has to fit here.
• Token: The unit of text a model reads and generates, roughly a word fragment. Context limits, latency, and cost are all measured in tokens.
• Context Engineering: The discipline of deciding what information goes into the context window and what stays out. It exists because attention dilutes over long inputs, and models attend to the start and end more than the middle.
• Progressive Disclosure: Revealing information in stages so the window stays lean. A one-line summary first, full details only when relevant, deep reference material only if needed. What lets an agent keep hundreds of skills in reach without drowning.
• Context Window Saturation: When a long-running agent fills its window with history and tool results until it loses track of the original goal. One of the most common production failure modes.
• Summarisation / Compaction: Compressing older turns into a running summary so a long conversation keeps its gist without keeping every token. A standard fix for saturation.
• Memory: The longer-term layer that persists across turns and sessions, conventions, preferences, stable facts, and lessons from past failures. What lets an agent improve instead of starting fresh each time.
• Short-Term (Working) Memory: The information held inside the current context window for the task at hand. Fast to access but wiped when the window resets.
• Long-Term Memory: Knowledge stored outside the context window (often in a database) and retrieved when relevant, so it survives across sessions.
• Episodic Memory: Memory of specific past events or interactions, what happened, when, and what resulted. Lets an agent recall a particular earlier exchange.
• Semantic Memory: Memory of general facts and concepts independent of when they were learned, the stable knowledge an agent reasons from.
• Procedural Memory: Memory of how to do things, the steps, routines, and skills an agent applies. Agentic skills are one way to make procedural memory explicit and reusable.

Knowledge and retrieval (RAG)

• RAG (Retrieval-Augmented Generation): Answering with documents fetched at query time rather than only what the model memorised in training. The standard way to ground an agent in current or private knowledge.
• Agentic RAG: RAG where the agent decides if, when, and what to retrieve, verifies the retrieved chunks, and may issue follow-up queries, instead of always retrieving once and hoping.
• Embedding: A numeric vector representing the meaning of a piece of text, so that similar meanings sit close together. The basis of semantic search.
• Vector Database: A store optimised for finding the embeddings closest to a query vector, which is how relevant documents are retrieved by meaning rather than keyword.
• Chunking: Splitting documents into smaller passages before embedding them, so retrieval returns focused, relevant pieces rather than whole files.
• Retriever: The component that, given a query, fetches the most relevant chunks from the store to add to the model's context.
• Reranking: A second pass that reorders retrieved candidates by relevance using a stronger model, improving the quality of what actually reaches the context window.
• Grounding: An answer is grounded when it is actually backed by retrieved sources rather than invented. A grounded answer can be traced to the documents it came from.

Agentic skills

Skills are reusable, self-contained packages of procedural knowledge an agent loads only when it needs them. A tool executes and returns a result; a skill teaches the agent how to approach a problem.

• Agentic Skill (SKILL.md): A reusable unit of know-how, usually a markdown file with a name, description, instructions, and optional scripts. Because the format is an open standard, the same file can be reused across different agent platforms.
• Discovery, Activation, Execution: The three stages by which a skill loads. The agent reads just the name and description, about 100 tokens. It loads the full instructions when a task matches. Only then does it reach for bundled scripts.
• Skill Routing: The agent's decision of which skill to invoke, when to switch skills, and how to combine several in one task. As the catalogue grows, choosing correctly becomes its own challenge, and the description field is the routing signal.
• Skill Trust and Lifecycle Governance: Vetting, permissioning, and maintaining skills, especially community-contributed ones, since a skill is executable knowledge and a poorly vetted one can carry hidden instructions or unsafe scripts.

Control and safety

These are the mechanisms that bound an autonomous agent so a probabilistic system stays safe to run. The recurring theme is enforcement the model cannot talk its way around.

• Guardrails: Deterministic constraints the model cannot override, applied at the step or agent level. An instruction in a prompt is something the model might follow; a guardrail is enforced by the system regardless.
• Human-in-the-Loop (HITL): Checkpoints where a person reviews, approves, or corrects an agent's output before it takes effect. The standard safety valve for high-stakes actions.
• Approval Workflow: A gated step requiring human sign-off before a consequential action runs. The deliberate friction is the point, the difference between suggesting a change and making one.
• Scope Limitation / Permissioning: Restricting precisely what data an agent can read and what actions it can take, so the blast radius is bounded when it misbehaves.
• Schema Validation: Automatically checking that output matches a required structure before anything downstream uses it. A cheap, deterministic way to catch malformed output before it causes a silent failure.
• Prompt Injection: An attack where malicious instructions hidden in a document, web page, or tool result hijack the agent's behaviour. A central security concern for any agent that reads untrusted input.
• Jailbreak: Coaxing a model past its safety constraints with crafted input. Related to prompt injection but aimed at the model's own guardrails rather than the surrounding system.
• Hallucination: When a model produces confident, fluent output that is simply false. The failure that grounding, validation, and evaluation are largely built to catch.

Operations and quality

Getting an agent to work once is a demo. Keeping it working is an operations problem, and it looks different from ordinary software because the system can fail by reasoning poorly rather than crashing.

• Orchestration: The coordination logic that governs how steps and agents are sequenced, run in parallel, and routed. The conductor that turns a loose collection of agents and tools into a coherent workflow.
• Eval / Evaluation: Measuring how good an agent's output is. Genuinely hard for agents, because there is often no single right answer and no consensus on what good means, so teams lean heavily on human review.
• LLM-as-a-Judge: Using a model to score another model's output against a rubric, a scalable (if imperfect) way to evaluate when there is no exact right answer to compare against.
• Observability: The ability to trace, inspect, debug, and monitor agent behaviour in production. Debugging a wrong answer is a different problem than debugging a crash. The system did not fail, it reasoned poorly.
• Trajectory: The complete sequence of an agent's reasoning, actions, and observations on a single task. Looking at trajectories, not just final answers, is how you understand why an agent succeeded or failed.
• Tracing and Spans: The recorded breakdown of a run into nested steps (model calls, tool calls, retrievals), each timed and inspectable. The raw material of observability.
• Non-Determinism Governance: Managing the reality that the same input can produce different outputs. An invalid output can leave a workflow silently stuck with no error thrown, so you need explicit handling for it.
• Regression / Drift Detection: Catching when output quality or behaviour shifts over time, often from a model update or changing data. Without an explicit gate, you find out when users complain.
• Prompt Caching: Reusing the model's processing of a repeated prefix (such as a long system prompt) across calls to cut latency and cost. A common production optimisation.
• Latency and Cost: The two operational budgets every agent spends, time to respond and tokens (money) consumed. Multi-step agents multiply both, which is why they have to be measured and controlled.

Model behaviour knobs

• System Prompt: The standing instructions that set an agent's role, rules, and behaviour, applied to every request regardless of what the user says.
• Temperature: A setting that controls randomness in the model's output. Low for focused and repeatable, higher for varied and creative. Often kept low for agents that need consistency.
• Zero-Shot / Few-Shot: Zero-shot asks the model to perform a task with no examples; few-shot includes a handful of worked examples in the prompt to steer behaviour. A cheap way to improve reliability.
• Fine-Tuning: Further training a base model on your own data to bake in behaviour, the slowest tier to update but the highest retention. Used when prompting and context are not enough.
• Context vs Weights: Two places knowledge can live, in the context window (fast to change, temporary) or in the model's weights via fine-tuning (slow to change, permanent). Choosing between them is a core design decision.

The engineering disciplines

Finally, the named disciplines for building around a model. They are layers, each wrapping the last, not replacements for one another.

• Prompt Engineering: Crafting the wording, role, and examples of an instruction to coax a better answer. The dominant focus of the early LLM era, still useful but no longer the whole job.
• Context Engineering: Deciding what information fills the model's context window for each step. The layer that followed prompt engineering once people realised the right context beats clever wording.
• Harness Engineering: Designing the validation, tools, recovery, and guardrails wrapped around a single agent run. The scaffolding the agent operates inside.
• Loop Engineering: Wrapping the model in a system that checks, validates, retries, and improves its output instead of trusting the first answer. The autonomous loop that keeps driving the agent.
• Model Scaling vs System Scaling: Improving capability by building bigger models versus building a better system around the model. The field's centre of gravity is shifting toward the latter as models converge.
• Agentic Enterprise Orchestration: Assembling harness components into a governed, observable, production-grade platform an organisation can rely on. Harness engineering scaled up to enterprise requirements.

That is the working vocabulary. If a term here sparked a deeper question, the linked posts at the top go past the definition into how each piece is actually built and where it breaks.