Multi-Agent Systems
Sometimes one agent isn't enough. A team of specialized agents — coordinated by an orchestrator — can tackle work no single agent could hold in its head.
🎯 By the end you'll understand
Why you'd ever want more than one agent, the orchestrator → worker pattern that powers most agent teams, a few other team shapes (pipeline, specialists, debate), how agents "talk" by being tools for each other, and the very real cost of coordination — plus the honest truth that a single strong agent usually wins.
KEY INSIGHTThe one idea to take away
A multi-agent system is just a team: one agent plans and delegates, others do focused pieces of work, and the results get stitched back together.
There's no new magic here. Every agent in the team is still the same thing you met in Lesson 2.1 — an LLM running a loop with tools. The only new idea is that one agent's tool can be another agent. Once you see that, the whole field of "multi-agent systems" collapses into something simple: agents calling agents.
You reach for multiple agents when a job is too big, too varied, or too context-heavy for one agent to carry alone — and when the pieces can be done by focused specialists. Not because more agents are inherently smarter. They're not.
CORE CONCEPTWhy you'd ever want more than one
A single agent is remarkably capable. So why complicate things with a team? There are four honest reasons — and notice they're about the shape of the work, not about raw intelligence:
Divide a big job
"Write a report on the EV market" is really five jobs: research demand, research supply, research policy, write, review. Splitting them makes each tractable.
Use specialists
A "researcher" agent with web-search tools, a "writer" agent tuned for prose, a "critic" agent told to find flaws. Each is briefed narrowly and does its one thing well.
Run work in parallel
Three researchers can dig into three sub-topics at the same time, then report back. One agent would have to do them one after another.
Keep each context focused
From Lesson 2.3: a smaller, focused context beats a giant cluttered one. Each worker only sees its slice of the problem, so each stays sharp.
That last point is the deepest one. A lone agent tackling a sprawling task ends up with a context window stuffed with half-finished threads — search results, drafts, notes — all competing for attention. Hand each thread to a separate agent and every one of them gets a clean, relevant context. The team isn't smarter than the soloist; it's just less overwhelmed.
A multi-agent system is two or more agents working together on a task, where agents hand work to one another and combine results. The agents may be specialized, may run in parallel, and are usually coordinated by a lead agent.
FRAMEWORKThe pattern that does most of the work: orchestrator → workers
If you only learn one multi-agent pattern, learn this one. The vast majority of real systems are some version of it.
A lead agent — the orchestrator (you'll also hear "lead agent," "manager," or "supervisor") — receives the goal and does three things, in a loop:
🧠 Plan
Break the goal into sub-tasks. "Research three angles, then draft, then critique."
📤 Delegate
Spin up worker agents (a.k.a. sub-agents) and hand each one a focused sub-task with just the context it needs.
🧵 Synthesize
Collect the workers' results and weave them into a single coherent answer — or kick off another round if the work isn't done.
The orchestrator never does the detailed work itself. Its job is to think about the work: what needs doing, who should do it, and whether what came back is good enough. The workers are the ones with their sleeves rolled up. This mirrors a human team lead who plans, assigns, and reviews — but doesn't personally write every line.
COMPARISONOther team shapes
Orchestrator-and-workers is the workhorse, but a few other arrangements show up often. They're not mutually exclusive — real systems mix them.
| Pattern | Shape | Good for |
|---|---|---|
| Pipeline | A → B → C: each agent's output feeds the next | linear workflows with clear stages (extract → transform → format) |
| Specialists | distinct roles: researcher, writer, reviewer | work that needs different "skills" or tools per role |
| Debate / critique | one proposes, another challenges, repeat | catching errors and weak reasoning; raising answer quality |
| Orchestrator + workers | lead plans & delegates, workers do, lead synthesizes | most open-ended jobs; subsumes the others |
The pipeline is the simplest: think of an assembly line where each station does one operation and passes the work along. No central coordinator — the structure is the coordination.
The debate / critique shape is worth a second look because it's quietly powerful. One agent proposes an answer; a second agent is explicitly told "your job is to find what's wrong with this." The proposer revises. This back-and-forth catches the confident-but-wrong mistakes that a single agent tends to wave through — it's structured disagreement, on purpose. (You'll recognize the spirit of this from self-correction in Lesson 2.6; here it's split across two agents so the critic isn't marking its own homework.)
The same model, told "critique this" instead of "write this," behaves differently. Roles aren't about smarter models — they're about pointing the same brain at a narrower task. That's the whole trick behind specialists.
CORE CONCEPTHow agents actually "talk": one agent is a tool for another
Here's the mechanical secret that makes all of this work, and it's a direct callback to Lesson 2.2. To the orchestrator, a worker agent looks exactly like a tool.
Remember: a tool is just a named capability the agent can call with some input and get a result back. A search_web(query) tool takes a string and returns text. From the orchestrator's point of view, a worker is identical — call it like research_agent("EV demand 2026"), wait, and get a report back. The orchestrator doesn't know or care that, behind that tool call, a whole other LLM ran its own loop with its own tools.
Agents don't "chat" in some mysterious shared language. The orchestrator calls a worker the way it calls any tool — with a task as input — and the worker returns its result as text. "Agents talking" is just tool calls where the tool happens to be another agent.
This is why multi-agent systems aren't a separate technology you have to learn from scratch. If you understand tools and loops, you already understand the plumbing. The orchestrator's "team" is just its toolbox, where some of the tools are agents.
SEE ITOrchestrator at work
Pick a job and press Run. Watch the orchestrator plan, spin up named workers (they "run" in turn), collect each result, then synthesize a final answer. Everything here is scripted and deterministic — but it mirrors exactly how a real orchestrator delegates.
PRACTICALA concrete example: the research-report team
Let's walk the canonical example end to end. The goal: "Produce a short briefing on the 2026 EV market." A single agent could attempt this, but it would juggle searching, reading, drafting, and checking all in one overstuffed context. Here's how a team splits it:
Orchestrator plans
"I need three research angles — demand, supply, policy — then a draft, then a critique." It writes a brief for each worker.
Three researchers (in parallel)
Each gets one angle and its own web-search tools. They run independently and each returns a tight bundle of findings. Three clean contexts, not one messy one.
Writer drafts
The orchestrator hands all three findings to a writer agent, briefed for clear prose. It returns a structured draft.
Critic reviews
A critic agent is told to hunt for unsupported claims and gaps. Its notes go back to the orchestrator, which decides: ship it, or send the draft back for one more pass.
Notice the structure mixes patterns: orchestrator + workers overall, with a parallel research fan-out, a pipeline from research → writing, and a critique step at the end. That blend is typical. The orchestrator is the only piece that sees the whole picture; every worker stays blissfully focused on its slice.
This team can produce something more thorough than a lone agent — because each piece got full attention. But look at the headcount: one orchestrator, three researchers, a writer, a critic. That's six agents, each running its own loop. Power has a price tag, which is exactly the next section.
WEAKNESSThe bill comes due: cost, latency, and coordination
Every agent you add is another LLM running its own loop — and that compounds fast. Be clear-eyed about four costs:
- Money. Six agents means roughly six times the token usage of one. Multi-agent runs can be dramatically more expensive than a single agent doing the same job.
- Latency. More steps, more round-trips, more waiting. Parallelism helps, but the orchestrator still has to wait for the slowest worker before it can synthesize.
- Coordination overhead. Someone has to write each worker's brief, pass context around, and merge results. That plumbing is real work and a real source of bugs.
- More places to fail. Each agent can misunderstand, hallucinate, or go off the rails. A six-agent system has six chances to go wrong, and errors can cascade — a bad research bundle poisons the writer's draft.
Adding agents is seductive because it feels like adding capability. Often it just adds cost, latency, and failure modes. The number of agents is a budget you're spending, not a score you're trying to maximize.
A single strong agent with good tools usually beats a complex multi-agent setup — it's cheaper, faster, and easier to debug. Reach for multiple agents only when the task genuinely needs it: when it's too big for one context, splits into truly independent pieces, or benefits from parallel work or an adversarial critic. Start with one agent. Add more only when one provably isn't enough.
WEAKNESSCommon mistakes to avoid
No. More agents means more cost, more latency, and more ways to fail. A team is justified by the shape of the work, not by a desire to look sophisticated. Often one focused agent wins outright.
They don't. Someone has to brief each worker, route context, and merge results — and the orchestrator burns tokens doing it. Coordination is real, costly work, not a freebie that appears when you add agents.
If you jump straight to a multi-agent design, you'll never know whether one agent would have done the job for a fraction of the cost. Always build and measure the single-agent version first, then justify each agent you add against it.
KEY INSIGHTWhere this connects in your course
- The agent loop (2.1) — every agent in a team, orchestrator and workers alike, is still just an LLM running this same loop.
- Tools (2.2) — the key insight: a worker agent is a tool to the orchestrator. "Agents talking" is tool calls in disguise.
- Context windows (2.3) — the deepest reason to split work: each worker gets a small, focused context instead of one giant cluttered one.
- Planning (2.5) — the orchestrator's "plan and delegate" step is planning, applied to who does what.
- Reasoning & self-correction (2.6) — the debate/critique pattern splits self-correction across two agents so the critic isn't grading its own work.
- Choosing the right tool (4.8) — when you build, the decision "one agent or many?" becomes a real architecture choice with a real bill.
Hold the simple version: a multi-agent system is a team where one agent's tool is another agent. Everything else — orchestrators, pipelines, critics — is just how you arrange that one idea.
GLOSSARYKey terms introduced
- Multi-agent system
- Two or more agents working together on a task, handing work to each other and combining results.
- Orchestrator
- The lead agent that plans, delegates sub-tasks to workers, and synthesizes their results. Also called lead agent, manager, or supervisor.
- Worker / sub-agent
- An agent given a focused sub-task by the orchestrator; from the orchestrator's view it behaves like a tool.
- Pipeline
- A team shape where each agent's output feeds directly into the next, like an assembly line, with no central coordinator.
- Specialist
- An agent briefed for one narrow role (researcher, writer, reviewer) — the same model pointed at a narrower task.
- Critic / debate
- A pattern where one agent proposes and another is told to challenge it, raising answer quality through structured disagreement.
- Coordination overhead
- The extra cost, latency, and complexity of briefing workers, passing context, and merging results in a multi-agent system.
ACTIVE RECALLCheck your understanding
Answer in your own words first, then reveal.
1In the orchestrator → worker pattern, what are the orchestrator's three jobs?›
Plan (break the goal into sub-tasks), delegate (hand each focused sub-task to a worker agent with just the context it needs), and synthesize (collect the workers' results and weave them into one answer). It thinks about the work; the workers do it.
2Mechanically, how does one agent "talk" to another?›
By treating the other agent as a tool. The orchestrator calls the worker like any tool — passing a task as input and getting a result back as text. There's no special agent language; "agents talking" is just tool calls where the tool happens to be another agent (callback to Lesson 2.2).
3Name two reasons to split work across multiple agents — and one reason not to.›
Reasons to split: the job is too big for one context, it has truly independent pieces, you can run work in parallel, or each piece keeps its context focused (Lesson 2.3). Reason not to: every agent adds cost, latency, coordination overhead, and another place to fail — so a single strong agent is often cheaper, faster, and good enough.
4Why does a critic agent often catch mistakes a single agent misses?›
Because it has a different job. Told "find what's wrong with this," the same model behaves differently than when told "write this." Splitting the critique into a separate agent means the critic isn't marking its own homework, so it's more willing to flag the confident-but-wrong claims the author waved through.