30 Must-Know Agentic AI Terms (Glossary)
A comprehensive glossary of the 30 essential terms for understanding modern AI agents — covering the core reasoning loop, memory, coordination, and emerging protocols.
🎓 Learning objectives
- •Define all 30 core agentic AI terms in your own words
- •Use the correct term when discussing agent architecture with other engineers
- •Map each term to the broader concept it belongs to (reasoning loop, memory, coordination, or protocols)
- •Recognize these terms when reading agent framework documentation (CrewAI, LangGraph, AutoGen)
What is it?
This is a curated glossary of the 30 most important terms in agentic AI — a quick-reference guide connecting the dots between key building blocks across agent frameworks like CrewAI, LangGraph, and AutoGen. It covers everything from the most basic vocabulary (Agent, Environment, Action) through reasoning concepts (ReAct, Planning, Reflection), memory types (short-term, long-term), and the newest coordination protocols (MCP, A2A). Rather than teaching any single concept in depth, this glossary exists to give you a shared vocabulary so you can read agent documentation, papers, and discussions fluently.
Why it exists
The agentic AI space moves fast and different frameworks (CrewAI, LangGraph, AutoGen, custom implementations) often use slightly different names for the same underlying concept, or the same name for subtly different things. A glossary exists to anchor a consistent, framework-agnostic vocabulary — so that when you read that 'Router' means one thing in one framework's docs and something close-but-not-identical in another, you have a stable reference point defining what the term fundamentally means.
Problem it solves
It solves the 'I nod along but don't actually know what that means' problem that's common when ramping up on agentic AI — terms like ARQ, A2A, or hierarchical agents get thrown around in blog posts and framework docs assuming familiarity. It also solves onboarding friction on teams building agentic systems: instead of each new engineer picking up terminology piecemeal and inconsistently, a shared glossary gets everyone using the same words to mean the same things, which matters enormously when debugging or designing systems together.
Intuition
Think of this the way you'd think of a glossary at the back of a technical textbook, or the terminology reference in a new job's onboarding doc — you don't read it front to back and memorize it once; you keep it open in a tab and refer back to it whenever an unfamiliar term shows up in something you're reading. Fluency in the vocabulary is what lets you focus your actual thinking on the harder architectural questions instead of getting stuck decoding jargon.
Analogy
It's like the glossary of nautical terms a new sailor learns before their first voyage — 'port,' 'starboard,' 'bow,' 'stern.' None of these terms alone teaches you to sail the ship, but without them, every instruction the captain gives requires a translation step, slowing everything down. Once the vocabulary is second nature, you can focus entirely on the actual sailing.
Technical explanation
The 30 terms, grouped by theme:
Core loop — Agent: an autonomous AI entity that perceives, reasons, and acts toward a goal. Environment: the world or system in which an agent operates and interacts. Action: a response or task performed by an agent based on its reasoning or goals. Observation: the data or input an agent receives from its environment at any given moment. Goal: the desired outcome an agent is designed to achieve. LLMs: the large language models that enable agents to reason and generate natural language. Tools: APIs or utilities agents use to extend their functionality and interact with the world. Tool call: an API invocation made by an agent to perform a specific task. Feedback loop: a continuous process of collecting outcomes, observing effects, and adjusting actions.
Reasoning — Reflection: an agent's process of self-assessing its actions to improve future performance. Planning: determining the sequence of steps an agent must take to reach its goal. ReAct: a framework where reasoning (thought) and acting (tool use) are combined step by step. Few-shot learning: teaching an agent new behaviors or tasks with just a few examples. Context window: the maximum amount of information an agent can consider at once. System prompt: the persistent background instructions or personality defining an agent's behavior. ARQ (Attentive Reasoning Queries): a structured reasoning approach where an agent solves complex, domain-specific problems step by step via explicit queries.
Memory & knowledge — Short-term memory: temporary context stored during a single session or conversation. Long-term memory: persistent context stored across multiple sessions for continuity and learning. Knowledge base: a structured repository of information agents use for reasoning and decision-making. Context engineering: the practice of shaping what information an agent sees to optimize its output.
Coordination & protocols — Evaluation: the process of assessing how well an agent performs against its intended goals. Orchestration: the coordination and control of multiple agents working together to achieve complex tasks. Multi-agent system: a group of agents collaborating to accomplish a final goal. Human-in-the-loop: a setup where humans intervene or guide the agent's decision-making process. Hierarchical Agents: a multi-level agent structure where a supervisor agent delegates tasks to sub-agents. Guardrails: rules or boundaries that prevent an agent from taking harmful or undesired actions. Guidelines: policies or constraints that keep an agent's behavior aligned with desired outcomes. MCP: a standardized way for agents to connect to external tools, APIs, and data sources. A2A: the Agent-to-Agent protocol enabling agents to communicate and exchange data directly. Router: a mechanism that directs tasks to the most appropriate agent or tool.
Architecture
The glossary itself has an implicit architecture: 9 core-loop terms form the minimal vocabulary needed to describe any single agent; 7 reasoning terms describe how an agent thinks between observation and action; 4 memory/knowledge terms describe how information persists and gets shaped; and 10 coordination/protocol terms describe how multiple agents (or an agent and a human) work together. Understanding a new agentic AI concept usually means placing it correctly into one of these four buckets first.
Workflow
- Skim the full glossary once to get a sense of the 30 terms and their groupings.
- When reading an unfamiliar framework's documentation (CrewAI, LangGraph, AutoGen), actively map its vocabulary onto this glossary's terms — most frameworks use a superset or relabeling of these same core concepts.
- When designing a new agentic system, use the 4 thematic groups (core loop, reasoning, memory, coordination) as a checklist: have you defined your agent's core loop, its reasoning strategy, its memory approach, and its coordination pattern (if multi-agent)?
- Revisit specific terms as needed when they show up in later, deeper topics (e.g., come back to 'ARQ' or 'A2A' after completing the full topics that cover them in depth elsewhere in this category).
Example
GLOSSARY = { # Core loop 'Agent': 'An autonomous AI entity that perceives, reasons, and acts toward a goal.', 'Environment': 'The world or system in which an agent operates and interacts.', 'Action': "A response or task performed by an agent based on its reasoning.", 'Observation': 'The data or input an agent receives from its environment.', 'Goal': 'The desired outcome an agent is designed to achieve.', 'Tools': 'APIs or utilities agents use to extend their functionality.', 'Tool call': 'An API invocation made by an agent to perform a specific task.', 'Feedback loop': 'A continuous process of collecting outcomes and adjusting actions.', # Reasoning 'ReAct': 'A framework combining reasoning (thought) and acting (tool use) step by step.', 'Planning': 'Determining the sequence of steps an agent must take to reach its goal.', 'Reflection': "An agent's process of self-assessing its actions to improve.", 'ARQ': 'Attentive Reasoning Queries — structured, domain-specific reasoning via explicit queries.', # Memory 'Short-term memory': 'Temporary context stored during a single session.', 'Long-term memory': 'Persistent context stored across multiple sessions.', # Coordination 'MCP': 'A standardized way for agents to connect to external tools and data sources.', 'A2A': 'Agent-to-Agent protocol enabling agents to communicate directly.', 'Router': 'A mechanism that directs tasks to the most appropriate agent or tool.', # ... (remaining terms follow the same pattern) }
def define(term: str) -> str: return GLOSSARY.get(term, f"'{term}' not found — check spelling or framework-specific naming.")
Real-world usage
This exact glossary format — a curated list of foundational terms — mirrors how major agent frameworks structure their own 'concepts' or 'glossary' documentation pages (LangGraph's concepts docs, CrewAI's core concepts page, AutoGen's terminology guide). Engineering teams building agentic products commonly maintain an internal version of this same glossary in their onboarding docs, since new hires ramping up on agent work benefit enormously from a single reference page instead of piecing definitions together from scattered blog posts and framework docs. Recruiters and hiring managers screening for 'agentic AI experience' often implicitly test for fluency in exactly this vocabulary during technical interviews.
Trade-offs
A glossary trades depth for breadth — none of these 30 terms is explained in the kind of depth needed to actually implement it (that's what this category's other topics, like ReAct-from-scratch or Memory Architecture, are for). Its value is purely as a fast, low-effort way to build baseline fluency and a shared vocabulary; it should be a starting point for orientation, not a substitute for the deeper implementation-focused topics on the specific concepts you'll actually build.
Visual explanation
A 4-quadrant grid grouping the 30 terms by theme. Quadrant 1 (Core Loop): Agent, Environment, Action, Observation, Goal, LLMs, Tools, Tool call. Quadrant 2 (Reasoning): Reflection, Planning, ReAct, Few-shot learning, Context window, System prompt, ARQ. Quadrant 3 (Memory & Knowledge): Short-term memory, Long-term memory, Knowledge base, Context engineering. Quadrant 4 (Coordination & Protocols): Evaluation, Orchestration, Multi-agent system, Human-in-the-loop, Hierarchical Agents, Guardrails, Guidelines, MCP, A2A, Router, Feedback loop.
Advantages
- —
Builds fast baseline fluency across the entire agentic AI vocabulary in a single pass
- —
Provides a framework-agnostic reference point when different tools (CrewAI, LangGraph, AutoGen) use overlapping or inconsistent terminology
- —
Useful as a quick-reference lookup while reading deeper topics or framework documentation
- —
Helps teams build a shared vocabulary, reducing miscommunication when designing or debugging agentic systems together
Disadvantages
- —
Provides no implementation depth — knowing a term's definition doesn't mean you can build the thing it describes
- —
Some terms (like ARQ or A2A) are new and still evolving, so their exact definitions may shift as the field matures
- —
A glossary alone can create false confidence — being able to define 'ReAct' is not the same as being able to debug a broken ReAct loop
Common mistakes
- —
Treating glossary fluency as equivalent to implementation skill — always pair term definitions with the deeper hands-on topics that teach how to actually build each concept
- —
Using framework-specific jargon interchangeably with these general terms without checking whether the framework means something subtly different
- —
Skipping the glossary entirely and picking up terminology piecemeal from scattered sources, leading to inconsistent or incorrect usage later
- —
Not revisiting the glossary after learning a term's deeper implementation — the two should reinforce each other, not be learned once and forgotten
📂 Subtopics
Core Agent Concepts: Agent, Environment, Action, Observation, Goal, LLMs, Tools
The 7 foundational terms every agent conversation starts with — what an agent actually is, the world it operates in, and the basic loop of acting and observing.
~12 min
Memory and Context Terms: Context Window, System Prompt, Short/Long-Term Memory, Knowledge Base, Context Engineering
The 6 terms covering what an agent 'knows' at any given moment — from the hard limit of its context window to the deliberate practice of shaping what it sees.
~12 min
Planning, Reasoning and Quality Control Terms
The 10 terms covering how an agent figures out what to do, improves through feedback, and stays within acceptable bounds — Planning, ReAct, Reflection, Evaluation, Guardrails and more.
~15 min
Multi-Agent and Protocol Terms: Orchestration, Hierarchical Agents, Router, MCP, A2A
The 7 terms covering how multiple agents (and the tools/other agents they connect to) are coordinated — from orchestration and hierarchy to the MCP and A2A protocols.
~12 min