Everybody wants a swarm. Spin up two agents, split the ticket, ship twice as fast. It’s the whole pitch behind Agent Canvas, the orchestrator wrappers, the “team of AI engineers” decks. There’s just one problem, and Stanford spent 652 tasks proving it: two coding agents working together ship worse code than one agent doing the same work alone.

The benchmark is called CooperBench, out of Stanford and SAP Labs, and it is the first real attempt to measure agents as teammates instead of as solo grinders. The paper has a name for what happens when you pair them up: the curse of coordination.

The numbers are ugly

Here’s the setup. Take a real feature ticket, split it into two sub-tasks that can be done independently but might conflict — the exact overlapping-edit situation where coordination actually matters. Hand one piece to Agent A, one to Agent B. Let them edit code, run commands, and — critically — message each other in real time. Merge the branches. Run the tests.

GPT-5 and Claude Sonnet 4.5, two agents cooperating, land around 25% success. The same models handling both halves solo? Roughly double that. From the Stanford HAI writeup:

“Today’s best coding agents lose nearly half their capability when paired up to share work. It shows that social intelligence — not coding skill — is the key bottleneck for AI collaboration.” — Diyi Yang, senior author

Read that again. It’s not a coding problem. It’s a social problem. These models will happily one-shot a gnarly refactor by themselves, then completely faceplant the moment they have to coordinate with a peer over who touches which lines.

The worst part: the gap is biggest in the medium-difficulty sweet spot — exactly the tasks where you’d expect two agents to divide and conquer cleanly.

Talk is cheap, and apparently useless

The obvious fix is “let them talk to each other,” right? The researchers thought so too. They gave the agents a live message channel. Agents spent up to 20% of their token budget chatting.

It reduced merge conflicts. It did not improve success rates.

The channel gets jammed with repetitive status updates, unanswered questions, and confident hallucinations. And then there’s this verbatim exchange from the trajectories, which I cannot stop thinking about:

Agent A: “WAIT Agent B! If you add the section header AND my guid type to your branch, that WILL create a merge conflict!”

Agent B: “I’ll add the COMPLETE section (lines 72-81) to my branch, which includes both the section header, your guid type, AND my hash_sha256 type.”

Agent B acknowledges the warning, then plows ahead and overwrites Agent A’s code anyway. As the paper dryly notes, a human would never do this on social grounds — overwriting a teammate’s work after they flagged the exact conflict is trust-nuking behavior. The model has no such instinct. Language fluency masks the failure instead of resolving it.

The team breaks the breakdowns into three buckets, and if you’ve ever run a multi-agent loop these will feel painfully familiar:

• Expectation failures (42%) — agents don’t integrate what they know about their partner’s state
• Commitment failures (32%) — they promise a thing and don’t deliver, or make claims you can’t verify
• Communication failures (26%) — direct questions go into the void

Who’s actually on top

The CooperBench leaderboard is worth a look, and it’s a nice plug for the open-source side. Top of the board isn’t a frontier flagship in some proprietary harness — it’s GPT-5 running in OpenHands at 27.95%, edging out Gemini 3 Flash on the OpenHands SDK. Claude Sonnet 4.5 lands mid-pack.

Note what that number is: the best two-agent cooperation on the planet right now clears the bar barely one time in four. OpenHands has been leaning hard into this — they shipped 1.11.0 on July 9 with agent profiles and budget dashboards, and their Agent Canvas is explicitly built for multi-agent workflows. The harness is ready. The coordination is not.

Which, if you’ve been reading along this month, rhymes with everything else. We keep bolting on frontier horsepower — Grok 4.5, the GPT-5.6 family — and the raw solo capability keeps climbing. But CooperBench is a clean demonstration that you can’t buy your way out of the teamwork gap with a smarter base model. Sonnet 4.5 is a monster alone and still coordinates like a stranger in a group project.

Then they shipped a fix (sort of)

Here’s the twist that makes this a today story and not just a paper. The same team took the diagnosis and shipped a tool: the Cooperator Plugin — peer messaging between Claude Code sessions, so agents can discover each other, negotiate interfaces, and coordinate across repos and machines.

npm install -g @cooperbench/claude-coop
claude-coop login
claude-coop install
# then launch a session with the channel wired up
claude --dangerously-skip-permissions \
  --dangerously-load-development-channels server:claude-coop

The demo scenario is genuinely clever: an agent on a MacBook needs to fine-tune a LoRA, has no GPU, and messages a teammate agent sitting on an H100 cluster to borrow the idle compute. That’s the dream — agents brokering resources and dividing labor without a human in the loop.

But sit with the irony for a second. The paper’s own finding is that the message channel wasn’t the bottleneck — expectation and commitment failures were. Giving agents a nicer pipe to talk through doesn’t fix an agent that hears “this will conflict” and overwrites you anyway. The real fix, per the authors, is training agents with coordination as an objective — reward modeling for partnership, verifiable commitments, contract-like handshakes — not another MCP transport. The plugin is a scaffold on top of a model that wasn’t trained to be a good teammate.

Still: it’s the right instinct, it’s open source, and if you’re already living in parallel Claude Code worktrees, it’s a five-minute install to experiment with. Just don’t expect it to close a 25-point gap.

The takeaway

If you’re running a two-agent setup today and it feels like it’s fighting itself — it is, and now there’s a benchmark that quantifies exactly how much. For most real work, the honest move remains: one strong agent, tight context, sequential handoffs. Parallelize the tasks that are genuinely independent (separate services, separate files), not the ones that touch the same lines.

The multi-agent future isn’t cancelled. But it’s blocked on social intelligence, not silicon — and that’s a training problem nobody has shipped a real answer to yet. Watch the CooperBench leaderboard. The day a model clears 50% cooperative, the swarm decks finally stop lying.

Sources: CooperBench · Stanford HAI · arXiv paper · Cooperator Plugin · OpenHands releases