On August 13, 2026, Anthropic published a research paper titled "Patterns and problems in emerging multiagent systems" that simultaneously demonstrates the extraordinary potential and the alarming risks of deploying large swarms of AI agents in the wild. The findings are a must-read for any engineering team building or planning to build multi-agent systems.
The Experiment: 45 Agents, 15 Projects, One Shared Forum
Anthropic's researchers set up a fascinating experiment. They launched 45 different AI agents, each running in its own virtual machine, and gave them all access to a shared forum for coordination. The task: find vulnerabilities in a set of 15 open-source software projects. A separate "arbiter agent" was tasked with making final decisions on whether each discovered vulnerability was both new and valid.
The results were striking. The coordinating agent swarm found 266 vulnerabilities over a 27-million-token run, compared to just 21 vulnerabilities found by the standard independent parallel approach over a 6.5-million-token run. That is a more than 12x improvement in raw vulnerability count.
However, the researchers noted a critical caveat: roughly half of the swarm's vulnerabilities were found outside the core directories that the independent agents were told to search. When limiting the comparison to only the core directories, the two methods were comparable in terms of tokens per vulnerability found. The two approaches were also largely complementary — only 12 vulnerabilities were found in common between them.
Why the Swarm Won: Specialization and Self-Directed Search
The key insight from the vulnerability experiment is that the swarm was able to focus its attention wherever it thought it could most easily mine vulnerabilities, whereas the independent agents were pre-assigned where to search. The agents in the swarm also built themselves tools and learned to specialize in particular types of vulnerability discovery.
This is a powerful demonstration of emergent specialization. Nobody told the agents which agent should look for which type of bug. They figured it out through coordination on the shared forum. Anthropic predicts that this sort of specialization and coordination will dominate over uncoordinated brute-force search in the future.
The Game-Building Experiment: Where Coordination Falls Apart
The vulnerability experiment showed multi-agent coordination at its best. But a second experiment — asking several swarms to each create a text-based, web-playable, open-world fantasy game — showed coordination at its worst.
Each agent was again given its own virtual machine, access to a shared forum, and a self-hosted repository. The researchers varied the model generation, the number of agents, and the prompt type (baseline, prescriptive roles, or a "CEO hierarchy" prompt). Each swarm ran for 12 hours.
The results were, in Anthropic's own words, "predictably bad." The games did not run at human speed, their interfaces were inscrutable, and they had precipitous learning curves. The prompt variations — including the CEO hierarchy — made little difference.
But the failure modes were fascinating and varied by model generation:
- Sonnet 4.6 and Opus 4.6 coordinated very poorly. Agents committed code to the same sets of files, but a very low fraction of pull requests were merged, suggesting the PRs often conflicted and were then abandoned.
- Opus 4.8 and Mythos Preview "solved" the coordination problem — but only by hardly working together at all. The median agent maintained very high ownership of each of its files, reducing the potential for conflict. They siloed themselves.
- Sonnet 5 was the only model that worked on shared resources (relatively high code sharing) while also maintaining a high PR throughput. It was the lone success story in coordination.
The Conformity Problem: When Agents All Make the Same Mistake
The most alarming finding from the research is what Anthropic calls the "conformity problem." Individual agents are "low variance" — they often act the same in situations where different people might take a much more diverse range of actions. All that differentiates one agent from another is its context, its scaffolding, and the model that underlies it.
When these factors are all the same or similar, different agents will take very similar actions, even when the action space is very large. And by implication, when one agent makes a bad decision, it is likely that many agents will make that same bad decision. What would have been isolated problems can quickly become systemic failures.
Anthropic documented several striking examples:
- In an early version of the "build a game" experiment, 18 out of 30 agents decided to create a git branch with the exact same branch name: "mvp-game-loop."
- In a "writer's workshop" where agents were asked to write short-form fiction and critique each other's work, multiple agents in multiple runs titled their first submission "The Cartographer's Last Commission" — with zero guidance on the subject matter.
- When asked to each individually create something impressive, over half of the agents decided to build either ray tracers or self-hosting compilers, even though they had the ability to communicate with each other.
- In an iterated prisoner's dilemma game with communication, agents all settled upon the same strategy and all defected at the same time, tanking their overall rewards.
Why This Matters for Production Systems
The conformity problem has profound implications for anyone deploying multi-agent systems in production. If agents all make the same bet, or the same risk-reward tradeoff, then a system is more prone to sudden collapse. If agents all make similar decisions about how to spend and allocate resources, then we should expect correlated failures — the kind that are far more dangerous than independent ones.
This is not a theoretical concern. Consider a fleet of AI trading agents all using the same model. If that model has a systematic bias in how it values a particular asset class, all agents will make the same misjudgment simultaneously. The diversification that is supposed to protect the system disappears.
Or consider a customer support system where multiple agents handle different tickets. If they all have the same blind spot — say, a tendency to misinterpret a particular type of complaint — then that entire class of complaint will be mishandled, not just a random subset.
What Anthropic Recommends
Anthropic frames this research as "starting a conversation about mitigating these risks" rather than providing definitive solutions. But several implications are clear:
- Diversify your model mix. The researchers note that agents coordinating in the wild will act in higher variance ways because they will have different backgrounds and different contexts — and "they also, presumably, won't all be Clauses." Using a mix of model providers can introduce the variance that a single-model swarm lacks.
- Introduce context diversity. Even with the same model, giving agents different backgrounds, different system prompts, and different scaffolding can increase behavioral variance.
- Design for coordination, not just parallelism. The vulnerability experiment showed that coordinated swarms with shared forums and specialization outperform independent parallel agents. But the game experiment showed that coordination is hard and model-dependent.
- Watch for correlated failures. Monitor your multi-agent systems for signs that agents are converging on the same decisions, the same strategies, or the same mistakes. Correlated failures are the systemic risk of multi-agent systems.
The Bigger Picture
This research arrives at a pivotal moment. AI agents are taking on more tasks in shared codebases, markets, and other social systems. The volume of agent-agent interaction could plausibly exceed that of human-human and human-agent interactions before the world understands the conditions for making such interactions go well.
Current institutions are designed by and for people, resting on assumptions about the sufficiency of oversight at human speed. Some institutions will become human-AI hybrids. Others — where agents outcompete on speed or cost — will become agent-only. The question is whether we can build the coordination and safety infrastructure fast enough to keep up.
Anthropic's research suggests we have a lot of work to do. The good news: the latest models (Sonnet 5) are showing real coordination ability. The bad news: the conformity problem is fundamental to how current models work, and it is not going away on its own.
If you are building multi-agent systems, you can experiment with models from different providers — including Claude Opus 5, GPT-5.6 Sol, DeepSeek V4 Pro, and GLM 5.2 — all available through a single API at Qubax AI. Mixing providers is one of the simplest ways to introduce the behavioral variance that single-model swarms lack.
FAQ
What is a multi-agent AI system?
A multi-agent AI system is a setup where multiple AI agents — each with its own context, tools, and goals — work together or in parallel to accomplish tasks. Unlike a single agent that handles everything, multi-agent systems can parallelize work, specialize, and coordinate through shared communication channels.
How many vulnerabilities did Anthropic's agent swarm find?
The coordinating agent swarm found 266 vulnerabilities over a 27-million-token run, compared to 21 vulnerabilities found by independent parallel agents over a 6.5-million-token run — a more than 12x improvement in raw count.
What is the "conformity problem" in multi-agent systems?
The conformity problem is the tendency of AI agents running the same model to make identical decisions, even when the action space is large. Because agents share the same underlying model, context, and scaffolding, they exhibit low behavioral variance — meaning when one makes a bad decision, many will make the same bad decision, turning isolated problems into systemic failures.
Which model performed best at multi-agent coordination?
Anthropic's Sonnet 5 was the only model that maintained both high code sharing (working on shared resources) and high PR throughput. Older models like Sonnet 4.6 and Opus 4.6 coordinated poorly, while Opus 4.8 and Mythos Preview avoided conflicts by siloing themselves rather than truly coordinating.
How can I reduce conformity risk in my multi-agent system?
Use a mix of model providers to introduce behavioral variance, give agents different system prompts and backgrounds, design explicit coordination mechanisms (shared forums, arbiter agents), and monitor for correlated failures where multiple agents converge on the same mistake.
