00. Multi-Agent Systems — The Five-Year-Old Version¶
Module 16 taught you to architect one agent — its toolbelt, its leash, its blast radius. This module teaches many agents to work together.
Imagine a small company with one very busy employee. That one person researches, writes, reviews, and publishes everything. For tiny jobs, this can work. The task is small. The context fits in one head. The tools are few. The decisions are easy to remember. See. But bigger work changes the story fast. Too many facts pile up at once. Different tools pull in different directions. Yesterday's choice gets forgotten by lunch.
Then the company grows. So what to do? We stop asking one person to do every job. We create departments. Research gathers facts. Writing turns facts into clear words. Review checks whether the claims are right. Publishing formats the final work and sends it out. Each department is good at one narrow job. Each one keeps less clutter in its head. Fewer things get mixed together. Simple, no?
Now a new problem appears. The departments have to fit together. Who decides what each one works on? Who passes which document to whom? What happens when two of them disagree? What happens when one of them goes silent? These are the questions of organisation.
So the company draws an org chart. The CEO sits at the top. The CEO does not do every job alone. The CEO breaks the work into parts. The CEO sends each part to the right department. The CEO reads what comes back. The CEO makes the final call. Sometimes departments speak only through the CEO. Sometimes departments talk directly to each other. That choice is the org chart.
When a department finishes, it passes work onward. That passing is the handoff. A clean handoff names the task, the result, and what is next. A messy handoff loses information and slows everyone.
In this module: - The department is one specialist agent. - The CEO is the orchestrator. - The org chart is the topology — orchestrator-worker, pipeline, debate, hierarchical, peer. - The handoff is what one agent passes to the next.
Keep this company picture in your head. We will use it again and again. When one agent struggles, we add the right department. When teams miscommunicate, we improve the handoff. When work stalls, we fix the org chart. When the org chart is wrong for the workload, we change topology. That is the whole module map. See.
Note. The wire protocol that lets any agent — single or multi — speak to its tools is MCP. That is covered in Module 16 (the toolbelt and how it is described). This module assumes you already know it and focuses on a different problem: how multiple agents organise their work.
The placeholders you will see called back¶
| Placeholder | Meaning |
|---|---|
| the department | one specialist agent with a narrow job |
| the CEO | the orchestrator that assigns and coordinates work |
| the org chart | the topology — who talks to whom |
| the handoff | what one agent passes to the next |
| the shared whiteboard | a common state store all agents can read and write |
Top resources¶
- Anthropic: Building effective agents — Clear advice on when teams of agents actually help and when one agent is enough.
- Anthropic: How we built our multi-agent research system — Real production multi-agent system with orchestrator and worker agents.
- OpenAI Agents SDK — Practical examples of orchestration, handoffs, and guardrails.
- LangGraph multi-agent docs — Good patterns for orchestrators, workers, and shared state.
- AutoGen docs — Agent conversation patterns and task delegation.
- CrewAI docs — Easy way to see role-based agent teams in practice.
What's coming¶
- 01-single-agent-overload.md — Why one busy employee doing everything breaks down.
- 02-orchestrator-worker.md — The default org chart: one CEO, many specialists.
- 03-pipeline-topology.md — When work flows in a strict sequence.
- 04-debate-critique.md — Using disagreement to catch mistakes.
- 05-hierarchical-peer.md — Scaling with sub-managers and direct collaboration.
- 06-task-decomposition.md — How to split work along failure boundaries.
- 07-handoff-design.md — Structuring what passes between agents.
- 08-shared-state-vs-messages.md — Shared store or explicit payloads — the architecture fork.
- 09-cost-latency-multiagent.md — Making multi-agent affordable and fast.
- 10-debugging-multiagent.md — Finding the broken handoff.
- 11-honest-admission.md — What multi-agent still gets wrong.
Bridge. One busy employee is trying to do everything. Let's see exactly where and why that breaks. → 01-single-agent-overload.md