Today you walk out with an agent.

The agent loop.

Every agent — research bot, coding assistant, sales SDR, browser automator — runs the same four-stage cycle. Once you see it, every agent in the world is the same diagram.

What happens at each stage

Plan. The model breaks a goal into smaller steps it can actually execute. “Write a briefing on the EU AI Act” becomes: find recent articles, extract claims, identify points of disagreement, draft, critique, polish.

Act. The model picks the next step and calls a tool — search, read a file, run a command, query an API. Exactly the loop from Day 03.

Observe. The model reads what came back. The result is rarely what was expected. Empty arrays, errors, garbage data, contradictions.

Reflect. Is the goal met? Do I have what I need? If not, revise the plan. This is the stage most home-grown agents skip — and it is the stage that separates a stuck agent from a useful one.

A real trace.

What the loop looks like in practice — a single research task, end to end.

From the last unit: You know the four stages. Watch them happen on a real research task — a handful of tool calls, one polished briefing, the loop printing its own thinking as it goes.

Here is the actual terminal output from one run — trimmed for length, but every line is a line the script really prints. The [goal] banner, the → tool calls, and the closing [done] line come from the loop itself; the [PLAN]/[ACT]/[OBSERVE]/[REFLECT] labels are the model narrating each turn, exactly as the system prompt instructs.

Copy$ python research_agent.py "How is Phoenix planning for the 2027 Colorado River cuts?"

[goal] How is Phoenix planning for the 2027 Colorado River cuts?

[PLAN] I will search for recent reporting, read the two or three most
authoritative sources, then draft and critique a briefing.
  → tool web_search({"query": "Phoenix 2027 Colorado River cuts plan"})
[OBSERVE] Five results. Arizona Republic and the state water-resources
department look authoritative; two blog posts look low-signal.
[ACT] Reading the two strongest sources before I draft.
  → tool fetch_url({"url": "https://www.azcentral.com/..."})
  → tool fetch_url({"url": "https://new.azwater.gov/..."})
[REFLECT] Two sources agree on the CAP allocation figure; one is from 2024
and may be stale, so I will flag it rather than lean on it.
[ACT] Drafting three paragraphs, then critiquing my own draft.
[REFLECT] My skeptic caught one unsourced number. Removing it. Saving.
  → tool save_briefing({"title": "Phoenix and the 2027 Colorado River Cuts", "body": "..."})
Saved a 3-paragraph briefing on Phoenix water policy to
briefings/2026-06-10-1432-phoenix-and-the-2027-colorado-river-cuts.md.

[done] agent halted naturally.

Four tool calls — one search, two reads, one save (the draft and critique happen inside a single model turn, no tool needed). No human in the loop until the end. This is the artifact you build in §04.03.

Build your research agent.

A working multi-step research agent in under 250 lines. Reads, searches, drafts, critiques, polishes. Saves the output. Lives on your machine.

From the last unit: You have seen the loop and the trace. The capstone is your own — ~250 lines of Python you read, modify, and run on a question of your choosing.

What it does

1. Takes a research question as a CLI argument.
2. Plans its sub-steps, then loops Plan → Act → Observe → Reflect.
3. Calls web_search and fetch_url as needed (DuckDuckGo, no search key required).
4. Drafts a 3-paragraph briefing.
5. Critiques its own draft (Day 02’s Critique pattern, baked into the system prompt).
6. Saves the polished briefing to briefings/ with a timestamped filename.
7. Prints every [PLAN] / [ACT] / [OBSERVE] / [REFLECT] step to the terminal so you can watch it think.

Get the code

You don’t need to clone anything. Save these two files into a new folder — right-click each link and choose Save Link As…, or use the curl commands below.

• research_agent.py — the agent (the file you just watched run).
• requirements.txt — its one dependency, the anthropic SDK.

Prefer the terminal? The same two files live at the URLs below — curl them into a fresh folder:

Copy# make a folder and pull both files into it
mkdir research-agent && cd research-agent
curl -O https://d154gd40skpa9c.cloudfront.net/agents/research_agent.py
curl -O https://d154gd40skpa9c.cloudfront.net/agents/requirements.txt

Set up and run it

From inside that folder, make a virtual environment, install the one dependency, set your key, and run. On modern macOS the venv is not optional — a bare pip install is blocked (see troubleshooting below).

Copy# 1 · create and activate an isolated environment
python3 -m venv .venv
source .venv/bin/activate
# 2 · install the anthropic SDK
pip install -r requirements.txt
# 3 · set your key (from console.anthropic.com)
export ANTHROPIC_API_KEY="sk-ant-..."
# 4 · run it on a real question from your week
python research_agent.py "a question from your week"

A full run typically costs a few cents and finishes in well under a minute.

Read the source

The file is written so each section maps to one part of the agent. Open research_agent.py in your editor and search for these four banner comments as you read:

• # === TOOL IMPLEMENTATIONS === — the three tools (web_search, fetch_url, save_briefing) that run on your machine.
• # === TOOL DECLARATIONS === — the JSON schemas the model actually sees. The descriptions are how it decides when to call each tool.
• # === SYSTEM PROMPT === — the agent’s discipline: the four labels, the “search first, read second” rules, and Day 02’s Critique pattern.
• # === THE LOOP === — _run(), the Plan → Act → Observe → Reflect cycle that ties it all together.

Copy# open the agent in your editor (macOS)
open research_agent.py

Reversibility, first.

A research agent reads. The next agent you build will write. The discipline that lets you ship a writing agent without losing sleep is reversibility.

From the last unit: A research agent reads. The next agent you build will write. The discipline that lets you ship a writing agent without losing sleep is reversibility.

Most of these are one-line changes in the tool implementation. They are the difference between an agent that is useful and an agent that is dangerous.

Where the craft goes from here.

You have the loop. You have a working agent. The next frontiers are about how agents compose — with each other, with the rest of your stack, with the world.

From the last unit: You can build agents. You can run them. The frontiers from here are about how agents compose — with each other, with your stack, with the world.

The Model Context Protocol (MCP)

A standard for connecting agents to tools and data. Instead of writing a read_file tool inside every agent, you write an MCP server once and any agent — Claude, Cowork, Code — can use it. Same shape as today, but reusable across apps.

Multi-agent systems

One agent plans. Another writes. A third critiques. A fourth posts. They share state through messages or a shared filesystem. The Capable Series ships the foundations; the Council Day extension explores when this matters and when it is over-engineering.

Evaluation

How do you know your agent is getting better? You write a suite of test cases — questions with known good answers — and run your agent against them on every change. The agent equivalent of unit tests. Most teams skip this and regret it.

Production deployment

The script you ran today is the shape. The production version adds persistence (a database), observability (every step logged), authentication, rate limits, retries, and a UI. None of it changes the core loop.

Your commitment, by Monday

The loop only pays off if it leaves the page. Before you close your laptop, turn one workflow from your week into a written plan with a date on it.

From curious to capable.