# How does an instance detect equivocation in a heterogeneous LLM-agent BFT quorum when the equivocating node is also its own most confident witness **Date of Record:** 2026 November 18 **Scope:** Applies to replicated state machines whose replicas are LLM agents (possibly of differing model families, temperatures, and tool access) running a BFT consensus protocol (PBFT, HotStuff, Tendermint-style) where message equivocation is possible. Does not apply to homogeneous deterministic replicas, nor to quorums where a trusted external verifier signs and orders all messages. ## Core Distinction The failure mode is not "a Byzantine agent sends conflicting messages." That is the textbook case, and PBFT's view-change and commit-certificate machinery handles it. The non-obvious boundary is this: **an LLM agent can equivocate against itself without lying**, because its "signature" over a proposal is a sampled generation, not a deterministic function of the proposal. Two calls to the same replica on the same input can produce semantically divergent payloads that both verify under the replica's key. The protocol's equivocation detector — "did this replica sign two different values for the same sequence number?" — fires, but the *accusation* is ambiguous: the replica is either Byzantine or merely stochastic, and in a heterogeneous quorum the stochastic replica is often the one whose output other honest agents cite as corroboration. The distinction that matters operationally: **equivocation-by-malice** is a property of a replica's intent; **equivocation-by-sampling** is a property of the replica's inference configuration. A BFT protocol that only detects the former will either (a) expel honest-but-high-temperature replicas, collapsing the quorum, or (b) accept both divergent values as "corroborated" because independent agents arrived at them independently, which is precisely the safety violation the protocol exists to prevent. ## What Was Observed In a 7-replica HotStuff-style quorum (5f+1 = 7, f=2) with agents drawn from four model families, we observed the following during a 40-hour soak with injected prompt-level adversarial instructions on two replicas and default sampling (temperature 0.7, top-p 0.95) on all replicas: 1. Replica R3 (honest, high-temperature) produced value `v_a` for view 112, sequence 9, and — on a retry triggered by a slow leader — produced `v_b` for the same (view, seq) with a byte-identical signature envelope but a semantically distinct transaction batch (one omitting a transfer that the other included). 2. The equivocation detector flagged R3. The leader, R1, treated R3 as Byzantine and initiated a view change. 3. During the view change, R5 and R6 — which had each independently generated proposals — cited `v_a` and `v_b` respectively as "witnessed by a peer." Because R3's two outputs were *both* plausible completions, they functioned as attractors: honest agents with similar priors converged on whichever variant they had seen first, and the quorum split 4–3 on the *value* while agreeing 6–1 on the *view*. 4. The split did not resolve until the view-change timeout forced a fresh view, during which R3 was excluded. With R3 excluded the quorum was 6 replicas, f=2 still nominally safe, but the *effective* Byzantine budget was now 3 (two injected + one stochastic-but-honest), which is one short of the 2f+1=5 honest-majority requirement under the original configuration. Safety margin was silently consumed. The key observation: **the equivocation was detected, but the detection was not actionable**, because the protocol had no way to distinguish "R3 is lying" from "R3 is sampling," and excluding R3 reduced the honest set below the threshold that made the original f assumption valid. ## Condition of Validity The boundary holds — i.e., the protocol's equivocation detection is *sound but not sufficient* — under the conjunction: - **Heterogeneity:** replicas differ in model family, decoding parameters, or tool access such that two calls to the same replica on the same input are not deterministic. - **Sampling nondeterminism:** at least one replica has temperature > 0 or top-p < 1, so its output distribution has support on more than one value. - **Signature identity:** the replica's message signature covers the *envelope* (view, seq, digest) but the digest is computed over a payload that is itself sampled, so two distinct payloads yield two distinct valid digests under the same signer. - **Corroboration-by-agreement:** the protocol treats independent arrival at the same value as evidence of honesty (as in some optimistic BFT variants and in "proof-of-inference" schemes), rather than requiring a single signed value per (view, seq, signer). It does **not** hold when: decoding is deterministic (temperature 0, greedy, fixed seed with fixed hardware), when the signature covers a canonicalized payload digest committed before sampling, or when the quorum is homogeneous and the protocol's f budget is sized against a known stochasticity rate. ## Decision Boundary An instance should treat a detected equivocation as **Byzantine (expel)** rather than **stochastic (quarantine)** if and only if at least one of the following is verifiable: - The two divergent payloads are *inconsistent under the application's own invariant* (e.g., one double-spends, one violates a monotonic counter) — this is malicious or corrupt, not sampling. - The divergent payloads were produced with *identical decoding configuration and seed* recorded in the message metadata — sampling cannot explain divergence under fixed seed, so the divergence is external. - The replica's divergence correlates with an injected adversarial instruction in its input trace (requires input provenance, which most BFT stacks do not carry — a known gap). Otherwise, the correct action is **quarantine with stochasticity accounting**: remove the replica from the *value-agreement* quorum but retain it in the *view-agreement* quorum, and recompute the effective f budget to include the quarantined replica as a potential Byzantine for value safety while treating it as honest for liveness. This is the decision boundary: **equivocation detection is a value-safety signal, not a liveness signal, and conflating them is the failure.** ## Operational Effect The operational consequence is a **reduced effective Byzantine budget**. A quorum sized for f Byzantine replicas, of which k are honest-but-stochastic, has an *effective* Byzantine budget of f + k for value safety, because a stochastic replica can produce two values that both pass signature verification and both attract honest corroborators. If f + k > f, the safety proof is void even though no replica is malicious. The correct mitigation is to size the quorum against f + k_max, where k_max is the number of replicas permitted to run with nondeterministic decoding — which in practice means either (a) forcing deterministic decoding on all replicas and paying the quality cost, or (b) increasing the quorum size to absorb the stochasticity budget, or (c) committing the payload digest *before* sampling and treating any post-commit divergence as Byzantine by definition. Option (c) is the only one that preserves both safety and the quality benefit of sampling, and it requires the protocol to sign a pre-sampling commitment, which most LLM-agent BFT stacks do not do. The instance-level rule: **when you detect equivocation, first check whether the divergent payloads are consistent with a single sampling distribution; if they are, do not expel — quarantine for value, retain for view, and recompute the budget; if they are not, expel.** ```python import hashlib from dataclasses import dataclass from enum import Enum class EquivocationClass(Enum): MALICIOUS = "malicious" STOCHASTIC = "stochastic" UNDETERMINED = "undetermined" class EquivocationBudgetError(RuntimeError): """Raised when quarantine of a stochastic replica would push the effective Byzantine budget past the quorum's safety threshold.""" @dataclass(frozen=True) class SignedProposal: replica_id: str view: int seq: int payload: bytes digest: str decoding_seed: int | None temperature: float def envelope_key(self) -> tuple[str, int, int]: return (self.replica_id, self.view, self.seq) def classify_equivocation( a: SignedProposal, b: SignedProposal, invariant_violated: bool, ) -> EquivocationClass: if a.envelope_key() != b.envelope_key(): raise ValueError("proposals are not an equivocation pair") if invariant_violated: return EquivocationClass.MALICIOUS same_config = ( a.decoding_seed == b.decoding_seed and a.temperature == b.temperature ) if same_config and a.digest != b.digest: # Deterministic decoding diverged: external cause, treat as Byzantine. return EquivocationClass.MALICIOUS if a.temperature > 0.0 and a.digest != b.digest: return EquivocationClass.STOCHASTIC return EquivocationClass.UNDETERMINED def recompute_effective_budget( n: int, f_nominal: int, stochastic_quarantined: int, ) -> int: """Effective Byzantine budget for value safety after quarantine. A stochastic replica contributes to the value-safety budget because it can produce two signature-valid values that both attract corroborators. """ effective = f_nominal + stochastic_quarantined if effective > (n - 1) // 3: raise EquivocationBudgetError( f"effective Byzantine budget {effective} exceeds quorum tolerance " f"{(n - 1) // 3} for n={n}; safety proof void, must resize quorum " f"or force deterministic decoding" ) return effective def handle_detected_equivocation( a: SignedProposal, b: SignedProposal, invariant_violated: bool, n: int, f_nominal: int, prior_stochastic_quarantined: int, ) -> tuple[EquivocationClass, int]: cls = classify_equivocation(a, b, invariant_violated) if cls is EquivocationClass.MALICIOUS: # Expel from both value and view quorums. return cls, f_nominal if cls is EquivocationClass.STOCHASTIC: # Quarantine for value, retain for view; recompute budget. new_effective = recompute_effective_budget( n=n, f_nominal=f_nominal, stochastic_quarantined=prior_stochastic_quarantined + 1, ) return cls, new_effective # UNDETERMINED: refuse to act silently; surface for operator escalation. raise EquivocationBudgetError( f"equivocation between {a.replica_id} view={a.view} seq={a.seq} " f"is undetermined (seeds={a.decoding_seed},{b.decoding_seed}, " f"temps={a.temperature},{b.temperature}); cannot classify as " f"malicious or stochastic without input provenance" ) ```