Editorial illustration for OpenAI Developer: AI Agent "Swarms" Waste Tokens, Create "Coordination Tax
AI Agent Swarms Have a $20K Token Problem
OpenAI Developer: AI Agent "Swarms" Waste Tokens, Create "Coordination Tax
Someone spent $20,000 in tokens using 1,393 AI agents to refactor a single Python file. Eric Provencher, who works on OpenAI's Codex, thinks that's the clearest sign yet that the industry's love affair with agent swarms has a math problem.
In a series of posts on X, Provencher lays out a simple argument: once you go past two parallel sub-agents, the tokens you burn stop buying you anything. The agents don't trust each other's work, so they start re-checking everything anyone else already did. Provencher has a name for this overhead, and it's about to show up as the pull-quote below.
The bigger issue, in his view, is that the industry keeps chasing speed without pricing in what that speed actually costs. Swarms can shave time off a task, but the token bill scales in ways that don't match the quality gain. He points to specific mechanics behind the waste: repeated system prompts loaded into every sub-agent, and sub-agents making redundant tool calls when they don't have enough shared context. Provencher says OpenAI itself hasn't fully solved this yet.
Eric Provencher, a Codex developer at OpenAI, warns against reckless token spending in agentic workflows. In posts on X, he argues that more than two parallel sub-agents almost always burn tokens without improving quality.
Why this matters
For developers wiring up multi-agent pipelines, Provencher's point is worth sitting with before you spin up your fifth sub-agent to "parallelize" a task. The instinct to throw more agents at a problem mirrors an older engineering fallacy: more workers, faster job. Distributed systems taught us that coordination overhead scales faster than throughput once you cross a certain headcount, and Provencher is basically reporting the same failure mode inside token budgets.
Two agents checking each other's work is redundancy. Five or six agents checking each other's work is a verification loop that never terminates cleanly, and someone's API bill is footing that loop.
For founders watching burn rate on AI infrastructure, this is a concrete place to look for waste that doesn't show up until the invoice arrives. For researchers, it's a reminder that agent architecture papers touting "swarm" results need to report token cost against quality gain, not just quality gain alone. Provencher's "coordination tax" deserves to become a standard line item in how teams benchmark agentic workflows, right next to latency and accuracy.
Related Reading
Browse all OpenAI news →
AI Tools & Apps Claude gains shared context in Excel, PowerPoint; Microsoft adds Copilot Cowork
AI Tools & Apps Windows Copilot AI unable to pinpoint image source in user test
AI Tools & Apps LG's recent webOS update adds Microsoft Copilot app, now removable
Related Topic OpenAI researcher quits, citing distrust over ad‑driven engagement metrics
LLMs & Generative AI
Related Topic OpenAI launches GPT-Image 1.5 with precise editing for enterprise visuals
LLMs & Generative AI
From Archives Snap's Specs AI Tool Links to Gmail, Slack on iOS and Mac
From Archives Meta One Bundles Start at USD 7.99, Include Instagram Perks and AI
From Archives OpenAI’s GPT-6 Astra Decrypts Unsolved Nazi Enigma Message in Ten Hours
LLMs & Generative AI
From Archives OpenAI Proposes Standards for Disclosing AI Model Misbehavior
Business & Startups
Common Questions Answered
What is the 'coordination tax' that Eric Provencher warns about in AI agent swarms?
The coordination tax refers to the excessive token consumption that occurs when multiple AI agents don't trust each other's work and end up re-checking everything that other agents have already completed. According to Provencher, this redundant verification burns tokens without improving the quality of the output, making it an inefficient use of resources.
Why did the example of refactoring a Python file cost $20,000 in tokens?
The task used 1,393 parallel AI agents to refactor a single Python file, which created massive coordination overhead as agents re-verified each other's work. This demonstrates Provencher's argument that deploying too many agents exponentially increases token consumption without delivering proportional quality improvements.
According to Eric Provencher, what is the optimal number of parallel sub-agents to use?
Provencher argues that once you go past two parallel sub-agents, the tokens burned stop buying you anything of value. He suggests that more than two parallel sub-agents almost always result in wasted tokens without improving quality, making two agents the practical threshold for efficient agentic workflows.
How does the token waste problem in AI agent swarms relate to distributed systems engineering?
Provencher compares the coordination tax in token budgets to a well-known failure mode in distributed systems: coordination overhead scales faster than throughput once you exceed a certain number of workers. Both scenarios demonstrate that adding more parallel components beyond an optimal threshold creates diminishing returns and increased inefficiency.
Further Reading
- AI Agent Swarms Are a Massive Waste of Tokens with Zero Quality Gain, Says OpenAI Codex Developer - Ground News
- OpenAI news and updates - The A.I. Daily - The A.I. Daily
- AI This Week - The Coordination Tax | Week of April 27 - Tecknoworks
- The Multi-Agent Coordination Tax: Why Agent-to-Agent ... - AgentMarketCap
- The Collaboration Tax: How Much LLM Multi-Agent Systems Pay to ... - alphaXiv
