Agentic AI Glossary: 40 Must-Know Terms Explained Simply

On your first day in the support team of an IT company at Indore's Crystal IT Park, your team lead says, "Check the SLA, escalate to L2 if it's a P1, and update the ticket before handover." Every word is English, yet you understand almost nothing.

Within a week the words are second nature, because someone explained each one once, with an example.

Agentic AI is similar. Framework docs use "tool calling", "handoff" and "A2A" as if everyone knows them.

What is agentic AI?

Agent vocabulary works the same way: a few dozen terms make the field readable. This page is that one-time explanation.

Agentic AI is the design of AI systems in which a language model plans and takes actions toward a goal, using tools, memory and a control loop, with limits set by humans.

The terms below are grouped by where they sit in a running agent. If you have not yet read the introduction to AI agents, skim it first; the glossary will then fill in the gaps.

Most glossary terms name one box or one arrow in this loop.

Core agent terms

• Agent: a program in which an LLM repeatedly chooses the next action, such as calling a tool or answering, based on a goal and what it has observed so far.
• Goal: the outcome the agent must achieve, such as "book the cheapest Indore to Delhi train for Friday".
• Environment: everything the agent can observe or change through its tools: databases, files, APIs, websites or other agents.
• Action: one thing the agent does in a step, usually a tool call or a final answer.
• Observation: the result fed back to the agent after an action, such as a search result or an error message.
• Agent loop: the cycle of decide, act, observe, repeated until the goal is met or a limit is hit. It is ordinary code around the model.
• Autonomy: how much the agent decides without human input. It ranges from choosing one branch to setting its own tasks, as described in the five levels of agentic AI.
• Workflow: a fixed sequence of steps written by a developer, possibly with LLM calls inside. Unlike an agent, its path does not change based on the model's choices.

Model and context terms

• LLM (large language model): the neural network that reads text and predicts the next tokens. In an agent it is the decision maker.
• System prompt: standing instructions sent with every call that set the agent's role, rules and output format.
• Context window: the maximum amount of text, measured in tokens, the model can read in one call. Everything the agent knows in a step must fit here.
• Token: a chunk of text, often part of a word, that models read and bill by.
• Context engineering: deciding what goes into the context window on each step: instructions, history, retrieved documents, tool results.
• Few-shot examples: sample inputs and outputs placed in the prompt to show the model the expected behaviour.
• Structured output: model output forced into a fixed format such as JSON, so code can parse it reliably.
• Reasoning (chain of thought): the model working through intermediate steps before deciding. Some models do this internally; others are prompted to write their reasoning out.

Tools, protocols and orchestration terms

• Tool: a function the agent can request, described by a name, a description and parameters. Your code runs it, not the model.
• Tool calling (function calling): the model returning a structured request, a tool name plus arguments, instead of plain text. See tools and function calling.
• Tool schema: the JSON Schema that defines a tool's parameters, types and required fields.
• MCP (Model Context Protocol): an open standard that lets an agent discover and call tools from external servers through one common interface. Start with what MCP is.
• A2A (Agent2Agent protocol): an open protocol for agents built by different teams or vendors to discover each other and exchange tasks.
• AG-UI (Agent-User Interaction protocol): an open protocol for streaming an agent's progress, tool activity and state to a user interface. Both protocols are explained in agent protocols: A2A and AG-UI.
• ReAct: a pattern where the model alternates a thought, an action and an observation.
• Planning: having the model write the steps of a task before executing them, often with dependencies between steps.
• Reflection: the model, or a separate critic, reviewing an output against criteria and revising it.
• Router: a component, often an LLM classification, that sends a request to one of several predefined paths or agents.
• Orchestration: the logic that decides which agent or step runs next and passes information between them.
• Multi-agent system: several agents with distinct roles that cooperate on a task. Patterns are compared in multi-agent system patterns.
• Handoff: one agent transferring control of the conversation to another agent that is better suited.
• Hierarchical agents: a structure where a supervisor agent splits work, delegates to worker agents and combines their results.

Memory, safety and operations terms

• Short-term memory: the current conversation and steps held in the context window. It disappears when the session ends.
• Long-term memory: information stored outside the model and retrieved across sessions, split into semantic (facts), episodic (events) and procedural (how-to). See memory in AI agents.
• Knowledge base: a collection of documents, such as manuals or policies, that an agent can search.
• RAG (retrieval-augmented generation): retrieving relevant passages and adding them to the prompt before the model answers.
• Agentic RAG: RAG where the agent decides when and where to search, can rewrite queries and can check whether results are good enough. See agentic RAG.
• Guardrails: checks around the agent that block or modify unsafe inputs, actions or outputs, such as step limits and tool allowlists.
• Human-in-the-loop: a design where a person approves, edits or rejects certain actions before they happen.
• Prompt injection: malicious instructions hidden in content the agent reads, such as a web page, that try to override its real instructions.
• Hallucination: confident output that is false or unsupported, including invented tool arguments.
• Trace: the full record of a run: every prompt, tool call, result, token count and timing. Traces are how you debug and evaluate agents.

See the terms in a single agent run

The simulation below prints a short agent run and labels each event with the glossary term it illustrates. Nothing calls a real model; the events are scripted so you can focus on the vocabulary.

run = [
    ("system prompt", "You are a train-booking assistant. Max 4 steps."),
    ("goal",          "Cheapest Indore to Delhi sleeper on Friday"),
    ("reasoning",     "I need train options first"),
    ("tool call",     "search_trains(from='INDB', to='NDLS', date='Fri')"),
    ("observation",   "3 trains found, cheapest Rs 685"),
    ("short-term memory", "history now holds 1 call and 1 result"),
    ("guardrail",     "book_ticket needs approval: paying money"),
    ("human-in-the-loop", "user approved the Rs 685 booking"),
    ("tool call",     "book_ticket(train='cheapest', class='SL')"),
    ("observation",   "booking confirmed, PNR saved"),
    ("long-term memory", "saved: user prefers sleeper class"),
    ("final answer",  "Booked the Rs 685 sleeper for Friday"),
]
steps = 0
for term, detail in run:
    if term == "tool call":
        steps += 1
    print(f"[{term:>17}] {detail}")
print(f"\nTool calls: {steps}  (each one counted toward the step limit)")

Read the labels top to bottom and you have an agent's whole lifecycle in twelve lines. A real trace has the same shape, plus timings and token counts.

Commonly confused agentic AI terms

The pitfalls to avoid follow directly from the table. Don't call every LLM feature an "agent", because it sets the wrong expectations about cost and risk. Don't assume that writing a rule in the system prompt makes it a guardrail. And don't treat MCP as a replacement for tool calling: an MCP tool still reaches the model through tool calling.

Key takeaways

• Agentic AI is about models that act toward goals through tools, memory and loops.
• Core terms (goal, action, observation, loop) describe a single agent's cycle.
• Context terms decide what the model sees; tool and protocol terms decide what it can do.
• Memory, guardrail and trace terms decide what it remembers, what it may not do and how you check it.
• Next, put the vocabulary to work by building a ReAct agent from scratch.