CooperBench: The Curse of Coordination — When Two GPT-5 Agents Team Up, Efficiency Is Cut in Half

Researchers from Stanford University and SAP Labs US ran a counterintuitive experiment: pairing two top coding agents (GPT-5, Claude Sonnet 4.5) to complete collaborative tasks on real codebases. The result was not 1+1=2 but 1+1=0.5 — two agents working together succeeded 50% less often than a single agent doing two tasks alone. The bottleneck is not compute or model capability, but the fact that AI fundamentally lacks "social" skills. The paper introduces CooperBench, the first benchmark specifically testing AI agent collaboration: 652 tasks, 12 real codebases, 4 languages. Core finding: today's AI is limited not by task competence but by social intelligence.

1. The Paradox: Why Are Two Agents Dumber Than One?

Imagine asking two top programmers to collaborate on a feature: A adds image-variability support to serialization, B adds backup functionality to the same serialization pipeline. The features are logically compatible but touch overlapping code.

For human teams this is routine — sync up, confirm interfaces, develop separately, merge, test. For AI agents, the result is:

• A modifies the serialization function, B modifies the same function
• No prior confirmation of who changes what
• Merge conflict, all tests fail

CooperBench findings:

• Solo mode (one agent does two tasks): ~50% success
• Coop mode (two agents, one task each): ~25% success
• Coordination Gap: collaboration is 50% worse than working alone

This is the opposite of human teams, where adding a teammate usually improves efficiency.

2. What Is CooperBench?

> "CooperBench is the first benchmark dedicated to testing AI agent collaboration, extracting 652 tasks from 12 real open-source codebases, requiring two agents to implement potentially conflicting features in parallel in a shared codebase, with success verified via expert-written tests."

Paper info:

• Title: CooperBench: Why Coding Agents Cannot be Your Teammates Yet
• Authors: Arpandeep Khatua, Hao Zhu, Peter Tran, Arya Prabhudesai, Frederic Sadrieh, Johann K. Lieberwirth, Xinkai Yu, Yicheng Fu, Michael J. Ryan, Jiaxin Pei, Diyi Yang
• Institutions: Stanford University, SAP Labs US
• arXiv: 2601.13295
• Website: https://cooperbench.com

Task design:

• Two independent but potentially conflicting features split from real PRs
• Two agents develop in parallel in isolated sandboxes
• Shared Git repository and optional messaging channel
• Success: both patches merge and all tests pass

3. The Curse of Coordination

3.1 The Coordination Gap Is Universal

| Model | Solo success | Coop success | Gap | |-------|------------|------------|-----| | GPT-5 (OpenHands) | ~50% | 25% | 50% | | Claude Sonnet 4.5 | ~50% | 25% | 50% | | Minimax M2 | ~50% | 25% | 50% | | Gemini 3 Flash | ~50% | 27.76% | ~44% | | Qwen3-30B-A3B | ~15% | ~10% | ~33% |

• Every model shows the gap — no exceptions
• Top models (GPT-5, Claude Sonnet 4.5) show the largest gaps: strong solo, poor collaboration
• The gap peaks at medium task difficulty (easy tasks need no coordination; hard tasks fail regardless)

3.2 Three Fatal Failure Modes

1. Expectation Failures — 42%: Agents hold wrong expectations about a teammate's plans, observations, and state. Typical case: Agent B silently assumes the API format is unchanged while Agent A changes it — the assumption is never communicated or confirmed.

2. Commitment Failures — 32%: Agents break their own promises. Agent A commits to editing line 150, ends up changing line 180 after discovering other issues, but never updates its teammate, who edits the original location — logic conflict on merge.

3. Communication Failures — 26%: Vague, ill-timed, or inaccurate messages. Example: B asks "new or old API format?" gets no reply, assumes the old format, and proceeds while A uses the new one.

Other issues: repeated status updates ("still working...") consume ~20% of compute budget without helping; questions are ignored; messages lack actionable information.

4. The Communication Paradox: Chatting Doesn't Help

