In February, a researcher at Anthropic gave 16 Claude agents one job: write a C compiler from scratch. Two weeks and almost $20,000 later, it could build a Linux kernel that boots. On the way there, all 16 agents got stuck on the same bug, and each one kept overwriting the others' fixes.
For that stretch, 16 agents did no better than one, and all 16 still cost money.
But here is the catch. The same thing can happen with three subagents on an ordinary task in Claude Code, and nothing in the output will tell you. A split that doesn't help still finishes and looks busy, and it costs more than one session would.
By the end of this post you'll know which work splits well across subagents, which doesn't, and how to check your own task.
One Contractor or a Whole Crew
Think of a house renovation. A crew beats one contractor when the rooms are separate: a painter in the bedroom, an electrician in the kitchen, a plumber in the bathroom. Nobody waits for anybody. Send the whole crew to one leaking pipe, though, and they get in each other's way and undo each other's work.
That's what happened with the compiler. While there were many separate failing tests, each agent took a different one and the split worked. The kernel is one giant task. Every agent hit the same failure, fixed it its own way, and wrote over the others.
The fix changed the shape of the task. A new setup built most of the kernel with GCC, a compiler known to work, and only a random set of files with the new compiler. Picture keeping the old plumbing in most of the house and putting new pipes in a few random rooms. When water shows up, you know which rooms to check, and each plumber can take a different room.
Two agent companies argued about this exact problem in 2025.
The 2025 Argument About Agent Teams
In June 2025, they published opposite advice, one day apart. Cognition, the company behind the coding agent Devin, wrote a post called Don't Build Multi-Agents. Their example was a Flappy Bird clone split between two subagents. One built a background that looked like Super Mario, and the other built a bird that didn't look or move like the one in the game.
Each subagent did something reasonable with what it could see, and the parts didn't fit. This is where the crew picture breaks. A painter can walk into the kitchen and ask the electrician a question, but a subagent sees only the brief you wrote for it. Imagine a contractor who gets one sticky note and no key to the rest of the house. Whatever you didn't write down, they'll guess.
The next day, Anthropic described its research system, where a lead agent sends subagents to search in parallel. On Anthropic's own research eval, the team beat a single agent by 90%.
But the same Anthropic post had a finding that got much less attention. On a browsing benchmark, the number of tokens a system spent explained 80% of the differences in performance. So was the team smarter, or did it only spend more?
Extra Tokens Make Teams Look Better
A team almost always spends more than the one agent it's compared to. Claude Code's docs say an agent team uses about 7 times the tokens of a normal session when the teammates run in plan mode. More tokens can improve the answer by themselves, so it's easy to credit the team for what the extra compute did.
Think of it like a drug trial. A new drug has to beat the best existing treatment, on similar patients, measured the same way. If the new drug's group also got twice the nurse visits, you couldn't tell which one helped. With agents, the nurse visits are tokens.
In January 2026, Anthropic wrote that some teams spent months on multi-agent systems, then found that a better prompt on one agent did as well. In April, a paper ran that fair trial, with the same reasoning budget on both sides. On questions that need several reasoning steps, across three model families, one agent consistently matched or beat the team.
Since then, both companies have moved toward the same middle.
Where Both Companies Landed in 2026
In April, Cognition wrote that its 2025 warning still holds for swarms of agents that all write code at the same time. What works for them is narrower: many agents add their thinking, and only one writes. Their review agent reads each change with none of the coder's context, and it finds about two bugs per pull request.
It's like a good editor. A writer can't see the holes in their own draft, because they know what they meant. The editor only has the page.
In October, Anthropic published a guide on folding subagents back into the main agent. In the cases it describes, one agent with skills often beat the subagent designs on quality, and often at lower cost and latency too. The guide still keeps subagents for three jobs: keeping the main context clean, running separate work in fresh contexts, and separating tools or instructions that would confuse one agent.
When to Reach for Subagents
Back to the house. A crew earns its cost when the rooms are separate, and in Claude Code that happens in three cases.
Use a subagent when the work would flood your main session with things it won't need again, like a wide search of a big codebase, long logs or a pile of docs. A subagent works in its own context window and hands back its findings, so the noise stays out.
Run subagents in parallel when the parts are truly separate, like independent questions, separate modules or unrelated test failures.
Add a fresh reviewer when you want a second read of a change. Ask a subagent to review the diff without your reasoning, with a prompt like: "Review this diff as if you've never seen the task. List anything that could break, with the file and line."
Stay in one session when each step depends on the last one: chasing a bug, or a refactor across shared files. That's the leaking pipe. Claude Code's docs also steer sequential work away from agent teams, which are still experimental.
These rules get you started. Your own task decides.
Run the Control Before You Split
The new book calls this check the control run: the same task, once with one agent and once with the team, at the same budget. In Claude Code it looks like this.
1. Pick a task you finished with subagents last week, with a clear pass rule: the tests pass and you'd merge the diff.
2. Run it in one session first, with a prompt like: "Do this task yourself, without subagents. Read the files you need, make the change, and run the tests." Write down the time and what /usage shows.
3. Run the subagent version with the same time limit. On a subscription plan, /usage shows the share that went to subagents, so count all of it.
4. Count what you fixed by hand to make the merged result work. That effort goes on the team's side.
5. Run each side at least twice. In one case from Anthropic's October guide, a change broke a step that had been passing, and the break showed up in only one run out of two.
Then read the result. If the team wins by more than the gap between its own two runs, keep it. If one session matches it, fold the work back into one session, and keep the good instructions you wrote for the team. If the team won but used far more, give one session that extra budget, for example a second pass where it reviews its own diff, and compare again.
What This Check Can't Tell You
The evidence is still narrow. The equal-budget results come from reasoning and research tasks, and few studies test long coding tasks with many tool calls. So you can't assume one session wins on your task, and you can't assume it loses.
The answer also expires. Anthropic's October guide found that rigid multi-agent setups often stopped newer models from doing more of the work themselves. A split that paid off on last year's model may lose to one session on today's, so run the control again each time the model changes.
A crew beats one contractor when the rooms are separate, and a lot of coding work is one long pipe where each step depends on the last. Before you split your next Claude Code task, give one session the same budget and see what it does.
This post is a short version of Chapter 1 of Multi-Agent Systems Made Simple, the new book in the sale below. The full chapter is free on the site. The book has no code, so the same decisions hold in Claude Code, Cursor or a system you build yourself.
One more thing before you go. My new book is out, and with it the only sale I run all year. It runs until Monday 30 November:
Prompt to Production, my course on building software with AI the way professionals do. 17 modules, with a lab on your own codebase in every one. $99 instead of $199. Get the course
All five of my books in one bundle, including the new one this post comes from. $149 instead of $199. Get all five books
The three agent books: AI Agents Made Simple, Agent Memory Made Simple and Multi-Agent Systems Made Simple. $99 instead of $129. Get the three agent books
The links already apply the discount. If you need to type it, the code is BLACKFRIDAY2026. It ends on Monday 30 November at midnight Israel time, which is 2 pm in San Francisco, 5 pm in New York and about 3:30 am on Tuesday in India.
Nir
P.S. Bought AI Agents Made Simple? Reply to this email with a screenshot of your order, and I'll send you the cheat sheet. It is two pages. How to pick the simplest setup that works, ten common failures with the first fix for each, and all 28 patterns with when to use them and when they are overkill.




