"Once these words feel familiar, agent tutorials and docs suddenly read like plain English. Bookmark this page."
Learning Objectives
By the end of this module, you will be able to:
- Recognize the key AI-agent terms
- Explain each in plain language
- Read agent articles and docs with confidence
The Essential Terms
| Term | Plain-language meaning |
|---|---|
| AI agent | Software that uses an LLM to plan, use tools, and act toward a goal. |
| LLM | Large Language Model — the reasoning "brain" of an agent. |
| Agent loop | The repeating cycle: think → act → observe → repeat until done. |
| ReAct | A pattern where the agent reasons, then acts, then reasons again. |
| Tool | An action an agent can take (search, email, calculator, code…). |
| Function calling | The mechanism where the LLM requests a tool and your app runs it. |
| Orchestrator | The "manager" that runs the loop and coordinates the pieces. |
| System instructions | The agent's role, rules, and personality. |
| Context window | How much text the model can consider at once (short-term memory). |
| Memory | Information the agent stores and recalls, within or across sessions. |
| RAG | Retrieval-Augmented Generation — look up relevant facts, then answer from them. |
| Embedding | Turning text into numbers that capture meaning, so search finds it. |
| State | Where the agent is in the current task (its progress). |
| Guardrail | A safety limit on what the agent is allowed to do. |
| Human-in-the-loop | A person approves key or risky steps before they happen. |
| Prompt injection | Hidden malicious instructions in content the agent reads. |
| Autonomous agent | An agent that plans its own steps freely toward a goal. |
| Workflow | A fixed, pre-defined sequence of steps (predictable, easy to trust). |
| Multi-agent system | Several agents with roles collaborating on a task. |
Key idea: Notice how these terms build on each other: an agent runs a loop, using tools (via function calling), guided by system instructions, grounded by RAG, aided by memory, kept safe by guardrails, and coordinated by an orchestrator. That's the whole track in one sentence.
Explain like I'm new: You don't need to memorize this table. Skim it now so the words feel familiar, then come back whenever a tutorial throws a term at you. Vocabulary sticks through use, not cramming — the fifth time you meet "embedding" in the wild, this page will make it obvious.
A Quick Way to Group Them
If nineteen terms feel like a lot, tie them to the questions from Module 1 — goal, tools, stopping point — plus a couple of extras:
- The thinker: LLM, system instructions, ReAct, state.
- The doing: tool, function calling, agent loop, orchestrator.
- The knowing: memory, context window, RAG, embedding.
- The safety: guardrail, human-in-the-loop, prompt injection.
- The shapes: workflow, autonomous agent, multi-agent system.
Grouping them like this turns a flat list into a small map. When you read "the orchestrator called a tool," you instantly know you're in the doing group; when you hit "embedding," you're in the knowing group. That mental filing system is what makes docs readable.
A few of these terms trip up beginners because they sound similar but mean different things. Tool and function calling are a pair: the tool is the action (send an email), and function calling is the mechanism the model uses to request it. Memory and context window overlap too: the context window is the short-term space the model reads right now, while memory usually means the longer-term store it writes to and pulls from. And workflow versus autonomous agent is the big spectrum from Module 4 — fixed, scripted steps on one end, self-directed planning on the other. If you can keep those three pairs straight, most agent writing will read clearly.
Don't feel you must learn all nineteen before moving on, either. Five or six — agent, loop, tool, RAG, guardrail, orchestrator — carry most conversations. The rest will attach themselves naturally as you build and read, and this page will be here whenever a new one shows up.
Key Takeaway: These ~19 terms cover the agent world: the agent and its loop, tools and function calling, the orchestrator, memory and context, RAG and embeddings, guardrails and human-in-the-loop, prompt injection, and the workflow-vs-autonomous spectrum. Keep this page as your quick reference.