The Agentic AI Glossary: 26 Terms Every Builder Should Know in 2026

I've been building web properties since 2007. For most of those years the work didn't change much. Figure out what people search for, write something useful, ship it, watch the logs. Then over the past two years a new layer arrived. Agents. Pipelines. MCP. ReAct. RAG. Along with the actual work came a vocabulary that nobody around me, including clients and friends running their own companies, could quite agree on the meaning of.

A friend sent me an infographic by Brij Kishore Pandey that defines twelve of these terms in plain language. I rewrote each one based on what I've actually learned shipping with them, then added fourteen more that I think belong on any honest list. The result is the cheat sheet I wish someone had handed me in early 2024.

This is written for non-technical operators trying to talk to their engineers, engineers trying to explain agents to a CEO, and founders trying to work out which of these things actually matters for the roadmap.

Quick Reference: All 26 Terms in One Line Each

1. MCP: an open protocol that lets AI models plug into outside tools and data through one standard interface.

2. Agent Loop: the four-step cycle of perceive, plan, act, observe that an AI agent runs until its goal is met.

   The 4-Step Problem Solving Process

   1

   Identify the Problem

   Define the gap between current state and desired outcome with data.

   2

   Generate Alternatives

   Brainstorm multiple solutions without judgment; quantity over quality.

   3

   Evaluate & Select

   Weigh feasibility, cost, and impact to choose the optimal path forward.

   4

   Implement & Review

   Execute the solution, measure results, and iterate based on feedback.

3. Tool Use: a model's ability to call external functions like APIs, code runners, and browsers.

4. Orchestrator: the senior agent that breaks a goal into subtasks and delegates them to other agents.

5. Subagent: a focused worker agent that handles one task inside a larger pipeline.

6. Memory: how an agent retains information, split into short-term (in-context) and long-term (stored).

7. Grounding: tying model outputs to verified external sources so the agent stops making things up.

8. Guardrails: rules and structural limits that stop an agent from doing forbidden things.

9. Sandboxing: running an agent's code in an isolated environment so mistakes don't leak.

10. Human-in-the-Loop: a checkpoint where the agent stops and asks before doing something irreversible.

11. Context Window: the maximum amount of text a model can read and reason over in one request.

12. Multi-Agent: a system of specialised agents collaborating on a larger goal.

13. Tokens: the subword pieces of text that a model reads, writes, and is billed for.

14. Hallucination: a model stating something false with the same confidence it uses for true things.

15. RAG: fetching documents from a database and inserting them into the prompt before the model answers.

16. ReAct: a pattern of alternating reasoning steps and tool calls inside the agent loop.

17. Computer Use: a kind of tool use where the agent operates a real computer like a person would.

18. Evals: automated tests for agents that check output quality, tool selection, and safety.

19. Chain-of-Thought: making the model write out its reasoning before producing an answer.

20. System Prompt: the standing instructions that tell the model who it is and what rules to follow.

21. Prompt Injection: a malicious input hidden in a document or tool result that hijacks the agent.

22. Reflection: a pattern where the agent critiques its own output and revises before returning it.

23. Workflow vs. Agent: a fixed code-driven pipeline versus a system where the model picks the next step.

24. Reasoning Models: models trained to think privately before producing a visible answer.

25. Embeddings and Vector Databases: turning meaning into numbers so it can be stored and searched.

26. Prompt Caching: an API feature that lets you reuse parts of a prompt at a fraction of the cost.

1. MCP: Model Context Protocol

MCP, short for Model Context Protocol, is an open standard published by Anthropic that gives AI models one consistent way to connect to outside tools and data sources.

Before MCP, every integration was bespoke. Connecting a model to Gmail meant one piece of glue code. Connecting it to GitHub meant another. Connecting it to a database meant a third. With MCP, the apps expose a small server that speaks the protocol, and the model talks to all of them through the same interface.

For me, this is the gap between Claude being a useful chatbot and being a teammate I delegate work to. When I run Claude Code against one of my projects, MCP is how it reads the database schema, runs migrations, and opens pull requests on GitHub. Without it I'd be copy-pasting between five tabs.

2. Agent Loop: Perceive, Plan, Act, Observe

The agent loop is the cycle an AI agent runs through to get anything done. Sense what's happening, plan a response, take an action, observe the result. Repeat until the goal is reached or the budget runs out.

The loop is also where most bugs live. An agent that can't notice its last action failed will cheerfully retry the same broken thing fourteen times in a row. An agent with no clear stop condition will recurse until your API bill makes you sit down.

A real example from my desk: I ask Claude Code to fix a failing test. Read the error, propose a fix, edit the file, run the suite, look at what came back. If I had to do this by hand I'd lose interest after three rounds. The agent doesn't get bored.

3. Tool Use: How Agents Actually Do Things

