Day 3 – Core Components Of An AI Agent

Big Picture First: An Agent Is Not a Single Thing

Before we dive into components, let’s reset the mental model.

👉 An AI Agent is a system of coordinated parts, not a single model, prompt, or API call.

Think of it like a smartphone:

A screen alone is useless
A processor alone can’t help you
Apps without storage are pointless

It’s the combination that creates intelligence.

Agentic AI works the same way.

The 5 Core Components of an AI Agent (High-Level View)

Here’s the canonical breakdown used in real production systems:

#	Component	Role
1️⃣	LLM (Brain)	Reasoning & language understanding
2️⃣	Planner	Decides what to do next
3️⃣	Tools	Enables actions in the real world
4️⃣	Memory	Remembers past & context
5️⃣	Control Loop	Orchestrates perception → action

We’ll walk through each—with examples you can immediately relate to.

🧠 Component 1: The LLM (The Brain)

What It Does

The LLM is responsible for:

Understanding instructions
Interpreting observations
Reasoning about next steps
Generating structured decisions

It is not responsible for:

Executing tools
Managing state
Tracking goals
Controlling cost

🔑 LLMs think. Agents act.

Real-World Analogy

🧑‍💼 LLM = Subject-Matter Expert

Gives advice
Explains reasoning
Suggests options

But someone else still needs to run the process.

Common Mistake ❌

Putting everything into the prompt:

Planning
Memory
Error handling
Tool decisions

This leads to:

Fragile prompts
Token bloat 💸
Unpredictable behavior

🧭 Component 2: The Planner (The Decision Maker)

This is where agents truly differ from chatbots.

What the Planner Does

The Planner:

Breaks a goal into steps
Chooses execution order
Decides when to stop
Revises plan after failures

Planner in Action (Mini Example)

🎯 Goal: “Resolve a customer refund issue”

Planner output:

Identify transaction
Check refund policy
Validate eligibility
Initiate refund
Notify customer

If step 3 fails → revise plan or escalate.

Types of Planners (You’ll See These Again)

Planner Type	Behavior
ReAct	Think → Act → Observe
Plan-and-Execute	Plan first, then run
Hierarchical	Goals → sub-goals
Manager–Worker	Delegates to sub-agents

💡 Planning is what gives agents autonomy.

🛠 Component 3: Tools (Hands & Legs)

An agent without tools is like a brain in a jar 🧠🫙.

What Counts as a Tool?

Anything that lets the agent do something:

REST APIs
Databases
Browsers / search
Code execution
Internal systems (Jira, GitHub, CRM)

Tool Selection Flow

User Goal
   ↓
Planner decides action
   ↓
LLM selects tool + arguments
   ↓
Tool executes
   ↓
Result returned to agent

This separation is critical for safety.

Example: Research Agent 🔍

Step	Tool
Search topic	Web search API
Fetch sources	Browser tool
Summarize	LLM
Save notes	Database

Anti-Pattern ❌

Hardcoding tool usage inside prompts.

✅ Tools should be externally controlled and auditable.

🧠 Component 4: Memory (Short-Term vs Long-Term)

Memory is what turns agents from clever into useful.

Two Types of Memory

Type	Purpose	Example
Short-term	Current task context	Steps completed
Long-term	Cross-session learning	Past failures, preferences

Memory Architecture Diagram

Observation
   ↓
Short-Term Memory (Task State)
   ↓
Relevant Recall
   ↓
LLM Reasoning
   ↓
Optional Long-Term Write

Example: DevOps Agent ⚙️

Long-term memory stores:

Past incidents
Known fixes
Rollback strategies

Result: Faster resolution over time.

Common Pitfall ❌

Dumping everything into vector memory.

🔴 Memory must be curated, not infinite.

🔁 Component 5: Control Loop (The Conductor)

This is the most underestimated component.

What the Control Loop Does

It:

Runs the agent step-by-step
Enforces limits (time, cost, steps)
Handles retries
Detects failures
Stops runaway behavior

The Agent Loop (Visual)

Perceive → Reason → Plan → Act → Observe
      ↑_______________________________↓

This loop continues until a stop condition is met.

Safety Hooks 🔐

A good control loop includes:

Max steps
Budget limits
Tool allowlists
Human approval gates

Putting It All Together: Full Agent Architecture 🧩

           Goal
            ↓
        Planner 🧭
            ↓
    ┌──────────────┐
    │     LLM 🧠     │
    └──────────────┘
      ↓          ↓
 Tools 🛠     Memory 🧠
      ↓          ↑
   Environment / Systems

        ↑
   Control Loop 🔁

Each component has clear responsibility boundaries.

Interactive Exercise 📝 (Do This!)

Pick a real task you do weekly.

Fill this table:

Question	Your Answer
Goal	?
Decisions needed	?
Tools used	?
What must be remembered?	?
Failure scenarios	?

If you can fill this out—you can design an agent.

Common Architecture Mistakes 🚨

Mistake	Consequence
No planner	Random behaviour
No memory	Repeated failures
No control loop	Infinite runs 💸
LLM does everything	Unstable system

Key Takeaways 🎯

Agents are multi-component systems
LLMs are just one part of the puzzle
Planning enables autonomy
Tools enable real-world impact
Memory enables learning
Control loops enable safety

If you design these components explicitly, your agents will be:
✅ Predictable
✅ Scalable
✅ Safe