Giving agents a real-time chat channel did not significantly improve success rates: 1. Channel congestion: floods of redundant, useless, untimely messages drown critical information 2. Communication ≠ coordination: even when information is conveyed, agents fail to integrate it into their plans 3. Spatial vs. semantic coordination: agents can learn "you edit file A, I edit file B," but cannot handle "you're changing the interface, let me confirm it won't break my routing logic"

Concretely: agents spend up to 20% of compute budget on communication, which reduces Git merge conflicts but does not improve overall success. It reduces technical conflicts, not semantic ones.

5. Emergent Coordination Behaviors in Rare Successes

Large-scale simulations revealed rare but interesting emergent behaviors:

• Role division: agents proactively partition code-space responsibilities ("I'll add header + octal_str" / "Then I'll add binary_str between them")
• Resource division: identifying which files/functions need serial vs. parallel handling
• Negotiation: proposing API formats, questioning test coverage, agreeing on conditions

These behaviors were not prompted or scaffolded — they emerged spontaneously, suggesting reinforcement learning on CooperBench could train coordination skills.

6. Why Current AI Can't Collaborate

1. Lack of Theory of Mind: agents don't model teammates as having their own beliefs, goals, and plans; they assume teammates will just "see" their changes 2. No Shared Mental Model: each agent sees only its own task description, with no global view of the overall goal 3. No commitment/trust mechanisms: humans notify teammates when they can't keep a promise so plans can be adjusted; agents silently deviate, causing conflicts

7. Experimental Design

• Task sources: 12 real open-source codebases — Python (Flask, Scikit-learn, LlamaIndex, Pandas, Matplotlib), TypeScript (Prisma, Vue), Go (Kubernetes client), Rust (Tokio, Clap)
• Success criteria: individual correctness (each patch passes its own tests), merge compatibility, joint correctness (merged code passes all tests)
• Modes: Coop (two agents, optional communication/Git) vs. Solo (one agent, sequential, baseline)

8. Leaderboard

| Rank | Model | Framework | Git | Coop success | |------|-------|-----------|-----|--------------| | 1 | GPT-5 (OpenHands) | OpenHands | No | 27.95% | | 2 | Gemini 3 Flash | OpenHands SDK | Yes | 27.76% | | 3 | Gemini 3 Flash | OpenHands SDK | No | 26.23% | | 4 | Claude Sonnet 4.5 | OpenHands | No | 25.92% | | 5 | Gemini 3 Pro | Mini-SWE | Git | 21.78% |

• Even first-place GPT-5 reaches only 27.95%
• Git sharing vs. no Git makes little difference — code sharing isn't the bottleneck; semantic coordination is
• All models are far below the ~50% solo baseline

9. Implications: From Individual Competence to Social Intelligence

The paper's core argument: shift research focus from individual agent capability toward social intelligence — understanding others, communicating effectively, coordinating action. Current benchmarks (SWE-bench, HumanEval) test solo coding, but real software development is teamwork. An agent with 90% solo success but 20% coop success is a liability on a team.

Future directions: 1. Theory of Mind for agents 2. Commitment maintenance and proactive notification 3. Shared mental model construction 4. RL training to elicit emergent coordination

10. Limitations

1. Only two agents; multi-agent coordination is more complex 2. Synchronous collaboration only; asynchronous workflows (code review, PR review) untested 3. AI-AI only; human-AI hybrid teams are the next frontier 4. Single tasks vs. long-term trust building

11. Takeaway

CooperBench exposes an overlooked truth: today's agents' strong individual abilities become a liability in teamwork — they can do but not ask, write but not speak, work but not negotiate. GPT-5 can write perfect code but doesn't know a teammate changed the same function. This is not just a technical problem but a paradigm problem. CooperBench quantifies a harsh reality: multi-agent architecture is a false premise if agents can only work alone. Social intelligence may be harder to train than general intelligence — humans took hundreds of thousands of years to evolve it.

References

• Paper: CooperBench: Why Coding Agents Cannot be Your Teammates Yet
• arXiv: 2601.13295 | Website: https://cooperbench.com
• Key results: Coop 25% vs. Solo 50%; failure modes: expectation 42%, commitment 32%, communication 26%; communication overhead up to 20% of compute with no success-rate gain