← Back to Table of Contents

Chapter 3 — Anatomy of an Agent

“An agent is just an LLM that runs in a loop, using tools, and checking its work.” — Harrison Chase, creator of LangChain

The Four Pillars

Every modern AI agent is built from four core components. Think of it like the human analogy: a brain, hands, memory, and a plan.

Pillar 1: The LLM (Brain)

The LLM is the reasoning engine. It:

• Understands the user’s goal from natural language
• Decides what to do next at each step
• Generates tool calls, code, or natural language responses
• Evaluates whether results are satisfactory

Which LLM for Agents?

Not all LLMs are equal for agent tasks. Key requirements:

Best choices for agents (2026): GPT-4o, Claude 3.5/4, Gemini 2.0, Llama 3.3 (local), Qwen 2.5

The System Prompt Is Everything

For agents, the system prompt defines the agent’s identity, capabilities, and constraints:

You are a research assistant agent. You have access to the following tools:
- web_search: Search the internet for current information
- read_file: Read contents of a local file
- write_file: Write content to a local file

RULES:
1. Always search before answering factual questions
2. Never modify files without user confirmation
3. If unsure, ask the user for clarification
4. Cite your sources

Pillar 2: Tools (Hands)

Tools give agents the ability to interact with the world. Without tools, an agent is just a chatbot.

A tool is defined as a function schema that tells the LLM what it can do:

tools = [{
    "type": "function",
    "function": {
        "name": "web_search",
        "description": "Search the web for current information on a topic",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "The search query"
                }
            },
            "required": ["query"]
        }
    }
}]

Deep dive: Chapter 5 — Tools & Function Calling

Pillar 3: Memory

Agents need memory to maintain context, learn from past interactions, and access knowledge.

The key challenge is context window management — as the conversation grows, you run out of space. Solutions:

• Summarization: Condense older messages into a summary
• Sliding window: Keep only the last N messages
• RAG: Store everything in a vector DB, retrieve only what’s relevant
• Hybrid: Summarize old context + retrieve specific facts on demand

Deep dive: Chapter 6 — Memory Systems

Pillar 4: Planning

Planning is how agents break complex goals into manageable steps.

Plan-and-Execute Pattern

# Simplified plan-and-execute
plan = agent.create_plan("Write a blog post about quantum computing")
# plan = ["1. Research recent quantum computing breakthroughs",
#          "2. Outline the blog structure",
#          "3. Write the draft",
#          "4. Review and edit"]

for step in plan:
    result = agent.execute(step)
    if not agent.evaluate(result):
        plan = agent.replan(result, remaining_steps)

Deep dive: Chapter 7 — Planning & Reasoning

How It All Fits Together

Real-World Example: A Coding Agent

Let’s trace how GitHub Copilot Workspace (a real agent) handles “Add dark mode to my app”:

1. Planning: Reads codebase → identifies relevant files → creates a multi-step plan
2. LLM reasoning: “I need to modify the CSS variables and add a toggle component”
3. Tool use: Reads files, writes new code, runs the linter
4. Memory: Keeps track of which files were changed, what errors occurred
5. Self-correction: Linter reports an error → agent reads the error → fixes the code → reruns

This is the anatomy in action. Every agent, from a simple chatbot with search to a multi-agent coding system, builds on these four pillars.

What’s Next

Now let’s look at the engine that drives all this — the agent loop. How does an agent decide when to think, when to act, and when to stop?

Next: Chapter 4 — The Agent Loop →

← Previous: Chapter 2 — History & Evolution · Next: Chapter 4 — The Agent Loop →

Last updated: April 2026