More agents working at the same time sounds like more work getting done. A study published on arXiv in October suggests it is not that simple – and the reasons it gives are ones I recognise from human teams.
What the study did
Researchers compared three coding agents – Codex, Claude Code and Kimi Code, in their July 2026 versions – with "dynamic concurrency" switched on and off. With it on, the main agent decides during the run whether to spawn sub-agents that work in parallel. Everything else was held constant: model, prompt, environment and time budget. In total 354 tasks and 2,124 runs across five benchmarks, four of them long-horizon.
The headline results:
- Success did not reliably improve. The effect on resolution ranged from an 11.9 percentage point decrease to a 2.3 point increase.
- On bounded tasks it hurt. On SWE-bench Verified, Claude Code went from 83% to 59% and Kimi Code from 77% to 59%. Codex stayed at 71%.
- On the longest tasks it could help. On LoopsBench, Claude Code's pass rate rose from 7.1% to 21.4%, and some tasks were only solved with sub-agents.
- It always cost more. Token use rose to between 1.41 and 3.31 times the sequential level, and runtime generally did not fall.
The failures are coordination failures
The part I find most useful is the failure taxonomy: 13 kinds of failure, grouped into four areas. The largest single one was concurrent writes – agents changing the same files without coordinating, often overwriting each other's deliverables. Others: work that no agent owned, parallelism where the critical path stayed sequential anyway, sub-agents timing out because their deadline was longer than the task's budget, failed work that nobody picked up, components built without an agreed interface, and a main agent declaring the task complete without checking the requirements.
Replace "agent" with "developer" and this is a list of reasons projects slip. Splitting work is easy. Integrating it is where the cost sits.
How I read it for agent teams
I work with agents in different roles – lead, developer, tester, architect – so this hits close to home. My takeaways:
Parallelism is a decision per task, not a default. The authors say the same: enable it selectively. A bounded bug fix rarely benefits. A large, separable piece of work might.
Split along boundaries you can name. The cases where concurrency helped had a shape: separable parts of the work, alternative attempts that the lead compares, or an independent check. If you cannot say what each sub-agent owns in one sentence, don't split.
Give each agent its own workspace. Concurrent writes and a contaminated shared environment were a third of all failure instances. A separate branch or worktree per agent, merged through review, removes a whole category.
Agree the interface before the work. Two components built in parallel without a contract will not fit. That is as true for agents as for teams in two offices.
Fit timeouts to the budget. A sub-agent allowed to run past the task deadline is a design error, not bad luck.
The lead verifies against the requirements. "Done" should mean every requirement has a passing test, not that every sub-agent has reported back. This is where test-driven work pays off: the tests are the shared definition of done.
Put tokens in the estimate. If parallel runs cost up to three times as much, that belongs in the estimate before the work starts, not on the invoice afterwards.
Caveats
It is one study, with three agents, sampled tasks and, as far as I can tell, a single run per task and mode because of cost. The tools change fast; these were July 2026 versions. Benchmarks are not your backlog. Failure labels were assigned manually, though with reasonable agreement between annotators.
But the direction matches what I would expect from any team: coordination is not free, and more hands only help when the work can actually be divided.
What I keep asking myself is not "how many agents?", but "what does each one own, and who checks the whole?"
Sources
- Han Li, HanHaoNing Li, Ziqian Jiang, Yiling Lou: When Sub-Agents Work in Parallel: The Promises and Pitfalls of Dynamic Concurrency in Long-Horizon Coding Tasks (arXiv, October 2026)