Introduction to AI Agents

What’s the Difference? Chatbots vs Agents

You’ve probably used ChatGPT, Claude, or a similar AI assistant. You type a message, it replies. Simple, useful, and incredibly powerful for many things.

But there’s a fundamental limitation: these are single-turn interactions. You ask → it answers. The AI doesn’t take any action in the world. It can’t search the web for you, book a meeting, write a file, or send an email. It just generates text.

AI agents are different. An agent receives a goal, not just a question, and then autonomously figures out and executes all the steps needed to achieve it.

Here’s the clearest way to see the difference:

Chatbot interaction:

You: “What companies are competing with us in the AI document processing space?” AI: “Here are the main competitors I know of as of my training data…” (answers, stops)

Agent interaction:

You: “Research our top 5 competitors in AI document processing, find any recent funding announcements, and send me a summary report.” Agent: Searches the web for “AI document processing companies 2024”… Finds 12 companies… Searches for each one’s recent news… Filters for funding announcements… Writes a structured summary… Formats it as a report… Sends it to your inbox.

The agent didn’t just answer, it took a series of actions over multiple steps to accomplish the goal. It made decisions along the way about what to search for, which results were relevant, and how to structure the output.

The Four Key Properties of an Agent

What makes something an “agent” rather than just a smarter chatbot? Four defining properties:

1. Goal-directed. The agent works toward an objective, not just responding to one message. It keeps the goal in mind across many steps.

2. Autonomous action. It can take real actions in the world: calling APIs, running code, reading and writing files, searching the web, sending messages. It’s not just generating text; it’s doing things.

3. Multi-step reasoning. It plans across multiple steps, and adapts that plan based on what it learns. If search result A doesn’t have the information it needs, it tries search B.

4. State persistence. It remembers what it’s done and what it knows across multiple steps within a task. It doesn’t forget what it found in step 3 when it’s working on step 7.

A simple way to remember it: Agent = LLM + Tools + Memory + Loop

The Perception-Reasoning-Action Loop

Every agent, no matter how sophisticated, operates on a fundamental repeating cycle. Understanding this loop is the key to understanding how agents work.

PERCEIVE → What is my current situation?
            (read the task, tool results, memory, messages)
     ↓
REASON  → What should I do next?
            (the LLM thinks it through and decides)
     ↓
ACT     → Execute that action
            (call a tool, run code, generate output)
     ↓
OBSERVE → What happened?
            (read the result of the action)
     ↓
Back to PERCEIVE... until the goal is achieved

Let’s trace through a real example. Goal: “Find the current CEO of Anthropic and write a one-paragraph bio.”

• Perceive: I have a goal. I don’t know the answer from memory.
• Reason: I should search the web for this information.
• Act: Call search_web(query="Anthropic CEO 2024").
• Observe: Search returns: “Dario Amodei is the CEO of Anthropic, which he co-founded in 2021…”
• Perceive: I have the information I need.
• Reason: I have enough to write the bio now.
• Act: Generate a paragraph summarising what I found.
• Observe: I’ve completed the goal.
• Stop.

Each loop iteration moves the task forward. The agent adapts to what it finds.

The Four Agent Capability Axes

Think about any AI agent along four dimensions. These determine what kind of agent it is and what it can do.

1. Planning

How does the agent break down a complex goal?

• Reactive: responds to each situation as it comes, no explicit plan. Fast but unpredictable for complex tasks.
• Plan-then-execute: generates a full plan first, then executes step by step. More reliable but rigid.
• Dynamic replanning: starts with a plan but revises it based on what it learns. Most powerful but also most complex.

2. Tools

What can the agent actually do?

• Web search, code execution
• File read/write
• Database queries
• Email, calendar, messaging
• Domain-specific APIs (CRM, payments, sensors)

An agent is only as capable as its tools. If it doesn’t have a tool for something, it can’t do it.

3. Memory

What can the agent remember?

• In-context: everything in the current conversation (limited by context window)
• External short-term: a scratchpad or database for the current task
• Long-term: past experiences retrieved via semantic search

4. Multi-Agent

Does it work alone, or with others?

• Single agent: one LLM, one loop, one set of tools
• Orchestrator + workers: a coordinator delegates to specialised sub-agents
• Peer agents: multiple agents collaborate as equals

Honest About Limitations

Understanding where agents fail is just as important as understanding how they work. Here are the real failure modes you’ll encounter:

Context exhaustion. Long tasks accumulate lots of text, tool results, intermediate thinking, conversation history. Eventually, the context window fills up and early context falls away, causing the agent to “forget” crucial earlier information.

Planning failures. Agents get stuck in loops, revisit already-completed steps, or drift from the original goal. The further a task goes from the agent’s training distribution, the more unreliable planning becomes.

Tool hallucination. The LLM might invent tool calls that don’t exist, or pass incorrect parameters to real tools. Strict validation is essential.

Cascading errors. An early mistake corrupts all subsequent steps. The agent confidently builds on wrong assumptions.

Non-determinism. The same agent with the same input can produce different results each run. This makes testing much harder than traditional software.

Cost accumulation. Complex tasks can require 20-50 LLM calls. At real API pricing, poorly designed agents become expensive quickly.

None of these mean agents aren’t valuable, they’re extraordinarily useful. But you should design with these failure modes in mind, not discover them in production.

Exercise: Think of a repetitive task in your own work that involves multiple steps, searching for information, and producing some kind of output. Map it to the agent loop: what would the agent perceive, reason, and act on at each step? What tools would it need? What’s the failure mode that would cause the most damage if it went wrong? Write this down, it’s the mental model for everything you’ll build in this course.