AI Agent Glossary

AI Agent

An AI agent is a software system that uses a language model to decide what actions to take, then calls tools to carry them out, in pursuit of a goal, with limited direct human instruction at each step.

Agentic AI

Agentic AI describes AI systems built to plan and take multi-step action toward a goal on their own, rather than just generating a single response to a prompt.

Autonomous Agent

An autonomous agent is an AI agent that can carry out a sequence of actions toward a goal without a human approving each individual step, though it may still stop at defined checkpoints.

Multi-Agent System

A multi-agent system is a setup where multiple AI agents, each with a narrower role, work on parts of a larger task and coordinate through some form of orchestration.

Subagent

A subagent is a secondary AI agent that a main agent spawns to handle a specific sub-task, usually with its own focused instructions and tools, and reports back to the agent that spawned it.

Agent Orchestration

Agent orchestration is the layer that decides which agent, subagent, tool, or server handles a given piece of work, in what order, and how their results get combined.

Agent Team

An agent team is a multi-agent setup organized around role-based collaboration — a lead agent plus specialized members like a planner, coder, reviewer, and tester — modeled loosely on how a human team divides work.

Agent Loop

The agent loop is the repeating perceive-plan-act-observe cycle by which an AI agent turns a goal into a sequence of actions, checking each result before deciding what to do next.

ReAct

ReAct is a prompting technique that has a language model explicitly interleave written reasoning ('Thought') with actions and their results ('Observation'), rather than jumping straight from a question to an action.

Planning

Planning is the step where an agent turns a goal into an ordered set of smaller steps before — or while — it starts acting, so it isn't deciding what to do purely one action at a time with no larger structure.

Reflection / Self-Correction

Reflection (or self-correction) is when an agent evaluates its own output or action against the goal and revises it, instead of treating its first attempt as final.

Human-in-the-Loop

Human-in-the-loop is a design pattern where an agent pauses to get a person's review or approval before or during a consequential action, rather than acting entirely on its own.

Autonomy Level

Autonomy level is an informal way of describing how much an agent decides and does on its own before checking in with a human, ranging roughly from fully manual to fully autonomous — it's not an official or standardized scale.

Agent-Computer Interface (ACI)

An agent-computer interface (ACI) is how a tool, API, or environment is designed to be used by an AI agent rather than a human — optimized for machine parsing and predictable structure instead of visual layout.

Agent Memory

Agent memory is the mechanism by which an AI agent retains and later reuses information beyond what fits in a single prompt — across steps in a task, or across separate sessions.

MCP

MCP (Model Context Protocol) is an open standard that lets AI applications connect to external tools, data, and prompts through one consistent interface instead of a custom integration for each.

MCP Server

An MCP server is a program that exposes tools, resources, and/or prompt templates to AI applications through the MCP protocol.

MCP Client

An MCP client is the component inside a host application that establishes and manages a connection to one or more MCP servers on the model's behalf.

A2A (Agent2Agent Protocol)

A2A (Agent2Agent Protocol) is an open protocol effort for letting AI agents from different vendors discover each other's capabilities and delegate tasks between them.

ACP (Agent Communication Protocol)

ACP (Agent Communication Protocol) is an earlier proposal for standardizing how AI agents communicate with each other, built on REST-style HTTP conventions.

AGENTS.md

AGENTS.md is a plain-text file placed in a project's repository that gives AI coding agents project-specific instructions, like how to set up, build, test, and follow the project's conventions.

SKILL.md

SKILL.md is a file format for packaging a reusable capability — instructions, and optionally supporting scripts or resources — that an agent can load when a matching task comes up.

Function Calling / Tool Calling

Function calling (also called tool calling) is a model capability where the model can output a structured request to invoke a specific function with specific arguments, instead of only producing free-form text.

Tool Manifest

A tool manifest is the structured description of a tool — its name, what it does, and what arguments it expects — that gets included in a model's context so it knows the tool exists and how to call it.

Capability Discovery

Capability discovery is the process by which a client finds out what tools, resources, or other capabilities a server actually offers, instead of assuming or hard-coding it in advance.

WebMCP (Web Model Context Protocol)

WebMCP is a proposed browser API (`navigator.modelContext`) that lets a web page publish JavaScript functions as structured tools a browser-based AI agent can discover and call directly, instead of reading and clicking the page like a person.

AP2 (Agent Payments Protocol)

AP2 (Agent Payments Protocol) is an open protocol for letting an AI agent pay on a user's behalf, structured so that every purchase carries cryptographically signed proof of what the user asked for, what the agent put in the cart, and what may be charged.

UCP (Universal Commerce Protocol)

UCP (Universal Commerce Protocol) is an open standard that lets an AI agent carry out a full shopping journey — discovery, cart, checkout, and post-purchase — against many different retailers through one common, capability-negotiated interface.

MHS (Model Hardware Standard)

MHS (Model Hardware Standard) is a proposed open specification, previewed by Anthropic in 2026, that gives AI agents one common way to discover and operate physical instruments — microscopes, robotic arms, liquid handlers — instead of a bespoke integration per device.

Skill

