This site has taught the mechanisms at length: how AI agents work end to end, and what an MCP server actually is. This eighth glossary lesson does the lighter job: the agent terms themselves, from planning to handoffs to the protocols that let agents reach tools and each other. Each entry is a sentence or two, with a link wherever a mechanism post already carries the depth.
What separates an agent from a chatbot
Four terms for the loop at the center of every agent definition you will read.
- AI agent: A language model wrapped in a loop that acts: it takes a goal, decides steps, uses tools, observes results, and keeps going until the goal is met or it gives up. The chatbot answers; the agent pursues.
- Planning: Breaking a goal into ordered, checkable steps before or while executing them. Good plans name their dependencies, which is what lets an agent notice that a failed step blocks three others and replan instead of marching on.
- Tool use: Calling external capabilities, functions, or APIs from inside the conversation, with the model emitting structured arguments a runtime can execute. Vendors market the same thing as function calling; the mechanism post on this site walks a full call end to end.
- Reflection: The habit of critiquing its own draft output and revising before showing it, whether prompted by the loop or written into the workflow. It costs extra model calls and earns them back only on tasks where a first draft is regularly not enough.
Memory and context under load
Three agent terms for the working state an agent carries while it runs.
- Agent memory: The store an agent keeps between steps or between sessions: scratchpads, summaries, vector records of earlier tasks. Without it, every step sees only what still fits in the context window, and nothing is learned across runs.
- Context management: Deciding what stays in the window and in what form, usually by compacting older turns into summaries while keeping tool results and instructions verbatim. Compaction is the specific move: compress the history, keep the load-bearing parts.
- Trajectory: The full record of one agent run, every step, tool call, and observation in order. Trajectories are what you debug when an agent failed, what you replay when auditing it, and what you mine when judging whether a design change helped.
When agents work in teams
Three terms for splitting one job across several cooperating agents; the multi-agent architecture explainer covers the patterns in depth.
- Multi-agent system: Several agents with divided roles sharing one job, each with its own prompt, tools, and context. The split buys focus and parallelism at the price of coordination, which becomes the new thing you debug.
- Agent handoff: One agent passing control of a conversation or task to another, typically because the receiving agent owns the needed specialty. A clean handoff carries the working state along; a sloppy one makes the customer repeat themselves.
- Orchestration: The layer that assigns work, routes messages, and enforces the order of operations across agents. The orchestrator-worker pattern is the common shape: one coordinator decomposes the goal and dispatches pieces to specialist agents it later reassembles.
Connections and safety rails
Five terms for how agents reach the world and how teams keep that reach survivable.
- MCP: The Model Context Protocol, an open standard that lets a model discover and call tools, resources, and prompts from any compliant server through one interface. One integration per capability, rather than one bespoke connector per pair of products.
- A2A: Agent-to-agent protocols, built for agents run by different owners and frameworks to find each other, exchange tasks, and report results. MCP connects an agent to tools; A2A-class protocols connect agents to agents.
- Computer use: An agent operating a GUI or browser the way a person does, reading screens and moving a cursor, so it can use software that offers no API. It is the broadest reach an agent gets and the least predictable one to test.
- Sandboxing: Running the agent’s actions inside a restricted environment with limited filesystem, network, and permissions, so a wrong move cannot touch production. With agents writing and executing code, the sandbox is the difference between an experiment and an incident.
- Human in the loop: Designing the workflow so a person approves, corrects, or intercepts at defined points rather than watching passively. Approval gates before irreversible actions are the standard placement; choosing which actions are irreversible is the actual design work.
Common confusions
Three pairings that sound interchangeable and are not.
- Agent vs agentic workflow: An agentic workflow is a fixed sequence of model calls with the branching designed by you; an agent chooses its own steps at run time. The workflow is predictable and easy to price; the agent is flexible and needs guardrails.
- MCP vs A2A: MCP standardizes how one model reaches tools and data; A2A-class protocols standardize how independent agents collaborate. A single agent with an MCP toolbox and a fleet of A2A-linked agents are different architectures, not competing brands of the same thing.
- Tool use vs computer use: Tool use calls a defined function with structured arguments and gets a structured result. Computer use drives an interface built for humans, with screenshots and clicks, and inherits every ambiguity of that interface. Prefer the former whenever an API exists.
Further reading
Three primary sources for the entries above:
- ReAct: Synergizing Reasoning and Acting in Language Models, the paper that established reasoning traces interleaved with tool calls as the standard agent loop.
- The Model Context Protocol documentation, the specification behind every MCP server this site has covered.
- The A2A protocol site, the reference for cross-vendor agent-to-agent task exchange.
This is lesson 08 of the AI glossary. Lesson 07 defined the RAG and grounding terms that many of these agents put to work, and agentic RAG in that lesson was a preview of this one. The next lesson slows the clock down to the millisecond level: inference, decoding, and serving.