Skip to content

AI, decoded

Should you build a single agent or a multi-agent system?

Start with a single agent. One agent with a clear set of tools is easier to build, debug, and trust, and it handles many tasks. Reach for multiple agents only when the work splits into distinct specialties that benefit from separate context and instructions — and accept that you're trading simplicity for new failure modes: coordination overhead, agents talking past each other, and harder debugging. Multi-agent is a way to manage complexity, not a free upgrade. Block's Angie Jones described on Chain of Thought a one-hour MIT workshop where six specialized sub-agents built a full-stack app, and the last, a QA sub-agent, said not to ship it to production.

· Updated · Chain of Thought

Level 5: Production agents · 5.1 Multi-agent systems

Multi-Agent SystemsAI Agents

  • 5 episodes
  • 5 guest clips
  • 8 glossary terms
One glowing sphere beside three dim nodes joined by broken dashed lines, with the words: start with one. Split only when the work splits.

In detail

Default to a single agent

A single agent — one agent running the whole task with its tools — is the simplest thing that can work, and it covers a surprising amount of ground. You can read its trace top to bottom, see why it did what it did, and fix it. Many teams reach for multiple agents before they’ve exhausted what one well-built agent can do.

When multiple agents earn their place

The case for splitting up holds when a task breaks into distinct specialties — a researcher, a coder, a reviewer — each needing its own instructions, tools, and context window that would clutter a single prompt. Separating them keeps each agent focused and lets you scale or swap pieces independently. The win is managed complexity and cleaner division of labor. MongoDB’s Mikiko Chandrasekhar describes this as the practice now developing for complex work: rather than one agent trying to do a lot of complex tasks, a system of small agents that each handle one to three tasks, each judged against criteria for its own skill set.

Update, October 3, 2026: Task specialization also appears in episode 73. Wen Sang calls Genspark’s design a “mixture of agents” architecture, describing more than 70 models selected for different tasks and more than 150 in-house tools those models can call. Sang gives planning, coding and media generation as examples of different model strengths. For the architecture choice discussed here, the distinction is between selecting models for tasks and assigning independent agents separate responsibilities; the model count alone does not establish the latter.

The costs you take on

Every agent you add is another thing that can fail, and the connections between them are where multi-agent systems break: handoffs drop context, agents loop or contradict each other, and a small fault in one cascades. Debugging gets harder because the failure is now spread across a conversation between components. Add agents when the problem demands it, not because more sounds more capable.

Two engineering write-ups from 2025 frame the trade from opposite sides. Anthropic reported that its research system, a lead agent directing parallel subagents, beat a single agent by 90.2% on its internal research eval, because subagents could explore separate directions at once in their own context windows. The same post says these systems used about 15 times the tokens of a chat and fit poorly where every agent needs the same context. Cognition’s Don’t Build Multi-Agents argues the opposite default: agents should share full context, because every action carries implicit decisions, and subagents working from partial context make conflicting ones. They don’t agree, and Cognition stays skeptical even of parallel subagents. Our reading of the two: splitting has the strongest case for broad, independent research, and work whose steps depend on each other belongs in one context.

Make the second agent earn its place

Compare the same tasks against a single-agent baseline. The checks below are our suggested experiment, not measured results from the guest examples.

Reason to split the workCompare againstWhat would justify the split
Distinct specialties need different instructions and contextOne agent with the required toolsBetter verified outcomes without losing required context at the handoff
Independent tasks can run at the same timeThe same tasks completed sequentiallyLower elapsed time within the same quality and total-cost requirements
A separate reviewer should catch errors in a producer’s workThe existing review and test processDetection of known bad outputs, with valid outputs still passing
The first agent is looping or failing unpredictablyDiagnose its trace before adding another agentA specific failure the split addresses, with checks at the new handoff

Write down what each agent must return, how the next step validates it, and when the whole run stops. Measure the final outcome as well as each agent’s output. A reviewer saying “approved” is evidence to inspect, not proof that the task succeeded. Use agent evaluation to define the outcome and multi-agent failure diagnosis to inspect the connections.

Single agent vs. multi-agent: what you gain and what you take on Left, a single agent: one agent runs the whole task with its tools. Its trace reads top to bottom, so you can see why it did what it did and fix it. It handles many tasks and is the default. Right, several specialist agents, a researcher, a coder and a reviewer, each with its own instructions, tools, context window and its own criteria for its skill set. Splitting keeps each one focused and lets you scale or swap pieces. But the connections between them are where the system breaks: a handoff drops context, agents loop or contradict each other, and one small fault cascades. The rule: split only when the work splits into distinct specialties. Multi-agent is a way to manage complexity, not a free upgrade. One agent first. Split only when the work splits. More agents buy focus and specialization, and add the connections where systems break. ONE AGENT · THE DEFAULT one agent runs the whole task with its tools ITS TRACE 1 read the task 2 call a tool 3 read the result 4 answer Read it top to bottom, see why it did what it did, and fix it. SEVERAL SPECIALISTS · WHEN THE WORK SPLITS researcher coder reviewer own instructions,tools, context own instructions,tools, context own instructions,tools, context ! ! WHAT YOU GAIN each agent stays focused; scale or swap pieces; judge each one on its own criteria for its skill set WHAT YOU TAKE ON a handoff drops context; agents loop or contradict each other; one small fault cascades The failure spreads across a conversation between parts. Multi-agent manages complexity. It is not a free upgrade: add agents when the problem demands it. Per-agent criteria: Mikiko Chandrasekhar (MongoDB), episode 33. Agentic systems are “much more complex than normal application”: Giovanna Carofiglio (Cisco), episode 31.
Multi-agent manages complexity; it is not a free upgrade. Per-agent criteria come from MongoDB’s Mikiko Chandrasekhar in episode 33, and the point that agentic systems are more complex than normal applications, and need deeper evaluation, from Cisco’s Giovanna Carofiglio in episode 31. Download the image

Hear it from the guest

“Instead of having each agent is compared to the same criteria, instead, like each agent has a different criteria that is focused on like their kind of specific skill set.”
“It's really important that the evaluation goes deep into explaining how this system works because they are much more complex than normal application.”
“The models that are good at reasoning and planning, we use them to come up with the work plan for a project.”
Watch on YouTube
“So if you just have one agent that does everything, you will have context bloat, you will have accuracy issues, etc.”
Watch on YouTube
“The last sub agent that we deployed was the QA sub agent, who then ripped the whole thing apart and was like, do not ship this to production.”
Watch on YouTube

Quotes lightly edited to remove filler words.

From the conversation

This explainer is drawn from these episodes — each carries its full transcript.

Concepts in this explainer

SubagentMulti-agent systemAgent SwarmAgent2Agent ProtocolMixture of agentsOrchestrator AgentContext WindowTokenization