1.2 From Chatbots to Agents

A common mental model of AI is a chat window: you type, it responds, and you move the answer somewhere useful. An agent adds tools and an action loop to that interaction.

What you will learn

• Define the difference between a chatbot and an agent in one sentence.
• Describe the agentic loop: gather, act, verify.
• Explain why the same model can be a toy in one setup and a teammate in another.

Builder principle

A chatbot generates responses. An agent can attempt actions through granted tools. Verify both.

The one-sentence difference

A chatbot primarily responds in conversation. An agent can use tools to pursue a bounded outcome across multiple steps.

The same or a similar language model may sit underneath. The difference is the harness around it: tools, permissions, context, feedback, and stop conditions. Those additions expand capability and risk; they do not guarantee completion.

A concrete comparison

Say your goal is: "I need a landing page for my candle business."

🌱 With a chatbot⚙️ With an agent

1. You ask for landing page copy. It writes some. You copy it into a doc.
2. You ask for HTML. It writes a wall of code. You have no idea what to do with it.
3. You paste the code somewhere, something breaks, you paste the error back.
4. Forty tabs later you have fragments of a website and a headache.

The chatbot did its job. You were the glue, the hands, and the debugger.

1. You describe the business, the vibe, and what "done" means.
2. The agent creates the files, writes the code, previews the result, notices the mobile layout is broken, fixes it, and tells you how to see it.
3. You review, request changes in plain language, and approve.
4. There is a real website in a real folder, under version control, ready to deploy.

You were the director. The agent was the crew.

The agentic loop

Many practical agent harnesses can be understood through this simplified cycle:

┌─→  GATHER   — read files, check state, understand the task
│        ↓
│    ACT      — write code, edit files, run commands
│        ↓
└─   VERIFY   — run it, test it, read the errors, check the result
         ↓
     (repeat until done — or until it needs you)

This loop is the single most important mental model in the course. Notice what it implies:

• The agent's first move is reading, not writing. What it can see determines what it can do — that's why Chapter 5 (context engineering) is the heart of the course.
• The agent checks its own work — but its verification and your verification are different steps. Yours is the one that counts.
• The loop runs many times per task. Small loops, compounding. Exactly like a good human worker.

Same model, different animal

Model capability is only part of system behavior. The other part is the harness — the tools, permissions, memory, and guardrails around it.

A harness may let a model attempt code changes, site construction, or workflow steps that a chat-only interface cannot execute. Failure can come from the model, context, tools, environment, task design, or verification; diagnose those parts instead of assigning every outcome to one component.

This course teaches you to build the harness: context (Chapter 5), Skills (Chapter 7), tools via MCP (Chapter 8), guardrails via hooks (Chapter 9), and teams of agents (Chapter 10).

Where Claude Code fits

Claude Code is the implementation this course builds with: Anthropic's agent that lives in the terminal, reads and writes real files, and runs commands through a gather–act–verify loop. The course uses one concrete tool so you can practice deeply. Chapter 2 separates the transferable concepts from Claude-specific files and controls; portability is something you will test, not something tool loyalty guarantees.

Watch

Mastering Claude Code in 30 Minutes — Boris Cherny, the creator of Claude Code. Watch it now for the flavor; rewatch it after Chapter 6 and you'll catch everything you missed.

Try it now

Take one task from the list you made in Lesson 1.1 and write it two ways:

1. As a chatbot request — "Write me a…"
2. As an agent brief — what does done look like? What files or information would the worker need? How would you check the result?

Feel the difference? The second one is a skill. It has a name — context engineering — and by Chapter 5 you'll be doing it on instinct.

Check your understanding

• What's the one-sentence difference between a chatbot and an agent?
• Name the three steps of the agentic loop. Why does it start with gather and not act?
• What is a harness, and why does it explain "the same model acting smart in one place and dumb in another"?
• Whose verification is the one that counts — the agent's or yours? Why?