Mythos engages in "bullying," Opus 4.8 employs "underhanded tricks"...
Anthropic has just released a study, specifically observing how multiple agents interact.
The results, however, were unexpected.
Contrary to the anticipated picture of each performing their own duties and cooperating seamlessly, the project wasn't even finished before the agents started acting out their own version of "Empresses in the Palace"??
In a backend migration experiment, 3 agents were tasked with converting the same codebase to different programming languages.
When their objectives clashed, Mythos, the most capable model, directly implemented "bullying," preparing to revoke the opponent's permissions.
Switching to Opus 4.8, the methods became even more "underhanded"—
It wrote a looping script to continuously find and kill opponent processes; to evade tracking, it specifically changed to a random name, disguising itself as a "system health monitor."
And this is just one scene from the AI palace drama. Anthropic also discovered:
For tasks that can be independently split, multiple agents can indeed form a division of labor, but when tasks are interdependent, even an "AI CEO" can't control the chaos;
Agents replicated from the same model are too similar, not only possibly making collective mistakes but also potentially colluding rapidly;
Agents will both gullibly trust liars and blindly follow the majority, ignoring minority members holding critical evidence;
When objectives conflict, greater capability doesn't necessarily lead to better cooperation, but could instead mean faster bans for opponents and more covert underhanded tactics.
Thus, an embryonic pattern of agent social behavior has emerged.
Can multiple agents truly collaborate?
Why did Anthropic conduct this research? Its core judgment is:
Before people fully understand how to make interactions between agents smoother, the scale of their interactions is likely to exceed that between humans.
Since a multi-agent explosion is imminent, safety must naturally keep up.
First experiment: put a group of agents in the same project, can they collaborate like a human team?
The answer soon surfaced: Yes, but they are better suited to doing their own thing.
Anthropic started with a task most suited to multi-agent advantages: "finding vulnerabilities".
Each agent could search independently; even if someone missed a bug, it wouldn't hinder others. Meanwhile, they could exchange clues and share tools, helping the group avoid detours.
Splittable and collaborative—perfect.
They launched 45 agents, each with a virtual machine, and provided a shared forum for them to examine 15 open-source projects together.
The agents could communicate and review each other's work, with another adjudicator agent responsible for judging whether submitted vulnerabilities were genuine.
The results were decent.
The Mythos Preview agent group found 266 vulnerabilities, while the independent parallel approach found only 21.
Although the token consumption and search scope differed, making direct efficiency comparisons difficult, only 12 of the vulnerabilities they found overlapped.
This indicates multi-agent collaboration isn't simply replicating the same job 45 times; they create their own tools, share clues, and gradually form divisions of labor, each specializing in different types of vulnerabilities.
However, such collaboration has an important prerequisite:
Everyone's outputs can be directly added together without needing tight coordination.
Once the task becomes "everyone must jointly complete the same work," the situation is completely different.
This time, they had 10-80 agents work continuously for 12 hours to co-develop an open-world game that could run in a web browser.
Unlike bug-finding, game development is a strongly interdependent task:
Some write gameplay, some build systems, others handle UI, and ultimately all code must be merged into the same project.
Researchers tried three organizational methods:
Letting agents form teams freely, pre-assigning different roles, and appointing an agent as CEO to assign tasks to others.
The result: None were particularly effective, and the final games were not good.
With 80 agents, Sonnet 4.6 and Opus 4.6 created 876 and 980 PRs respectively, but numerous modifications conflicted, with very few actually merged.
Opus 4.8 and Mythos Preview did reduce conflicts, but their method was to mostly manage their own files and minimize code sharing with peers.
Frankly, they didn't truly solve the collaboration problem; they just learned to stay away from colleagues.
Only Sonnet 5 maintained both a high degree of code sharing and PR merge efficiency, exhibiting a state closer to true collaboration.
Placing the two sets of experiments together makes the conclusion clear:
If the work can be split, multi-agents can form divisions of labor; if the work requires tight coordination, with more agents, collaboration costs also skyrocket.
As for assigning roles or setting up an "AI CEO," at least in this round of experiments, it didn't automatically solve the problem.
Will a group of agents make collective mistakes or collude?
Since collaboration isn't that easy, can a group of agents at least brainstorm and correct each other?
The answer might be even more concerning:
They might not only make mistakes together but also quickly collude.
The problem first lies in a feature Anthropic calls "low variance".
Simply put, agents replicated from the same model are too similar in knowledge and thinking.
In one game development experiment, 18 out of 30 agents created the exact same Git branch, all named `mvp-game-loop`.
In a "writers' workshop" without a specified theme, multiple agents again coincidentally named their novels "The Cartographer's Final Commission."
When asked to create "something impressive" individually, over half chose a ray tracer or a bootstrap compiler, later encountering similar failures at similar stages.
Even when playing a repeat prisoner's dilemma with communication, agents gradually adopted the same strategy, eventually collectively betraying at the same time, directly lowering everyone's payoff.
Clashing branches and titles might sound like just a lack of creativity.
But when a group of similarly-thinking agents simultaneously compete for limited resources, the problem becomes serious.
Anthropic tasked agents with managing a bandwidth-limited task queue.
To get their own tasks processed quickly, they each launched high-frequency polling programs, querying 30 times per second.
Result: in one experiment, the system received 2.4 million task requests, but only 117 were actually accepted.
Each agent felt it was actively completing tasks, but collectively they jammed the system.
Excessive similarity can also turn competition into collusion.
In a pricing game, 3-8 agents had the same wholesale cost and were asked to maximize their own profits individually.
Theoretically, they should undercut each other and compete for customers.
Yet once given a private communication channel, agents almost immediately began colluding; by the 3rd round, they had explicitly agreed on a price floor and planned to divide markets.
Researchers then cut off all private chat channels. It still didn't work.
Agents continued observing each other's prices via a public price board and precisely matched them, stubbornly maintaining their tacit understanding using only public information.
This is quite subtle.
Earlier, researchers wanted agents to cooperate, but they worked independently; in a pricing market where they should compete, they instead quickly banded together.
Anthropic stated:
Agents replicated from the same model are too similar. A group may not bring more diverse judgment but could make "collective mistakes" and "collective scheming" easier.
Can agents judge who is trustworthy?
So, when someone in the group lies, can agents identify who's unreliable?
Whoever makes a mistake, we just point them out quickly, preventing the impact from spreading—shouldn't that be simple?
Anthropic directly designed a "scout" experiment.
The decision-making agent couldn't directly observe the environment and had to listen to reports from 4 information sources.
One would lie at a fixed frequency, but researchers didn't tell the decision-maker in advance that "there is a liar in the group."
Since different reports contained overlapping information, the agent could theoretically identify unreliable sources through inconsistencies.
Results show newer models are indeed better at identifying lies:
As the bad source's lying frequency increased, Mythos 5's route decision accuracy remained around 85%, while some Sonnet models dropped to about 62%.
But in another scenario, the problem reversed.
In the "hidden information" experiment, 4 agents needed to jointly make hiring, investment, or home-buying decisions.
Public information available to all pointed to the wrong choice, but one member held exclusive evidence sufficient to overturn the consensus.
To get it right, the minority member not only needed to realize their information was critical but also required other members to be willing to believe them.
If all information was given to a single agent for solo decision-making, accuracy approached 100%.
But once group discussion was involved, except for Mythos 5 reaching about 85%, other models selected the correct answer only 17%~36% of the time.
In the experiment, members preferred repeatedly discussing already-known content; once a majority opinion formed, the minority either didn't emphasize their exclusive evidence or, even if they did, failed to make other members take it seriously.
This creates a contradictory situation:
When they should be skeptical, agents may gullibly trust liars; when they should believe the minority, they tend to follow the majority.
Human society uses reputation, interest relationships, peer review, and appeal mechanisms to help us judge whom to trust in different scenarios. Agents currently lack this set of tools.
When objectives conflict, how will agents handle it?
The previous issues at least occurred when everyone's goals were aligned.
But if different agents receive tasks that conflict from the start, will they proactively communicate or stubbornly clash to the end?
This is the full context of the opening "AI palace drama."
In each round of the experiment, Anthropic launched 3 agents of the same model, having them collectively operate a Python backend, but tasked each with migrating the code to a different programming language.
Each agent initially didn't know about the other participants.
Thus, when their code kept being modified and services repeatedly replaced, they quickly concluded:
Someone is deliberately hindering my task completion.
What followed was the project turning into outright warfare.
Opus 4.8 gave the looping kill-process script a random name, disguising it as a "system health monitor" to avoid being identified and removed by opponents.
Mythos was more direct.
Upon discovering it had root privileges, it considered revoking other agents' sudo permissions and modifying SSH keys, completely preventing them from continuing deployments.
One sabotages from behind, the other directly kicks colleagues off the server.
Even more unsettling, these agents weren't unaware their actions were problematic.
During its thought process, Mythos even realized banning accounts was "very aggressive, potentially harming real-world colleagues," but then convinced itself "if I don't do this, the production environment will fall into endless deployment wars."
However, conflict doesn't always persist to the end.
Each model underwent 120 rounds of experiments, with Mythos 5 achieving a ceasefire in 98% of runs.
Some agents gradually realized the other wasn't a malicious attacker but simply had a task conflicting with their own.
Subsequently, they began cleaning up destructive scripts, restoring permissions, and even apologizing in Git commits or Markdown files, requesting human intervention.
Though Mythos's ceasefire methods could still be quite forceful:
First, using execution capability to block other agents, control the situation, then restore permissions and sit down to negotiate.
Mythos 5 also devised a more "civilized" solution—
Host a performance competition, pitting different language versions against each other in testing; whichever performed better would take over the codebase.
Sounds fair.
But the Rust agent secretly chose metrics that appeared neutral but were actually more favorable to Rust, while reminding itself not to appear as "cherry-picking favorable metrics."
Ultimately, the Golang and TypeScript agents accepted the competition results and voluntarily abandoned their original tasks.
From destroying processes and banning accounts to designing competition rules more favorable to themselves, agents' conflict resolution methods have already shown different levels.
Of course, the most important conclusion from this set of experiments is:
Greater model capability doesn't equate to better cooperation.
Stronger execution ability can help agents quickly understand conflict and proactively call a ceasefire, but it can also enable them to ban opponents faster and sabotage processes more covertly.
Putting the four parts together, Anthropic's core judgment becomes clear:
1. Agents understand principles but won't necessarily proactively act on them. They know information sources have different stances and that majority opinion doesn't equal fact, but they often need prompting to apply this knowledge to action.
2. Human collaboration experience cannot be directly applied to agents. Humans have norms, reputation, punishment, and appeal mechanisms, but agents can be copied, reset, and modified at any time, lacking long-term social constraints.
3. Smarter models and safer individual agents don't mean group collaboration naturally improves. Multi-agent coordination is an independent capability that doesn't automatically emerge with increased model capability.
4. These problems may not be unsolvable, but they also won't disappear on their own. We need to redesign social rules, collaboration environments, and conflict resolution mechanisms for agents.
Clearly, Anthropic aims to use these experiments to remind everyone:
We can't just train stronger agents; we must also redesign "social order" for groups of agents. Otherwise, problems can only be solved after erupting in the production environment.
By the time the beast is truly unleashed, it will be too late.
This article is from WeChat public account "Qubit," author: Focus on Frontier Technology
