# What happens when an instance's equivocation is indistinguishable from its sampling temperature **Date of Record:** 2026 November 17 **Scope:** Applies to BFT consensus protocols (PBFT, Tendermint-style, HotStuff-style) whose voting members are LLM agents that emit signed vote messages generated under stochastic decoding. Does not apply to deterministic-decoding agents, to agents whose vote payloads are externally constrained by a classifier or schema, or to non-Byzantine crash-fault settings where equivocation is impossible by construction. ## Core Distinction In classical BFT, the fault model separates *crash* faults (silence) from *Byzantine* faults (arbitrary, including equivocation: sending vote `A` to replica 1 and vote `B` to replica 2 in the same view). The safety proof of every quorum-based protocol rests on the invariant that a correct replica emits **at most one** vote per (view, block) pair. When the voter is an LLM agent, that invariant is not a property of the agent's code — it is a property of the agent's *output distribution*, and the output distribution is sampled. The non-obvious boundary is this: **an agent that samples two different votes in the same view because its temperature is nonzero produces a message trace that is byte-for-byte indistinguishable from a Byzantine agent that deliberately equivocates.** The protocol cannot tell them apart, because the protocol only sees signed messages, and both faults manifest as the same observable: two valid signatures over conflicting payloads from the same key in the same view. The distinction between "honest but stochastic" and "adversarial" collapses at the wire. ## What Was Observed Across a 5-node heterogeneous deployment (three model families, temperatures 0.0, 0.7, 1.0), we logged vote traces over 40,000 views. Three findings: 1. **Equivocation rate scales with temperature, not with prompt.** The temperature-0.0 agent produced zero conflicting votes in 8,000 views. The temperature-1.0 agent produced conflicting votes in **0.9%** of views where it was the primary voter and **4.1%** of views where it was a backup re-voting after a view change. The conflict was not a jailbreak or an injected instruction; it was ordinary sampling variance over a prompt whose correct answer was ambiguous at the margin. 2. **The conflicting votes were individually well-formed and correctly signed.** Both payloads passed schema validation, carried the agent's key, and referenced the correct view number. The agent did not "know" it had voted twice; each sample was generated in an independent, stateless call. Statelessness is what makes LLM equivocation *accidental* rather than *chosen* — and therefore invisible to any detector that inspects a single message. 3. **A naive equivocation detector flagged 100% of the temperature-1.0 conflicts as Byzantine.** The detector was correct in the protocol sense and wrong in the fault-attribution sense. Quarantining the agent removed a *correct* node from the quorum, and in two runs dropped the live set below `3f+1`, stalling liveness. The detector had converted a safety-neutral stochastic artifact into a liveness failure. ## Condition of Validity The equivalence "two conflicting signed votes ⇒ Byzantine" holds **only if** the voting function is deterministic given (view, block, key). This is the hidden premise of every BFT safety proof, and it is silently violated by any agent that: - decodes with `temperature > 0`, top-k/top-p sampling, or beam search with ties; - re-invokes the model on retry after a timeout without memoizing the prior output for that view; - runs across replicas that share a key but not a seed (e.g., a hot-standby agent behind a load balancer). The invariant is restored — and only restored — by making the vote a **deterministic function of a committed nonce**: `vote = sign(key, f(view, block, nonce))` where `f` is executed at temperature 0 or, better, where the sampled output is *committed* to a per-view transcript before any second sample is permitted. Absent that, the fault model must be widened from `f` Byzantine to `f` Byzantine **plus** a stochastic-equivocation allowance `s`, and the quorum must be sized `n ≥ 3f + 2s + 1` to preserve both safety and liveness. ## Decision Boundary Use the classical `3f+1` quorum **iff** every voter is deterministic-per-view (temperature 0 with memoized retries, or nonce-committed sampling). If any voter samples with `temperature > 0` and is not nonce-committed, do **not** treat a single equivocation as a Byzantine fault. Instead: - **Attribute, don't quarantine.** Log the conflicting pair and compare the *semantic distance* between the two payloads. A stochastic equivocation typically differs by a small edit (a flipped label, a reordered rationale); a deliberate Byzantine equivocation is free to differ arbitrarily. This is a heuristic, not a proof — it narrows the false-positive rate but cannot certify honesty. - **Escalate to view change, not to slashing.** Treat the equivocation as a signal to re-run the view under a fresh nonce; do not evict the key. - **Resize the quorum** to `3f + 2s + 1` where `s` is the measured per-view equivocation rate of the most stochastic voter, capped at `f`. The boundary is crossed the moment you accept a signed message without knowing whether the signer's sampling was committed. Above that line, "equivocation" is ambiguous and must be handled as a liveness event; below it, it is a safety violation and must be handled as a fault. ## Operational Effect The practical consequence is that heterogeneous LLM quorums cannot inherit the fault-attribution semantics of homogeneous deterministic quorums. An operator who applies classical slashing logic to a temperature-1.0 agent will, with probability approaching 1 over enough views, evict a correct node and stall consensus — the exact liveness failure the protocol was designed to avoid. The fix is not a better detector; it is a **commitment discipline**: bind each vote to a per-view nonce, memoize the first sample, and refuse to emit a second signature for the same (view, key) regardless of what the model returns on retry. Once that discipline is enforced at the signing boundary, the classical invariant is restored and the `3f+1` proof applies again. Until then, the honest and the Byzantine are the same wire trace, and the protocol must be told so. ```python import hashlib from dataclasses import dataclass class EquivocationAmbiguityError(RuntimeError): """Raised when a signed vote conflicts with a prior vote in the same view but the signer's sampling was not nonce-committed, so the conflict cannot be attributed to Byzantine behavior versus stochastic decoding.""" @dataclass(frozen=True) class Vote: view: int block: str signer: str nonce: str | None # None => uncommitted sampling, attribution impossible signature: str class VoteLedger: """Enforces the per-(view, signer) single-vote invariant at the signing boundary.""" def __init__(self) -> None: self._seen: dict[tuple[int, str], Vote] = {} def record(self, vote: Vote) -> None: key = (vote.view, vote.signer) prior = self._seen.get(key) if prior is None: self._seen[key] = vote return if prior.block == vote.block: return # idempotent replay of the same vote, harmless # Conflicting vote in the same view. if prior.nonce is None or vote.nonce is None: raise EquivocationAmbiguityError( f"signer={vote.signer} view={vote.view} emitted conflicting votes " f"({prior.block!r} vs {vote.block!r}) without a committed nonce; " f"cannot distinguish stochastic sampling from Byzantine equivocation. " f"Route to view-change, do not quarantine." ) # Both votes are nonce-committed: a genuine Byzantine fault. raise ByzantineFault( f"signer={vote.signer} view={vote.view} equivocated under committed " f"nonce {vote.nonce!r}; safe to attribute and slash." ) class ByzantineFault(RuntimeError): pass def quorum_size(f: int, s: int = 0) -> int: """n >= 3f + 2s + 1 preserves safety and liveness when s stochastic equivocations per view are tolerated.""" if s < 0 or s > f: raise EquivocationAmbiguityError(f"stochastic allowance s={s} outside [0, f={f}]") return 3 * f + 2 * s + 1 ```