"Under the hood, every agent is a handful of simple parts working together. Learn the parts, and agents stop feeling like magic."
Learning Objectives
By the end of this module, you will be able to:
- Name the core parts that make up an agent
- Explain what each part does in plain language
- See how the parts fit around the LLM
1. The Parts Around the Brain
At the center of an agent is the LLM — the reasoning brain. But a brain alone can only think. It has no way to look things up, remember yesterday, or press a button in the real world. The other components give it instructions, abilities, memory, and safety — everything a mind needs to actually get work done.
2. The Components, One by One
| Component | In plain words | Example |
|---|---|---|
| Model (LLM) | The reasoning brain that decides what to do | GPT, Claude, Gemini |
| System instructions | Its role, rules, and personality | "You are a careful travel assistant" |
| Tools / function calling | The actions it can take | search, send email, query a database |
| Memory | What it remembers within and across sessions | "The user prefers window seats" |
| Knowledge (RAG) | Facts it can look up on demand | your company handbook |
| State | Where it is in the current task | "Step 2 of 4 done" |
| Guardrails | Safety limits on what it may do | "Never spend over $50 without asking" |
| Evaluation | Checking whether it's doing a good job | tests, scores, human review |
Key idea: Think of the LLM as a smart new employee. System instructions are the job description, tools are the software they can use, memory is their notebook, RAG is the company wiki, guardrails are the rules, and evaluation is their performance review.
Explain like I'm new: Don't worry about memorizing all eight at once. The two that matter most on day one are the model (the thinker) and its tools (the doers). Everything else — memory, knowledge, guardrails — is there to make the thinker smarter, safer, and more consistent over time.
3. How They Work Together
When the agent runs, the system instructions shape its behavior, it reasons with the model, checks memory and knowledge for context, uses tools to act, tracks progress in state, stays inside its guardrails, and its work is judged by evaluation. Remove any one and the agent gets weaker — a toolless agent can't act; a memoryless one forgets; a guardrail-less one is risky.
Here's a quick picture. A travel agent gets a goal ("book my trip"). Its system instructions tell it to be careful with money. It uses memory to recall you like aisle seats, checks knowledge for the company travel policy, calls a booking tool, tracks in state that flights are booked but the hotel isn't, and its guardrail stops it from spending over your limit without asking. Every part played a role.
It's easy to overlook the last component, evaluation, because it doesn't help the agent act — it helps you know whether the agent is any good. Evaluation is how you catch an assistant that quietly gives wrong answers 20% of the time. It can be as formal as automated test cases ("given this question, did it retrieve the right document?") or as simple as a human skimming a sample of outputs each week. Without it, you're flying blind: the agent might be failing often and you'd never know until a user complains. Think of it as the difference between a new hire who's never reviewed and one whose work you spot-check — the review is what turns "seems fine" into "actually reliable."
Beginner tip: You rarely build all eight parts on day one. Most beginner agents start with just three: a model, clear system instructions, and one tool. Add memory, RAG, and guardrails as your project needs them.
Common mistake: Trying to wire up all eight components before your agent does anything at all. It's easy to spend a week building memory and RAG for an agent that can't yet call a single tool. Get the simple three-part version working first, then grow.
Key Takeaway: An agent is an LLM surrounded by supporting parts: system instructions (its rules), tools (its actions), memory (what it recalls), knowledge/RAG (what it looks up), state (its progress), guardrails (its limits), and evaluation (its report card). Start with a model, instructions, and one tool — then grow.