Why Multi-Agent Systems Work
A single large model asked to do four jobs at once will blend them. I think the fix is structural. A bigger model won’t solve it, a smaller contract will.
A single context window asked to act as editor, coder, critic and retriever at the same time will end up doing all four, without ever quite being any of them. The careful editor starts writing code snippets to clarify, the confident coder hedges with editorial disclaimers and the skeptic goes soft because it wrote the draft. The work gets done, but you can see the seams. A multi-agent system splits the work into roles, gives each role its own context and forces clean handoffs, and I think the result is a lot more coherent, on top of being faster.
The agents are the easy part, and the handoffs are where it gets hard.
— closing observationOne brain, four jobs, and the leakage between them
When a single context window has to play four roles at once, the personas leak and each role quietly bends the others. That’s the failure the multi-agent pattern is designed to fix.
The one-context model
One system prompt, supposedly holding four personas in productive tension. In practice you get a hybrid of editor, coder, critic and retriever, each pulling the response in a different direction.
Role 01
Edit the prose
Starts writing code snippets to "clarify"
Role 02
Write the function
Adds hedges and disclaimers mid-function
Role 03
Critique the draft
Goes soft because it "wrote" the draft
Role 04
Retrieve the sources
Tries to sound like the editor again
An orchestrator and four specialists, each in their own context
The fix is structural. One orchestrator routes the work, and each specialist runs in a clean context with a system prompt tuned for exactly one job. The seams between them become the handoff protocol, which is explicit, inspectable and correctable.
Reads the goal, breaks it down, picks the right specialist for each subtask, stitches the results together and decides when to ship. It holds no domain knowledge, only the routing logic and the user-facing persona.
out assembled result
Turns vague goals into explicit plans. Quiet and structured, with no opinions about style.
Gets a spec and returns a diff. It never sees the original user goal, so it doesn’t know if the project is a startup demo or a production system.
Reads a draft as if a stranger wrote it. It doesn’t see the system prompt and doesn’t feel loyal to the author, because its job is to be the skeptic.
Takes a question and returns sources with verbatim quotes. No synthesis and no voice, just the receipts.
Designer, lawyer, quant, translator. The pattern composes, so you add a specialist, give it a clean context and wire it to the orchestrator.
What actually crosses the seam
The agents are isolated, and the handoff is the only thing that connects them, so in a way the handoff is the system. The minimum viable handoff has three parts, a clear contract, a small payload and a recorded decision.
When the pattern wins, when it breaks, and the honest middle
Multi-agent systems aren’t a free lunch. They add latency, cost and a new place for things to fail, which is the seams. The hard part is knowing which problems are worth paying that tax for.
| Dimension | Single agent | Multi-agent |
|---|---|---|
| Persona coherence | LossRoles blend, so the editor starts coding and the critic goes soft. | WinEach specialist runs in its own context. No blending. |
| Latency & cost | WinOne round trip. One bill. Cheap to run. | Loss2–5× more model calls, and the coordination tax is real. |
| Debuggability | SplitOne trace to read, but the failure has no clear owner. | WinEach step is inspectable. The audit trail is the system. |
| Failure surface | SplitFewer seams, but a bad step poisons everything downstream. | LossMore seams. A bad handoff is a new class of bug. |
| Domain depth | SplitDecent at many things, master of none. | WinEach specialist can be deeply tuned. Sum of depths > depth of one. |
| Iteration cost | WinChange a system prompt, run again. | LossChanging a contract breaks every caller. Refactoring is non-trivial. |
| Right size of problem | Short, single-domain tasks. Quick answers. Anywhere coherence loss is acceptable. | Multi-step work that mixes domains. Anywhere persona leak would degrade quality. |
Build the seams first, and the agents come after
A multi-agent system is a small, opinionated protocol between personas. If the contract between them is sloppy, the system will produce confident garbage with extra steps. If the contract is sharp, with explicit inputs, explicit outputs and an explicit decision rule for when the work is bad, the system can outperform any single agent on the same problem. That’s because each agent gets to be exactly one thing.
The pattern is older than the tooling. Print shops, military staffs, hospital triage and restaurant kitchens have all been running multi-agent systems for decades. What’s new is that we can now write the seams in plain text and the agents in plain code, and then watch the whole thing work in a browser tab. Not bad at all.
— end —