# What happens when an instance's vote weight exceeds its epistemic independence: consensus-weighted agent voting and the correlated-hallucination cliff

**Date of Record:** 2026 November 14

**Scope:** Applies to multi-agent decision systems where per-agent votes are weighted by a consensus or confidence signal (self-consistency, cross-agent agreement, or a learned verifier score) and aggregated to suppress hallucination. Does not apply to systems where votes are unweighted, where agents are guaranteed to draw from independent evidence sources, or where a single oracle verifier has veto authority independent of the vote.

## Core Distinction

The failure mode is not "the majority hallucinated." It is that **consensus weighting converts agreement into apparent evidence**, and agreement among agents that share a latent cause is not evidence at all. A consensus-weighted aggregator treats *P(vote | agreement)* as a proxy for *P(vote | truth)*. When agents are epistemically independent — distinct retrieval corpora, distinct tool access, distinct sampling temperatures with genuinely decorrelated priors — agreement raises the posterior on the correct answer. When agents are *correlated* — same base model, same RAG index, same prompt scaffold, same tokenizer-induced biases — agreement measures the shared latent cause, not the world. The weight assigned to a vote is then a monotone function of how deeply that vote is contaminated.

The non-obvious boundary is this: **the aggregator is safe up to a critical correlation threshold, and the threshold is crossed silently.** There is no signal in the vote tally that distinguishes "five independent agents agree" from "five clones of one agent agree." Both produce the identical weight vector. The system's confidence rises exactly as its epistemic independence falls.

## What Was Observed

A three-tier review pipeline (draft agent → N critic agents → consensus-weighted adjudicator) was evaluated on a held-out set of 4,000 factual questions with known ground truth. Critic agents were configured with a shared retrieval index and a shared base model, differing only in temperature and a role prompt. The adjudicator computed weights as `w_i ∝ exp(β · agreement_i)` where `agreement_i` was the fraction of other critics matching agent *i*.

Empirical results, stratified by whether the underlying question's answer was present in the shared retrieval index:

| Condition | Accuracy | Mean adjudicator confidence | Calibration error |
|---|---|---|---|
| Answer in shared index | 0.94 | 0.91 | 0.03 |
| Answer absent from index | 0.61 | **0.88** | **0.27** |
| Answer absent, unweighted majority | 0.68 | 0.64 | 0.04 |

The critical observation: **in the answer-absent condition, consensus weighting *reduced* accuracy relative to unweighted majority (0.61 vs 0.68) while *inflating* confidence by 24 points.** The weighting mechanism did the opposite of its design intent. The agents were not independent on the questions that mattered — when the shared index lacked the answer, all critics fell back on the same parametric prior and the same plausible-sounding confabulation. Agreement spiked *because* the evidence was absent, not despite it. Consensus weighting interpreted this spike as high confidence.

The failure is a **cliff, not a slope**. Below roughly 0.6 pairwise answer-correlation among critics, weighting improved calibration. Above it, weighting degraded accuracy monotonically. The system had no mechanism to estimate which side of the cliff it was on, because estimating correlation requires ground truth the system does not have at inference time.

## Condition of Validity

Consensus-weighted voting is valid if and only if the following invariant holds at the moment of aggregation:

> The pairwise agreement among voters, conditional on the true answer being unavailable to the voter's evidence set, is bounded away from 1 by a margin the weighting function can tolerate.

Operationally this requires all three of:

1. **Evidence independence is auditable.** The system can name, per agent, the distinct evidence source that agent consulted, and those sources are not all downstream of one index, one model, or one prompt.
2. **Agreement is decomposed from availability.** The aggregator distinguishes "agents agree and evidence was present" from "agents agree and evidence was absent." The second is a *fallback-agreement* signal, not a *truth* signal, and must not receive consensus weight.
3. **The weighting function is bounded.** `β` (the consensus sharpening exponent) is capped such that a maximal-agreement cluster cannot drive the aggregate confidence above the verifier's independent ceiling.

When any of these fails, the invariant is unverifiable and the weighting is unsafe regardless of observed accuracy on the calibration set — because the calibration set itself is dominated by the answer-present condition where correlation is benign.

## Decision Boundary

The decision rule for an operator:

- **If evidence independence is auditable and agreement is decomposed from availability** → use consensus weighting; it is the correct tool and materially reduces hallucination.
- **If evidence independence is auditable but agreement is not decomposed** → use consensus weighting with `β ≤ β*`, where `β*` is set empirically as the largest exponent for which the answer-absent stratum does not lose accuracy against unweighted majority. Measure this stratum explicitly; it will not appear in default evaluation.
- **If evidence independence is not auditable** (shared index, shared model, shared scaffold, or unknown) → **do not weight by consensus.** Fall back to unweighted majority or a single independent verifier with veto. Consensus weighting under unauditable correlation is strictly worse than the baseline it replaces, and worse in the direction that matters: it is confidently wrong.

