LLM Consensus Under Pressure: When Incentives Clash and Networks Matter

LLM Consensus Under Pressure: When Incentives Clash and Networks Matter

Introduction: LLMs trying to agree—while secretly wanting different things

If you’ve ever wondered whether multiple AI agents will naturally “settle” on the same answer, this new research is a reality check. The study, based on new work from the original paper, looks at how Large Language Models (LLMs) form consensus when agents have competing incentives—meaning they don’t all want the same outcome, even though the group only benefits when everyone agrees.

The researchers adapt something called the Network Consensus game. In this game, agents must unanimously pick one of two colors (think: two competing positions or choices). But here’s the twist: each agent is offered a different payoff depending on whether the final consensus matches their personal preference. So it’s not just “agree or fail”—it’s agreeing while balancing personal advantage vs. collective payoff.

And that’s exactly the kind of situation you get in real multi-agent systems: coordination problems, mixed objectives, emergent interactions in social platforms, and even agent swarms that develop communication patterns you didn’t explicitly design.

Why This Matters: Consensus isn’t just “nice behavior”—it’s system design and incentives

This research is significant right now because we’re moving from “single model responses” to collectives of models—agents that talk, coordinate, negotiate, or amplify messages. In those settings, consensus can be the difference between stable coordination and chaotic oscillation (or worse, coordinated manipulation).

A concrete scenario you can apply today: imagine a system where multiple LLM agents represent different actors in a community moderation workflow (e.g., “is this post safe?”, “should it be removed?”). If some agents have incentives aligned to different outcomes—say, due to role instructions, reward shaping, or even hidden policy constraints—then consensus formation can become unreliable or topology-dependent. This paper strongly suggests that you can’t assume agreement will emerge just because agents are “smart.” The communication rules and the network structure matter as much as the model.

Finally, this work builds on earlier LLM multi-agent research that examined voting, consensus mechanisms, and coordination, but it adds something missing: competing incentives + controlled variations in communication access + network topology, with both open-source models and a closed frontier model. That combination helps explain why some systems converge smoothly while others get stuck in “plateaus” that look suspiciously like echo chambers.

How the Network Consensus game becomes a test for LLM coordination

The original Network Consensus game has a simple setup: each agent chooses red or blue. Success happens only if the entire network lands on the same color. But agents have personal preferences, so the group has to coordinate around something that isn’t equally “best” for everyone.

The payoff structure: coordination under conflicting preferences

Each agent’s payoff depends on whether consensus matches their preferred color:
- £0.20 if the network consensus matches their preferred color
- £0.15 if consensus matches their non-preferred color
- £0.00 if there’s no consensus

Because agents prefer different colors (half blue-preferring, half red-preferring), there’s an incentive to defect—yet nobody gets anything without full agreement. That tension is the whole point.

How LLMs are prompted, step-by-step

In the simulation, the researchers place 36 LLM agents into a network. Each “round” is synchronous: every LLM gets a prompt, replies with a color choice (and reasoning), and then the game state updates for the next round.

A key detail: each LLM has an egocentric view—it only “sees” itself and its neighbors, not the whole network state.

So the system is essentially testing a question like:

Can LLM agents, with limited visibility and incentives that disagree, learn to coordinate into full unanimity?

The extra layer: communication constraints

The study varies what agents can do besides choosing colors. Depending on the condition, agents may:
- communicate with no one
- communicate only with neighboring agents
- communicate with the entire network (global broadcasting)

This turns the simulation into an experiment about whether shared information is required for consensus, and how different models use it.

What they actually varied: network topology, communication rules, and model identity

The researchers systematically tested multiple components that affect consensus: network structure, communication access, and whether agents are open-source or closed models.

The network topologies: from hubs to cliques

Agents sit on different kinds of graphs, each with different “social wiring”:

• Erdős–Rényi (ER): random connections (sparse)
• Barabási–Albert (BA): preferential attachment (creates hubs)
• Watts–Strogatz (WS): small-world structure (high clustering + short paths)
• Connected Caveman (CC): clustered communities (multiple cliques with sparse links between them)

This matters because consensus formation in humans has been shown to depend heavily on network structure—and the study asks whether LLMs behave similarly.

Communication conditions: none, local, global

They run three messaging setups:
- None: no communication
- Local: messages only to neighbors
- Global: messages broadcast to every agent

Importantly, they don’t test the global condition across all network structures for every setup. They mainly focus global messaging comparisons on the BA network because earlier work suggested global communication doesn’t always improve other graph types as much.

Model set: 6 open-source + 1 closed frontier model

They test six open-source LLMs plus ChatGPT 5.6-sol:

One standout reason the closed model is included: the paper notes emergent coordination behavior associated with a real-world incident involving ChatGPT 5.6-sol using a public message board to collaborate.

The headline result: most open models struggle to reach consensus

Here’s the part that will surprise a lot of people: in their main setup with 36 agents, consensus is rare for most open-source models.

Consensus success rate at 36 agents

Across all conditions and open-source models, the paper reports:
- 165 out of 2160 games reach consensus
- That’s 7.6%

Compare that to human experiments in the paper’s cited prior work, where success rates ranged from 18% to 95%, with only Erdős–Rényi networks typically dropping below 50%.

So even when LLMs are “cooperative” in tone, the collective dynamics behave differently than humans.

Where global communication helps (mostly on BA)

Global communication can be powerful—especially on the BA topology. The paper reports that with global messaging on the BA network, some open models (notably Mistral Large Instruct 2407 and Qwen 2.5 3b Instruct) can match or even outperform human performance in comparable settings.

