Day 94: AI Agents Explained

Why Should I Care?

A chatbot gives you an answer. An agent gets you a result. One responds to the world. The other changes it. When you ask a chatbot "book my trip to Bangalore" it tells you how. When you give an agent the same goal it checks your calendar, books the train ticket, reserves the hotel, and sends you a confirmation — all without you typing another word. One goal given. Then silence. Multiple autonomous steps taken. Reports back only when done. That is the difference. And today you learn to build the second kind.

Core Concept

An AI agent is a loop. It runs five stages repeatedly until the goal is complete. Perceive — read the goal and gather information using tools or search. Reason — the LLM decides what the next step should be. Act — call the right tool with the right input. Observe — read the tool output and understand what happened. Adjust — re-plan if the result was unexpected, then loop back. This loop is the agent. It keeps running until the goal is done. No follow-up instructions needed. No hand-holding. Autonomous action in the world — that is the defining feature of an agent.

How It Works

Think of a personal assistant you hire to plan your trip to Bangalore next Friday. You hand over the goal once and go silent. The assistant does not come back every five minutes asking what to do next. She checks the calendar — that is Perceive. She reasons that trains are faster — that is Reason. She books the train ticket — that is Act. She sees the confirmation — that is Observe. She books a hotel near the station — Act again. She sends you the full itinerary — Communicate. An AI agent follows this exact loop. The LLM is the brain deciding each next step. The tools are the hands taking each action. The loop is what makes it an agent and not just a prompt.

GOAL
  |
Perceive     --> read tools, search web, gather context
  |
Reason       --> LLM decides next step
  |
Act          --> calls a tool with the right input
  |
Observe      --> reads tool output
  |
Adjust       --> re-plans if needed
  |
Loop back until --> Goal Complete

Chatbot: User --> Ask --> Answer --> STOP
Agent:   User --> Goal --> Plan --> Tools --> Actions --> Check --> COMPLETE
The difference is autonomous action.

Real World Connection

When you use Swiggy''s reorder feature and it automatically applies your last address, selects the same restaurant, and pre-fills your payment — that is a simple agent loop. When a customer support AI at a bank receives your complaint, looks up your account, identifies the issue, raises a ticket, and sends you a resolution timeline without a human touching it — that is a full agent in production. When GitHub Copilot reads an error in your code, searches documentation, writes a fix, and suggests the edit in the right line — perceive, reason, act, observe — agent loop. Every AI product moving from "assistant" to "autonomous" is making this exact upgrade. Now you understand what that upgrade actually means.

Examples

goal  = "Plan trip to Bangalore next Friday"
steps = [
    ("search_web",        "best trains to Bangalore Friday"),
    ("book_ticket",       "Bangalore"),
    ("send_confirmation", "Trip to Bangalore booked for Friday")
]

print("== AI Agent Running ==")
for i, (tool, arg) in enumerate(steps, 1):
    print(f"Step {i}: [{tool}] --> {arg}")
    result = tools[tool](arg)
    print(f"Result  : {result}\n")

print("== Goal Complete ==")

# OUTPUT:
# Step 1: [search_web] --> best trains to Bangalore Friday
# Result : Found relevant data
#
# Step 2: [book_ticket] --> Bangalore
# Result : Ticket to Bangalore booked successfully
#
# Step 3: [send_confirmation] --> Trip to Bangalore booked for Friday
# Result : Confirmation sent
#
# == Goal Complete ==
# One goal. Three autonomous actions. Zero hand-holding.

Common Mistakes

Mistake 1 — Thinking AI agents are just chatbots with a fancy name:

-- WRONG:
def chatbot(prompt):
    return llm_call(prompt)
# responds to prompts -- stops after one answer
# no tools, no loop, no autonomous action
# this is a chatbot, not an agent

-- CORRECT:
def agent_loop(goal, max_steps=10):
    for step in range(max_steps):
        next_action = llm_decide(goal, history)
        result      = tools[next_action.tool](next_action.input)
        history.append(result)
        if goal_complete(result):
            return result
# acts autonomously across multiple steps using tools
# that is the defining feature of an agent

Mistake 2 — Building agents without exit conditions or oversight:

-- WRONG:
while not goal_complete:
    result = agent.act()
# no max steps -- agents chain mistakes
# one wrong step triggers the next forever
# infinite loop with no way out

-- CORRECT:
def agent_loop(goal, max_steps=10):
    for step in range(max_steps):
        try:
            result = agent.act(goal)
            if goal_complete(result):
                return result
        except Exception as e:
            log_error(e)
            return fallback_response()
    return "Max steps reached -- human review needed"
# always include max steps, error handling,
# and human approval gates for irreversible actions

Mini Challenge

Quick Quiz

Q: What are the five stages of an AI agent loop?
A: Perceive — gather information. Reason — LLM decides next step. Act — call the right tool. Observe — read the result. Adjust — re-plan if needed. Then loop until the goal is complete.

Q: What is the fundamental difference between a chatbot and an agent?
A: A chatbot responds to a prompt and stops. An agent takes a goal, plans autonomously, calls tools, observes results, and loops until the goal is done — no further instructions needed.

Q: Why must every agent loop have a max_steps limit?
A: Because agents chain mistakes — one wrong step triggers the next forever without a limit. A max_steps ceiling stops infinite loops and routes the agent to human review when it cannot complete the goal.

Bonus Knowledge

The agent loop you built today is the foundation of every major AI agent framework — LangChain, AutoGen, CrewAI, and LlamaIndex all implement variations of this exact perceive-reason-act-observe-adjust cycle. The key upgrade from a simple loop to a production agent is memory — storing past steps so the agent does not repeat actions it already tried. The second upgrade is tool selection — instead of a hardcoded plan, the LLM reads tool descriptions and chooses autonomously which tool to call next based on what it observed. Day 95 covers tools in depth. Day 96 covers multi-agent systems where multiple loops coordinate together. You are one day away from building agents that actually choose their own tools. The loop is ready. Now give it hands.

Key Takeaways