Multi-Agent Workflows
Split the work: a planner delegates to workers, and an independent checker catches what the maker can’t see in its own draft.
You ask one agent to write a long market report: it plans, drafts, and checks its own work all at once — and the result is mediocre. It rambles, and it misses its own mistakes because it’s grading its own homework with no fresh eyes. In a human team you’d never do it that way: someone plans, people write sections, and someone else reviews. Can agents work the same way? They can — and two simple patterns get you most of the way.
Planner / worker: decompose and delegate
In the planner/worker pattern (also called orchestrator + workers), one agent — the planner — breaks a big goal into smaller subtasks and hands each to a worker agent. Workers can be specialized (“research,” “write,” “format”) and can run in parallel; the planner then combines their outputs. It’s the same reason teams divide labor: separable parts get done by focused agents instead of one agent juggling everything and losing the thread.
Maker / checker: produce, then independently review
In the maker/checker pattern (generator + critic), one agent produces an output and a separate agent critiques it against explicit criteria; the maker revises, and the loop repeats until the checker is satisfied. The checker’s power is independence: because it didn’t write the thing and doesn’t share the maker’s reasoning, it catches errors the maker is structurally blind to — the same blind spot that created the mistake also hides it from whoever made it.
Maker/checker on code: • Maker: writes a function from the spec. • Checker (independent): reads the spec + the function, hunts for bugs, finds an off-by-one the maker overlooked, and returns it as a defect. • Maker: fixes it. Checker re-reviews → passes. The bug survived the maker but not a fresh, independent reviewer.
When multiple agents help — and when they just cost
Multi-agent isn’t automatically better. Every extra agent means more model calls, more latency, more spend, and coordination complexity. The win comes specifically from decomposition (a task with separable parts) or independent review (catching errors a single pass misses) — not from the number of agents. For a small, single-pass task, one well-prompted agent is cheaper and clearer. Reach for multiple agents when the task genuinely benefits from splitting or from fresh eyes.
Think of a newsroom. The editor-in-chief (planner) assigns stories and assembles the issue; reporters (workers) write their pieces; an editor (checker) reviews each draft. The editor catches what the reporter can’t see in their own writing precisely because they didn’t write it — fresh eyes find the typo and the logic gap the author reads right past. But you wouldn’t staff a whole newsroom to write a grocery list; the structure is worth it only when the work is big enough to need it.
A research report, built as a multi-agent workflow: 1. Planner: splits the goal into “gather sources,” “draft each section,” “fact-check,” “assemble.” 2. Worker agents: a researcher pulls sources; section-writers draft in parallel. 3. Checker: independently reviews each section against the brief, flags an unsupported claim. 4. The relevant writer revises; the checker re-reviews and passes. 5. Planner assembles the final report. No single agent had to hold the whole task in its head, and an independent checker caught an error the writer would have shipped.
This is the reading. The interactive version — active-recall quiz, a hands-on experiment you run in your own AI, and an earned mastery check — is free in the app.
Start this lesson free →