The AI Buzzword Glossary: From Agents to Agentic AI
Every week brings a fresh wave of AI terminology. “Agentic AI,” “RAG,” “MCP,” “context engineering” — the words pile up faster than anyone can keep track of them, and half the time they’re used loosely or interchangeably.
This post is a no-jargon reference. Each term gets a plain-English definition (what it is), a quick real-world example, and a short note on what it’s for — so you can read a vendor blog or a conference talk without nodding along to words you don’t actually use yourself.
The terms are grouped by theme so related ideas sit together.
1. Core Agent Terminology
This is the cluster everyone is talking about — the shift from chatbots that answer to systems that act.
| Term | What it is | What it’s for |
|---|---|---|
| AI Agent | An LLM-powered system that can take actions — call tools, hit APIs, run code — to accomplish a goal, not just produce texte.g., an agent that reads a support ticket, looks up the order, and issues a refund | Automating multi-step tasks like data lookups, ticket resolution, or bookings |
| Agentic AI | The broader paradigm where AI plans, decides, executes, and self-corrects with some degree of autonomye.g., a system that books a trip end-to-end — comparing flights, choosing, and reserving | The umbrella term for moving from “assistant that talks” to “system that does” |
| Autonomous Agent | An agent that runs with minimal or no human input, looping until its goal is mete.g., a monitor that watches logs overnight and opens a ticket when it spots an anomaly | Background jobs, monitoring, “set and forget” workflows |
| Multi-Agent System (MAS) | Several specialized agents collaborating, each owning a sub-taske.g., a research agent hands findings to a writer agent, which hands copy to an editor agent | Complex workflows where one agent coordinates others (planner + researcher + writer) |
| Orchestration | The control layer that decides which agent, tool, or model handles each stepe.g., routing a customer query to the billing agent vs. the tech-support agent | “Who does what next” in a multi-agent flow |
| Copilot / Assistant | A human-in-the-loop agent embedded in an app that suggests or assists rather than acting alonee.g., code suggestions that appear inline as you type | Productivity inside everyday tools |
2. Architecture & Reasoning Patterns
How agents are actually wired up under the hood.
| Term | What it is | What it’s for |
|---|---|---|
| RAG (Retrieval-Augmented Generation) | Fetching relevant documents or data and feeding them to the model before it answerse.g., a chatbot that pulls from your policy document before answering an HR question | Grounding answers in your own data; reducing hallucination |
| Grounding | Tying model output to authoritative source datae.g., an answer that links to the exact document the fact came from | Trust, citations, accuracy |
| Chain-of-Thought (CoT) | Prompting the model to reason step-by-step before answeringe.g., showing the working before giving the final answer to a word problem | Better results on math, logic, and multi-step problems |
| ReAct (Reason + Act) | A pattern where the model alternates between reasoning and tool-callinge.g., “I need today’s weather” → calls the weather API → then answers | The backbone of most agent loops |
| Reasoning Model | A model trained to “think” longer before respondinge.g., spending extra time to work through a tricky coding bug | Hard problems that need deliberation |
| Tool Use / Function Calling | The model invoking external functions or APIs in a structured waye.g., calling getWeather(“Bengaluru”) instead of guessing the temperature | How agents actually do things rather than just describe them |
| Context Engineering | Deliberately designing everything that goes into the model’s context windowe.g., choosing which past messages and documents to include in a long support chat | The evolution of “prompt engineering” for agents |
3. Models & Foundations
The engines that power everything above.
| Term | What it is | What it’s for |
|---|---|---|
| LLM (Large Language Model) | A model trained on massive text to generate languagee.g., the model behind a chat assistant that drafts an email | The core engine of most GenAI |
| SLM (Small Language Model) | A compact, cheaper, faster modele.g., a small model running on a phone to summarize notes offline | On-device, low-latency, cost-sensitive tasks |
| Foundation Model | A large pre-trained model reusable across many taskse.g., one base model adapted for chat, coding, and search | The base you build or fine-tune on |
| Frontier Model | The newest, most capable models at the cutting edgee.g., the latest flagship model topping the benchmarks | Benchmark-leading and demanding workloads |
| Multimodal | Handles a mix of text, images, audio, and videoe.g., asking a question about a photo you uploaded | Document understanding, vision tasks, voice |
| GenAI (Generative AI) | Umbrella term for AI that creates contente.g., generating text, images, code, or audio from a prompt | The whole category |
4. Data & Memory
Where agents get their knowledge — and how they remember.
| Term | What it is | What it’s for |
|---|---|---|
| Embeddings | Numeric vector representations of text or data that capture meaninge.g., “cancel my order” and “I want a refund” land close together as similar | Semantic search, similarity, RAG retrieval |
| Vector Database | A store optimized for embeddingse.g., a search index that finds the most relevant document chunks for a question | Fast semantic lookup that powers RAG |
| Knowledge Source | The grounding data an agent draws one.g., a document library the agent searches before answering | Accurate, domain-specific answers |
| Memory | Persistence of context across turns or sessionse.g., the assistant remembering your name and preferences across chats | Personalization and long-running agents |
5. Protocols & Interoperability
The newest layer — standards that let agents and tools talk to each other without custom glue code.
| Term | What it is | What it’s for |
|---|---|---|
| MCP (Model Context Protocol) | An open standard introduced in late 2024 for connecting AI models to external tools and data sourcese.g., linking an assistant to your files and calendar through one standard | Plug-and-play connectors — often described as “USB-C for AI tools” |
| A2A (Agent2Agent) | An open protocol introduced in 2025 (now under the Linux Foundation) for agents to discover, message, and delegate to one anothere.g., a travel agent handing a payment task to a separate payments agent | Cross-vendor collaboration between agents |
| Connector / Plugin | A packaged integration giving an agent access to a specific systeme.g., a connector that lets an agent read tickets from a service-desk tool | Extending agents to enterprise systems |
MCP vs. A2A in one line: MCP connects an agent to its tools and data; A2A connects an agent to other agents. They’re complementary, not competing.
6. Build & Tuning
The practical side — making, shaping, and trusting models.
| Term | What it is | What it’s for |
|---|---|---|
| Fine-tuning | Further training a model on your own datae.g., training on past support replies so the model matches your tone | Specialized tone, domain, or behavior |
| Prompt Engineering | Crafting effective instructionse.g., adding “answer in three bullet points” to control the format | Steering model output |
| Inference | Running the model to produce output (as opposed to training it)e.g., the compute cost charged each time you send a request | The “cost per use” side of the equation |
| Guardrails | Safety and policy filters around inputs and outputse.g., blocking the model from revealing personal or sensitive data | Preventing harmful or off-policy responses |
| Evals (Evaluations) | Systematic testing of model or agent qualitye.g., running 100 test questions to check accuracy before launch | Measuring accuracy and catching regressions |
| Hallucination | Confident but wrong or fabricated outpute.g., the model inventing a citation or statistic that doesn’t exist | The core problem that grounding and RAG try to solve |
How It All Fits Together
If you read the tables top to bottom, a rough mental model emerges:
- A foundation model (an LLM) provides the raw intelligence.
- Wrap it in a reasoning pattern like ReAct, give it tool use, and you have an agent.
- Ground it with RAG over a vector database so it answers from real data.
- Connect it to systems via MCP, and to other agents via A2A.
- Coordinate several of them through orchestration to build a multi-agent system.
- Keep it honest with guardrails and measure it with evals.
That progression — from a single model to a coordinated, tool-using, self-correcting system — is essentially what people mean when they say agentic AI.
Know a buzzword that should be on this list? The vocabulary keeps growing — this glossary will too.