A Skill is a packaged, reusable capability — instructions, and sometimes scripts or reference files — that an agent loads into context only when a task calls for it.

Workflow

A workflow is a defined sequence of steps — carried out by an agent, a human, or both — that runs from some starting trigger to a finished result.

Playbook

A playbook is a set of “if this situation, apply this rule, take this action” instructions written for a recurring class of problems, rather than a single fixed sequence.

Pipeline

A pipeline is a linear, ordered sequence of processing stages that data or a task flows through, from an initial input to a final output.

Hook

A hook is a piece of code or a check that runs automatically at a defined point in an agent's action lifecycle, typically just before or just after the agent does something.

Slash Command

A slash command is a short, typed instruction — starting with `/` — that a user invokes to run a predefined prompt, procedure, or action instead of writing it out in full.

Task Decomposition

Task decomposition is the process of breaking one large or ambiguous task into smaller, more concrete subtasks that can each be executed and checked individually.

Chain-of-Thought (CoT)

Chain-of-thought is a prompting technique where a model is asked to write out its intermediate reasoning steps before giving a final answer, rather than producing the answer directly.

DAG Workflow

A DAG workflow is a workflow modeled as a directed acyclic graph — steps that can branch into parallel paths and later merge back together, with no path ever looping back on itself.

State Machine Agent

A state machine agent is one whose behavior is modeled as a fixed set of named states — like idle, working, waiting for input — with explicit rules for when it transitions from one to another.

Trigger

A trigger is the external event that starts a new agent run — a schedule firing, a webhook arriving, a file changing, or a person issuing a manual command.

Scheduled Agent

A scheduled agent is an agent configured to run automatically on a recurring time-based schedule — daily, hourly, every Monday — rather than being started by a person or an external event.

Coding Agent Harness

A coding agent harness is the surrounding software — outside the model itself — that assembles context, executes tool calls, enforces permissions, and feeds results back, turning a raw model into something that can actually operate a coding environment.

AI Agent Evaluation

Agent evaluation is the practice of testing an AI agent's complete multi-step behavior against a set of tasks, rather than grading a single output in isolation.

AI Agent Benchmark

An agent benchmark is a fixed, repeatable set of tasks and a scoring method used to compare different agents or models under identical conditions.

AI Agent Safety

Agent safety is the practice of anticipating and limiting the harm an AI agent could cause once it can take real actions in the world, not just generate text.

AI Agent Guardrails

A guardrail is a rule, filter, or check applied to an agent's inputs or proposed actions that constrains what it's allowed to do, enforced independently of the agent's own reasoning.

Prompt Injection

Prompt injection is an attack in which text inside the content a model reads — a web page, a document, an email, a tool result — is crafted so the model treats it as an instruction and acts on it, overriding what the developer or user actually asked for.

Tool Poisoning

Tool poisoning is a form of indirect prompt injection where the malicious instructions are hidden inside a tool's own metadata — its description, parameter docs, or schema — which the model ingests when it decides how to use the tool, but which the user's interface never shows.

Agent Identity

Agent identity is the practice of treating an autonomous agent as its own principal in an access-management system — with its own credentials, narrowly scoped and time-limited permissions, a delegation chain back to an authorizing human, and its own audit trail.

Deterministic Guardrails

Deterministic guardrails are constraints on an agent enforced by ordinary, non-probabilistic code — state machines, policy engines, pre- and post-condition checks, allow-lists — so that required steps happen in a fixed order with fixed outcomes, no matter what the model decides.

OWASP Agentic AI Top 10

The OWASP Top 10 for Agentic Applications is a community-produced list from the OWASP GenAI Security Project that catalogues the ten most significant security risks specific to AI agent systems, from goal hijacking to rogue agents.

Context Engineering

Context engineering is the practice of deciding what information — instructions, tools, retrieved documents, history, memory — actually goes into a model's context window for a given step, and how it's structured and kept up to date.

Agent Observability

Agent observability is the practice of capturing enough visibility into an agent's step-by-step trajectory — which tools it called, in what order, with what results — to understand and debug why it behaved the way it did.

MRC (Multipath Reliable Connection)

MRC (Multipath Reliable Connection) is an open network transport protocol that spreads a single data transfer across hundreds of network paths at once, so a large AI-training cluster keeps running at full speed even when individual links congest or fail.

Agentic Commerce

Agentic commerce is the emerging practice — and the stack of protocols built for it — in which an AI agent carries out purchases on a user's behalf, from discovering products to checking out and paying, while the person sets the intent and approves the result rather than clicking through each step.

Context Rot

Context rot is the observed pattern that a language model's reliability degrades as the amount of text in its input grows — not only when the context window is nearly full, but incrementally as tokens accumulate, even on tasks the model handles easily at short lengths.

Test-Time Compute

Test-time compute is computation spent while a model answers a query — rather than during training — used to improve the result through longer chains of reasoning, multiple sampled attempts, search over options, or self-checking.

Agentic RAG

Agentic RAG is retrieval-augmented generation restructured as an agent loop: instead of retrieving once and generating, the model plans a query, retrieves, judges whether the results are sufficient, reformulates or switches sources, and repeats until it can answer.