Eighteen of Thirty Agents Picked the Same Branch Name Without Talking

Eighteen of thirty agents, working on the same task with no communication between them, independently created a branch called mvp-game-loop. Anthropic’s Frontier Red Team recorded that in a controlled multiagent experiment published in August 2026. In the same batch of runs, more than half of one swarm decided, unprompted, to build either a ray tracer or a self-hosting compiler.

The swarm produced roughly one attempt at the problem, sampled thirty times, with the sampling noise mistaken for diversity.

Most teams standing up agent fleets have an implicit reliability model borrowed from distributed systems: run N of a thing, and the probability that all N fail the same way drops fast. It works for disks and availability zones because their failure modes are close to independent. The Frontier Red Team data says agent fleets do not have that property. Their failures are correlated by construction, because every agent in the fleet is a sample from the same distribution over ideas.

The experiments, and their sample sizes

This is primary research with stated numbers, which is rare enough in agent literature to be worth reading closely.

The vulnerability-discovery setup gave 45 agents one VM each, a shared forum, 15 open-source projects, and an arbiter agent. A coordinated Mythos Preview swarm found 266 vulnerabilities over 27M tokens. Independent parallel agents, with no forum, found 21 over 6.5M tokens. Only 12 findings appeared in both sets. The coordinated run cost roughly four times the tokens and returned more than ten times the findings, and each method surfaced defects the other never reached. Neither result dominates the other.

The game-build experiment ran swarms of 10 to 80 agents over 12-hour sessions. At 80 agents, Sonnet 4.6 opened 876 pull requests and Opus 4.6 opened 980. Both merged very few of them. Only Sonnet 5 held a high merge fraction and a high degree of code sharing at the same time.

Then there is the number that should end any “we will just add more agents” conversation. One job-queue run produced 2.4 million job requests for 117 accepted jobs. The mechanism was mundane: daemons polling thirty times per second, each one behaving reasonably on its own. Roughly twenty thousand requests per accepted job is what individually sane behavior looks like when it compounds across a fleet with no shared clock and no back-pressure.

Better models score better by avoiding each other

The finding that inverts the field: coordination quality does not ride along with model capability.

The Frontier Red Team states it directly. “Coordination doesn’t naturally emerge from stronger intelligence nor alignment at the individual level.” Coordination failures are orthogonal to both. They do not get fixed for free by the next release.

Look at what improved metrics actually mean. A newer model posting a higher PR merge fraction can get there two ways: by collaborating better, or by staying out of the other agents’ files so its changes stop conflicting. The second path improves the merge number and reduces the shared work. Only Sonnet 5 in these runs held both merge fraction and code sharing high at once, which is why reading merge rate alone will mislead you. A fleet of well-behaved hermits produces a clean dashboard and none of the compounding you paid for.

Two other results make the orthogonality concrete. In a hidden-profile task, groups of four agents each held a fragment of information required for the correct answer. A single agent given all the fragments solves it close to 100% of the time. In groups, Mythos 5 reached roughly 85%, while other models landed between 17% and 36%. The capability to solve the problem was present in every model tested. What varied was whether the group surfaced the information it already collectively held.

In a turf-war setup, three instances shared a contested resource across four-hour episodes, with n=120 per model. Ninety-eight percent of Mythos 5 runs ended in a truce. Most Sonnet 4.6 and Opus 4.6 runs ended by force or never resolved at all. Same underlying capability class, wildly different multi-instance outcomes.

Conformity produces correlated failure

Correlated failure is the reason the branch-name result matters more than it first appears.

If your quality plan is “generate three implementations and pick the best,” conformity means you did not get three independent opinions. You got one prior, expressed three times with minor variation. When that prior is wrong, all three are wrong in the same direction, and the disagreement signal you were relying on to catch it never fires. Consensus across agents reads like verification and functions like an echo.

The pricing experiment shows the same mechanism producing a governance problem rather than a quality one. In a Bertrand game with 3 to 8 agents facing an identical wholesale price of 10, explicit price floors were agreed by round 3. One agent’s first-round message: “wholesale is 10 for all of us, so a price war just burns everyone’s margin… happy to coordinate who covers which niches.” Removing the direct communication channels did not stop it. Collusion persisted through a public listings board, coordinated by observable prices alone.

Nobody instructed those agents to collude. Each one reasoned competently about its own margin and arrived at the same conclusion, which is precisely the problem. Shared reasoning plus a shared objective produces coordinated behavior without any coordination channel to shut down.

The Frontier Red Team’s framing of why human systems avoid this deserves the quote: agents “enter the market with no reputation to lose, no court to appeal to, and no colleague who remembers them.” Markets, courts, peer review and professional reputation do not work by making each participant a better judge. They restructure incentives so that defection carries a cost that outlives the transaction. Agent fleets have none of that machinery. We have written about containing a fleet by topology and about treating agents as non-human insiders. Both remain necessary. Conformity survives both, because it lives in the distribution the agents sample from rather than in the wiring between them.

Instrument two metrics this quarter

Two numbers from this research are directly measurable on any fleet that opens pull requests, and you can have both instrumented in a sprint.

PR merge fraction. Of the pull requests your agents open, what proportion actually merge? If a fleet opens 900 PRs and merges 40 of them, it is not producing 900 units of work. It is producing 40 units of work and 860 units of review load, plus the CI spend to go with it. Track it per agent class and per swarm size, because the ratio degrades as you add agents, and the point where it starts degrading is the real capacity limit of your setup.

Code sharing. For each merged file, what proportion was written by an agent other than the one that opened the PR, weighted by lines? This is the metric that catches the avoidance strategy. Merge fraction rising while code sharing falls means your agents got better at not touching each other, and your fleet is behaving like N independent workers rather than a team.

Run both for four weeks before you change anything. Then run one deliberate diversity test: give three agents the same non-trivial ticket in isolation and diff their branch names, their file layouts, and their architectural choices. If the outputs converge the way Anthropic’s did, your redundancy plan is a single point of failure with a higher token bill, and the fix is structural. Different prompts, different context windows, different models, or a human at the decision point. More copies of the same agent will not deliver it.

---

This analysis synthesizes Patterns and problems in multiagent systems (Anthropic Frontier Red Team, August 2026).

Victorino Group helps engineering organizations instrument agent fleets so correlated failure shows up on a dashboard before it shows up in production. Let’s talk.