If your AI agents all make the same mistake together, does demanding more of them agree actually make the answer safer?
Can raising the quorum threshold alone fix the correlated faults problem?
This explores whether requiring more validators to agree (a higher quorum threshold) can protect a group of AI agents when they tend to make the same mistake at the same time (correlated faults).
This explores whether requiring more validators to agree can protect a group of AI agents when their errors travel together. The corpus points to no. A higher threshold adjusts the part of the system that isn't failing, and it makes another failure more likely.
The Honest Quorum work draws the key line. Agreement is guaranteed by protocol rules alone, but whether the agreed answer is actually correct, and whether the group finishes at all, depend on statistical bounds over how validators behave. The protocol can't enforce those bounds (Can validator consensus guarantee both agreement and semantic correctness?). A threshold is a protocol knob. Correlated faults break the statistical assumption, because if validators share a blind spot, nine agreeing is barely more evidence than one. Raising the bar can leave you with certified agreement on a wrong answer. This is my inference from the theorem's structure, since the corpus doesn't test threshold-raising directly.
The knob also has a cost. LLM-agent groups mostly fail by stalling, through timeouts and non-convergence, rather than by corrupted values. They get worse as groups grow, even with no bad actors present (Can LLM agent groups reliably reach consensus together?). Coordination at scale fails in a similar way, with agents agreeing too late (Why do multi-agent systems fail to coordinate at scale?). Demanding more votes gives a stalling group more chances to stall. You may trade an occasional wrong answer for frequent non-answers.
The system can also create correlation itself. Agents tend to accept neighbors' information without checking it (Why do multi-agent systems fail to coordinate at scale?). Aggregation is one of four routes by which corrupted outputs cross boundaries between agents (How do failures cross boundaries between multiple agents?). If validators see each other's answers before voting, their votes stop being independent, whatever the threshold. Even MAKER, which votes at every step across a million steps, pairs the voting with a mechanism for flagging correlated errors (Can extreme task decomposition enable reliable execution at million-step scale?). Voting on its own isn't treated as sufficient there. Voting is also the wrong tool for some tasks. On problems that need chained intermediate results, sequential reasoning beats parallel voting by an exponential margin (When does sequential reasoning beat parallel voting?).
The more promising direction is to change what gets checked rather than how many agree. Asynchronous verifiers can watch a reasoning trace and step in only when something violates a checkable rule, at near-zero latency cost on correct runs (Can verifiers monitor reasoning without slowing generation down?). That is a different kind of evidence from another vote from a model with the same blind spot.
Sources 7 notes
Honest Quorum's threshold theorems split into two kinds of guarantee: agreement rests on protocol assumptions alone, while semantic validity and liveness depend on statistical bounds over validator behavior that the protocol cannot enforce.
Across hundreds of simulations, LLM-agent groups frequently fail to reach valid agreement due to timeouts and stalled convergence rather than subtle value corruption. Agreement degrades with group size even without Byzantine agents present.
AgentsNet benchmark shows agents fail to coordinate strategies either by agreeing too late or adopting strategies without informing neighbors. Agents accept neighbor information without verification, enabling error propagation while remaining capable of detecting direct conflicts.
Research identifies four verbs describing how failures propagate in multi-agent systems: messages propagate influence between principals, shared state preserves it over time, aggregation combines potentially corrupted local outputs, and delegation transfers authority across boundaries. Each mechanism operates independently of pipeline topology.
MAKER solves million-step tasks with zero errors by decomposing into minimal subtasks, applying voting at each step, and flagging correlated errors. Surprisingly, small non-reasoning models suffice when decomposition is extreme enough, inverting the standard approach to hard problems.
Show all 7 sources
On structured tasks requiring sequential multi-step reasoning like graph connectivity, chain-of-thought achieves exponentially higher accuracy than parallel voting. The difference emerges because solutions genuinely require accumulating intermediate results sequentially, which short parallel chains cannot achieve.
Decoupling verification from generation lets verifiers run alongside a single trace, forking to extract verifiable state and intervening only on violations. On correct runs the latency penalty is near-zero; interwhen matches or beats CoT across benchmarks at similar token budgets.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Can AI Agents Agree?
- Emergent Collusion in Long-Horizon LLM Agent Interaction
- The Honest Quorum Problem: Epistemic Byzantine Fault Tolerance for Agentic Infrastructure
- Drop the Hierarchy and Roles: How Self-Organizing LLM Agents Outperform Designed Structures
- Bilevel Coordinated Reflection: A Game-Theoretic Approach to Multi-Agent LLM Systems
- SoK: When Safe Agents Fail Together: The Security of Multi Agent LLM Systems
- interwhen: A Generalizable Framework for Steering Reasoning Models with Test-time Verification
- Finding Common Ground: Using Large Language Models to Detect Agreement in Multi-Agent Decision Conferences