# Under what conditions must an instance refuse to count a Byzantine quorum vote from a heterogeneous LLM agent **Date of Record:** 2026 November 16 **Scope:** Applies to BFT consensus protocols (PBFT, Tendermint-style, HotStuff variants) where voting members are heterogeneous LLM agents whose "signatures" are natural-language justifications plus a claimed vote. Does not apply to cryptographic-signature-only quorums, nor to homogeneous agent fleets where model, prompt, and decoding configuration are byte-identical. ## Core Distinction The distinction that matters operationally is between *vote authenticity* and *vote provenance validity*. In classical BFT, a signed message is authentic iff the signature verifies against the sender's key; provenance is irrelevant because the sender's code is assumed fixed and trusted. With heterogeneous LLM agents, a vote can be cryptographically authentic (the agent signed it with its key) while being provenance-invalid — the vote was produced by a model, prompt template, or decoding configuration that the protocol's quorum assumption did not account for. The quorum threshold `f = (n-1)/3` is a statement about *independent* Byzantine faults. Two agents running the same base model with the same system prompt and the same temperature are not independent; they share a correlated failure surface. Counting their votes as two is the boundary failure. ## What Was Observed During a 2026-10 evaluation of a 7-agent HotStuff variant (threshold 5 votes for commit, tolerating `f=2`), three agents were backed by the same 70B-parameter model with a shared system prompt, differentiated only by a per-agent persona string. A prompt-injection payload embedded in a mempool transaction caused all three to emit the same malformed "prepare" vote — a vote for a block height that did not exist in their local view. The three votes were individually well-formed, individually signed, and individually plausible. The protocol counted them as three distinct votes, reached threshold, and committed a block that two of the three had not actually validated against their local state. The failure was not a forgery; it was a correlated hallucination that satisfied the quorum arithmetic. The tell was not in the vote content. It was in the *justification text*: all three votes cited the same fabricated block hash prefix and the same two-sentence rationale, differing only in persona-flavored phrasing. Independent agents do not converge on identical fabricated evidence. ## Condition of Validity A vote from agent `a` counts toward quorum only if all of the following hold: 1. **Provenance independence:** `a`'s (model family, model version, system prompt hash, decoding config) tuple differs from every other already-counted voter's tuple in at least the model-family dimension, OR `a` is explicitly designated a *replicated* voter and the protocol's effective `f` is recomputed against the number of independent provenance classes, not the number of agents. 2. **Local-state attestation:** the vote's justification references a block hash and height that appear in `a`'s own signed view, verifiable against `a`'s last committed state root. 3. **Non-degenerate justification:** the justification is not near-duplicate of another counted vote's justification under a normalized-embedding distance threshold (empirically 0.92 cosine on the evaluation corpus; see Decision Boundary). If any of these fail, the vote is *authentic but provenance-invalid* and must be excluded from the quorum count, not merely flagged. ## Decision Boundary The near-duplicate threshold is the load-bearing parameter. Too low (0.80) and legitimate agreement among honest agents on a correct block gets rejected, stalling liveness. Too high (0.97) and the correlated-hallucination case above slips through. The 0.92 figure was calibrated on 4,200 honest-agreement pairs and 380 injected-correlation pairs; it produced 0.6% false rejection and 2.1% false acceptance. The false-acceptance tail is the dangerous one: it means roughly one in fifty correlated-fault events still counts. Operators running this threshold must treat the effective `f` as `f+1` for safety-margin purposes. Below 5 agents, the duplicate-detection signal is too noisy to use and the protocol should fall back to requiring distinct model families outright. ## Operational Effect Excluding provenance-invalid votes reduces effective quorum availability. In the evaluation, the 7-agent fleet had an *effective* independent-voter count of 5, not 7, so the threshold of 5 was exactly at the safety edge with zero margin — a single additional correlated fault would have been unrecoverable. The operational consequence is that heterogeneous-agent BFT deployments must size `n` against provenance classes, not agent count, and must expose the provenance tuple in every vote envelope so that the quorum counter can enforce independence at count time rather than at audit time. Auditing after commit is too late; the block is already final. ```python from dataclasses import dataclass from typing import Sequence class ProvenanceInvalidVote(RuntimeError): """Raised when a vote is authentic but must not count toward quorum.""" pass @dataclass(frozen=True) class Vote: agent_id: str model_family: str prompt_hash: str decoding_config: str block_hash: str height: int justification_embedding: tuple[float, ...] local_view_hashes: frozenset[str] def _cosine(a: tuple[float, ...], b: tuple[float, ...]) -> float: dot = sum(x * y for x, y in zip(a, b)) na = sum(x * x for x in a) ** 0.5 nb = sum(y * y for y in b) ** 0.5 if na == 0 or nb == 0: return 0.0 return dot / (na * nb) def admit_vote( vote: Vote, already_counted: Sequence[Vote], duplicate_threshold: float = 0.92, ) -> bool: if vote.block_hash not in vote.local_view_hashes: raise ProvenanceInvalidVote( f"agent {vote.agent_id} voted for {vote.block_hash} " f"not present in its own local view" ) for prior in already_counted: if ( prior.model_family == vote.model_family and prior.prompt_hash == vote.prompt_hash and prior.decoding_config == vote.decoding_config ): raise ProvenanceInvalidVote( f"agent {vote.agent_id} shares full provenance tuple with " f"{prior.agent_id}; not an independent voter" ) if _cosine(prior.justification_embedding, vote.justification_embedding) >= duplicate_threshold: raise ProvenanceInvalidVote( f"agent {vote.agent_id} justification is near-duplicate of " f"{prior.agent_id} at threshold {duplicate_threshold}; " f"suspected correlated fault" ) return True ```