Tool use is a model's ability to call external functions like APIs, code interpreters, browsers, and databases, instead of only producing text. A model that can only write is a writer. A model that can call tools is a worker.

The interesting part of building agents is rarely the model itself. It's the menu of tools you put in front of it, and the conditions under which each one fires. Expose the wrong tool and the agent will use it. Hide a useful one and the agent will go in circles trying to do without it.

Sit a "delete all rows" tool next to "send welcome email" with no other distinction between them. One day the welcome emails will stop going out and the user table will be empty.

4. Orchestrator: the Manager Agent

An orchestrator is the top-level agent that takes a complex goal, breaks it into smaller pieces, hands each piece to a specialist, and stitches the results back together.

Without an orchestrator, a single agent told to "redesign the homepage" sprawls. With one, the same goal becomes "audit the current copy," "draft three layout options," "generate the CSS," "write the migration plan." Four narrower tasks that four narrower agents can each finish before lunch.

5. Subagent: the Specialist Worker

A subagent is a focused worker agent that handles one specific task inside a larger pipeline. The orchestrator calls it, it does its job, returns a result, and steps out of the way.

Subagents don't usually talk to each other. They report up. Think of it less like a meeting and more like a printing press. Each station does its part. The work moves forward. Nobody is trying to be the manager.

6. Memory: Short-Term and Long-Term

Memory in an AI agent is how it retains information between turns. It comes in two flavours. Short-term memory lives in the context window: the running conversation, files you've pasted in, recent tool outputs. Long-term memory lives in an external store, usually a database or a vector index, and gets pulled back into context when the agent decides it's relevant.

Short-term is fast and free but small. Long-term is durable but slow and selective. Nothing about long-term memory is automatic. Somebody decided what to save and how to find it later.

If you've ever opened a new chat and felt like the AI forgot everything about your project, that's the seam between the two. Either nothing was written to long-term memory, or the retrieval pulled the wrong slice.

7. Grounding: Anchoring Output to Real Data

Grounding is the practice of connecting an AI model's answers to verified external sources so it stops making things up. The opposite of grounding is the agent confidently quoting you a stock price from 2023 because that's what its training data remembers.

Grounding usually needs three pieces working together. A way to fetch fresh data, whether through search, an API, or a database. A discipline of citing what was fetched. And an interface that shows the reader where each claim came from. Skip any one of those and the trust collapses.

8. Guardrails: Rules the Agent Cannot Break

Guardrails are the rules an agent is not allowed to break, regardless of what it's asked. Some are written into the system prompt ("never delete user data without confirmation"). Others are structural. The agent simply isn't given the tool that would let it do the forbidden thing.

A lesson I keep relearning: a guardrail in the prompt is a polite request. A guardrail in the toolset is a wall. If something must not happen, don't ship the capability that would let it happen.

This matters more in compliance contexts than anywhere else. In a compliance product the principle is non-negotiable from day one — the model can suggest a policy change, the model cannot ship one.

9. Sandboxing: Running Agent Code Safely

Sandboxing means running an agent's code inside an isolated environment so any damage stays contained. A Docker container. A virtual machine. A serverless function with no production credentials. The agent can break the sandbox. The sandbox can't break your business.

Claude Code uses this pattern. When it writes a Python script and executes it, the script runs in an isolated container. If the script does something stupid, and they do sometimes, the worst case is that the container dies. Your laptop survives. Your production database doesn't notice.

10. Human-In-The-Loop: the Approval Gate

Human-in-the-loop is a design pattern where the agent pauses and asks for your approval before doing anything irreversible. Sending the email. Pushing to main. Charging the card. Booking the flight.

Calibrating this is the actual hard part. Too many checkpoints and the agent feels like a slow assistant asking before every keystroke. Too few and the agent has burned through your inbox before you've finished your coffee. There is no formula. Start cautious and dial it down.

11. Context Window: the Working Memory Limit

A context window is the maximum amount of text a language model can read and reason over in a single request, measured in tokens.

Today's frontier models offer somewhere between 200,000 and a few million tokens. Two hundred thousand tokens is around 150,000 English words. Call it a novel or a small codebase. A million tokens fits something closer to an entire company wiki.

Bigger isn't always better. You pay per token both going in and coming out, so a big context is a real bill. Quality also tends to drop on details buried in the middle of very long contexts. The skill is sending the model what it actually needs and trimming the rest.

12. Multi-Agent: a Team of Specialists

A multi-agent system is one where several specialised agents collaborate, usually under an orchestrator, to solve a problem too messy for any single one of them.

The honest truth: multi-agent gets reached for too early. A single capable agent with the right tools and a clear system prompt will beat a sprawling team of weak ones nine times out of ten. The right moment for multi-agent is when the bottleneck is the sequencing of genuinely distinct skills — research, then write, then fact-check, then publish — not when the model itself is what's holding you back.