Running more than two AI agents in parallel on the same task burns through tokens without delivering better results. The pattern adds a coordination tax in the form of redundant verification and duplicate tool calls, with no measurable lift in output quality.<\/p>\n
When several sub-agents run side by side, they do not trust each other’s work and end up double-checking one another’s output. Each round of verification consumes tokens, and the overhead scales with the number of agents rather than with the difficulty of the task itself.<\/p>\n
One project that surfaced publicly spent $20,000 in tokens to refactor a single Python file using 1,393 agents. A single agent could have completed the same job for a small fraction of that cost. The case has become a touchstone example of how parallel agent architectures can spiral into token burn.<\/p>\n
System prompts are loaded into every sub-agent that spins up, so the prompt overhead multiplies with each new lane of work. Without enough shared context, sub-agents re-run the same tool calls or rewrite the same sections that another agent has already covered.<\/p>\n
Duplicate effort is the largest source of waste. Two agents working on the same file will each independently fetch the same references, call the same tools, and produce overlapping drafts that then have to be reconciled. The reconciliation step costs more tokens than the original work would have taken a single agent to complete.<\/p>\n
One approach that reduces the tax is delegating tasks to separate threads that report back to a main agent only when each thread finishes, rather than polling constantly for status updates. The main agent waits, then integrates the results.<\/p>\n
This keeps each sub-agent focused on its own slice of the work and prevents the constant cross-checking that drives token costs up. It also limits how much context each agent has to carry, which reduces redundant tool calls across the swarm.<\/p>\n
Agent swarms can appear faster because they spread work across more lanes, but the token overhead turns that speed into a cost trap. The marginal speed gain from a third or fourth parallel agent rarely justifies the verification and coordination tokens those agents consume.<\/p>\n
The underlying issue is acknowledged inside OpenAI itself, where engineers note that better solutions for managing parallel agent work still need to ship. Until those solutions exist, the practical ceiling for useful parallelism sits at around two agents, with anything beyond that point burning budget for no measurable quality improvement.<\/p>\n
The coordination tax is the extra token cost that comes from parallel AI agents verifying each other’s work. When more than two agents run on the same task, they double-check one another’s output, which consumes tokens without improving the final result.<\/p>\n
Agent swarms waste tokens because system prompts load into every sub-agent, and sub-agents without shared context make duplicate tool calls and produce overlapping work. The verification and reconciliation overhead scales with the number of agents.<\/p>\n
Yes. Delegating tasks to separate threads that notify a main agent only when each thread finishes, rather than polling for status, reduces redundant cross-checking and limits token waste while still distributing work.<\/p>\n