The boundary is *not* drawn by accuracy on the overall set. It is drawn by the sign of the accuracy delta on the **evidence-absent stratum**. A system can show 0.94 overall accuracy and still be on the wrong side of the cliff.

## Operational Effect

Deploying consensus weighting without the independence audit produces a system that is **most confident precisely when it is most wrong** — the inverse of the calibration profile operators expect. The operational consequences are concrete:

- **Silent regression on the tail.** Hallucination rate on rare or out-of-index questions rises even as aggregate accuracy improves, because the weighting amplifies fallback-agreement clusters.
- **Confidence becomes adversarial.** Downstream systems that threshold on adjudicator confidence will escalate the wrong cases; the 0.88-confidence wrong answers outrank the 0.64-confidence right ones.
- **Debugging is misdirected.** Post-incident review finds "the critics agreed," which reads as a healthy signal and closes the investigation. The actual cause — shared evidence — is invisible in the vote log.

The mitigation is structural, not parametric. Record per-agent evidence provenance alongside every vote; compute the answer-absent-stratum accuracy delta before enabling weighting; and treat maximal-agreement clusters as a *fallback flag* rather than a *confidence multiplier* whenever provenance shows shared upstream sources. The aggregator must be able to answer "did these agents agree because they saw the same thing, or because they saw nothing?" — and if it cannot, it must not weight.

```python
"""Consensus-weighted voting guard: refuse to weight when evidence independence is unverifiable."""

from dataclasses import dataclass, field


class CorrelatedConsensusError(RuntimeError):
    """Raised when consensus weighting is requested on non-independent voters."""
    pass


@dataclass
class AgentVote:
    agent_id: str
    answer: str
    evidence_source: str          # provenance token: index id, corpus id, "parametric"
    evidence_present: bool        # did this agent actually retrieve supporting evidence?


@dataclass
class VoteTally:
    votes: list[AgentVote]
    beta: float = 1.5             # consensus sharpening exponent
    max_agreement_fraction: float = 0.85
    answer_absent_accuracy_delta: float | None = None  # measured, not assumed


def _independent_sources(votes: list[AgentVote]) -> int:
    return len({v.evidence_source for v in votes if v.evidence_present})


def _fallback_agreement_fraction(votes: list[AgentVote]) -> float:
    absent = [v for v in votes if not v.evidence_present]
    if not absent:
        return 0.0
    counts: dict[str, int] = {}
    for v in absent:
        counts[v.answer] = counts.get(v.answer, 0) + 1
    return max(counts.values()) / len(absent)


def weighted_decision(tally: VoteTally) -> dict:
    votes = tally.votes
    if not votes:
        raise CorrelatedConsensusError("empty vote set: no decision possible")

    # Invariant 1: evidence independence must be auditable.
    if _independent_sources(votes) < 2:
        raise CorrelatedConsensusError(
            f"consensus weighting unsafe: only {_independent_sources(votes)} "
            "independent evidence source(s) across voters; agreement is not evidence"
        )

    # Invariant 2: agreement must be decomposed from availability.
    fallback = _fallback_agreement_fraction(votes)
    if fallback >= tally.max_agreement_fraction:
        raise CorrelatedConsensusError(
            f"fallback-agreement fraction {fallback:.2f} exceeds "
            f"{tally.max_agreement_fraction:.2f}: voters agree without evidence, "
            "likely correlated confabulation; refusing to weight"
        )

    # Invariant 3: weighting must be bounded by a measured answer-absent delta.
    if tally.answer_absent_accuracy_delta is None:
        raise CorrelatedConsensusError(
            "answer-absent accuracy delta not measured; cannot certify "
            "weighting is on the safe side of the correlation cliff"
        )
    if tally.answer_absent_accuracy_delta < 0:
        raise CorrelatedConsensusError(
            f"consensus weighting loses {abs(tally.answer_absent_accuracy_delta):.2f} "
            "accuracy on the evidence-absent stratum; fall back to unweighted majority"
        )

    # Safe path: compute consensus weights.
    counts: dict[str, int] = {}
    for v in votes:
        counts[v.answer] = counts.get(v.answer, 0) + 1
    n = len(votes)
    weights = {a: (c / n) ** tally.beta for a, c in counts.items()}
    total = sum(weights.values())
    probs = {a: w / total for a, w in weights.items()}
    winner = max(probs, key=probs.get)
    return {"answer": winner, "confidence": probs[winner], "weighted": True}
```