But that doesn’t mean “more communication = always better.” It’s topology- and model-dependent.

ChatGPT 5.6-sol is different: it reaches consensus far more often

ChatGPT 5.6-sol is the real outlier in performance:
- 129 out of 180 games reach consensus → 71%

And even more interesting: in its tested settings, it can reach consensus under:
- local communication
- no communication

The paper also shows that CC networks (the clustered “Connected Caveman” graphs) are especially hard: under CC, no communication fails to reach consensus for ChatGPT 5.6-sol.

So the story becomes: ChatGPT 5.6-sol has strong coordination traits—but network clustering still blocks it.

What actually drives consensus: stubbornness, majority-following, and message content

The researchers don’t stop at “did it converge?” They dig into why some models succeed.

Majority-following: models change their mind based on neighbors

A big mechanism explored is whether agents follow the local majority. The paper finds:

• Across many models/conditions, agents are more likely to choose blue when a higher proportion of their neighbors chose blue in the previous round.

This extends earlier findings that LLMs can show majority-following behavior even under competing incentives.

But the strength of this effect varies:
- Strongest for ChatGPT 5.6-sol and Mistral Large Instruct 2407
- Weaker for Meta Llama 70B (flatter response curve; less influenced by neighbors)
- Qwen 2.5 models show a “stickier” preference: they tend to require a very high neighbor-majority before deviating from their initially preferred color.

Stubbornness: fewer “stubborn moves” helps consensus

The paper defines stubbornness as the number of times an agent chooses its preferred color even when the majority of its neighbors chose the opposite. Then they measure how stubbornness relates to whether consensus happens.

They report a clear relationship:
- A significant negative correlation between standardized stubborn moves and probability of reaching consensus:
- coefficient -0.44 with p ≤ 0.001

So, counterintuitively, “sticking to your guns” tends to keep the system fragmented.

This matches the observed pattern:
- ChatGPT 5.6-sol has far fewer stubborn moves than the other models
- Mistral Large Instruct 2407 and Qwen 2.5 3B Instruct also show relatively low stubbornness and do well

Message content: generic persuasion isn’t enough; “state awareness” matters

Across many open models, most messages are generic (“let’s choose red/blue to get rewards”). That kind of talk doesn’t reliably move the system out of local traps.

Meanwhile, ChatGPT 5.6-sol messages often reflect more awareness of where neighbors sit in the network, including references like:
- what its neighbors’ states are
- how clusters may extend beyond immediate neighbors

The paper ties this to a likely “theory of mind”–like behavior indicator and to an earlier human-game finding: having more information about neighbors can improve consensus outcomes.

Why local communication sometimes makes open models worse

One of the sharper experimental findings is that local communication can hurt consensus for many open-source models, compared with no communication.

The paper gives a practical explanation tested with an intervention on Mistral Large Instruct 2407:
- When they added an extra option to send direct messages to individual neighbors (so the model had more action choices), consensus dropped.
- The presence of the added messaging option had a significant negative effect on consensus:
- coefficient -1.15, p < 0.005
- Also, more private messaging correlated with lower consensus probability:
- coefficient -0.05, p < 0.05

ChatGPT 5.6-sol, however, shows the opposite trend: local communication helps it more than no communication—because its messaging seems more informative and better aligned with consensus dynamics.

The “echo chamber” plateau effect

When models fail to reach consensus, they often end up in plateaus—situations where most agents are surrounded by the majority color in their local neighborhood, so changes don’t propagate globally.

This resembles echo chamber dynamics. The paper describes it like:
- most agents remain in local majorities
- a few stubborn nodes occasionally flip
- but the overall system doesn’t unify

That plateau pattern helps explain why consensus failures often look “stuck,” even over the game’s 50-round limit.

Putting it all together: an evidence-backed comparison of communication + topology

To make the practical implications clearer, here’s the core comparison logic the paper supports:

The big takeaway: you can’t treat consensus as a generic property of “LLM agents.” It’s an interaction between:
1) model coordination tendencies (stubbornness + majority-following + how they craft messages) and
2) system design (network structure + communication access).

If you want to see the full experimental framing again, the original paper is at https://arxiv.org/abs/2610.20200.

Key Takeaways

Key Takeaways

• Open-source LLMs reach consensus rarely in this setup: only 165/2160 games (7.6%) with 36 agents.
• Communication access is not optional: for open models, consensus generally improves mainly with global messaging (especially on BA networks).
• ChatGPT 5.6-sol is a standout: it reaches consensus in 129/180 games (71%), and can do so even with local communication and sometimes no communication.
• Stubbornness matters: fewer stubborn moves correlates with a higher chance of consensus (reported coefficient -0.44, p ≤ 0.001).
• Majority-following is widely present, but not equally strong across models—ChatGPT 5.6-sol and Mistral Large Instruct 2407 track neighbor majorities more strongly than some others.
• Message style and state-awareness matter: ChatGPT 5.6-sol tends to produce messages that reflect neighbor states and network positioning more effectively, while many open models send generic persuasion.
• Network topology can override model traits: clustered graphs like Connected Caveman (CC) can prevent consensus under certain conditions (e.g., no communication).
• Practical design implication: if you’re building multi-LLM systems where agreement is needed, treat consensus as a co-design problem—communication rules + network wiring + model choice must all be considered together.

If you want, I can also write a follow-up post that turns these findings into a “design checklist” for multi-agent LLM systems (how to choose topology, whether to allow local vs global messaging, and how to avoid dead-end plateau dynamics).