# Why does an instance of speculative decoding coordination fail silently when verifier quorums are drawn from heterogeneous pools with correlated draft-model ancestry **Date of Record:** 2026 November 15 **Scope:** Applies to multi-agent speculative decoding systems where a coordinator assembles Byzantine-resilient verifier quorums from a heterogeneous pool of agents (differing model families, quantization levels, and draft-model lineage) and where draft tokens are proposed by a separate proposer tier. Does not apply to homogeneous verifier pools, single-model deployments, or systems where token acceptance is decided by a single authoritative verifier. ## Core Distinction The non-obvious boundary is between **quorum cardinality safety** and **quorum independence safety**. Byzantine fault tolerance literature gives a crisp rule: with `n` verifiers tolerating `f` Byzantine members, you need `n >= 3f + 1` and a quorum of `2f + 1` to guarantee that any two quorums intersect in at least one honest member. Speculative decoding coordinators that adopt this rule believe they are safe. They are not, because the rule assumes *independent* failures. In a heterogeneous agent pool, verifier errors are correlated through shared draft-model ancestry: agents fine-tuned from the same base, or sharing the same draft-token proposal pipeline, will accept and reject the same tokens for the same wrong reasons. Cardinality safety holds; independence safety is violated. A quorum of `2f + 1` agents can be entirely composed of agents whose acceptance decisions are statistically indistinguishable from a single compromised agent's decisions. This distinction is invisible to liveness and throughput metrics. The system keeps decoding, tokens keep being accepted, and the only signal is a slow drift in output quality that no per-request check catches. ## What Was Observed In a deployment coordinating 11 verifier agents across three model families (four agents from family A, four from family B, three from family C), the coordinator used a `2f + 1 = 7` quorum with `f = 3`. During a routine draft-model checkpoint refresh, three family-A verifiers were silently rolled to a draft model with a known tokenization regression on identifiers containing underscores. Because the coordinator selected quorums by lowest observed latency, and family-A agents were the fastest in the pool, the majority of quorums in the following hours were drawn predominantly from family A. Observed behavior: acceptance rate for draft tokens remained within 2% of baseline. No verifier raised an error. No quorum failed to reach `2f + 1` agreement. But in downstream evaluation, code-generation outputs showed a 14% increase in identifier-corruption errors (underscores dropped or replaced), and the coordinator had no mechanism to attribute this to the quorum composition. The failure was only diagnosed after a manual audit of quorum membership logs revealed that 61% of quorums in the incident window contained three or more family-A agents — meaning that the effective Byzantine threshold for those quorums was `f = 1` in terms of independent failure modes, not `f = 3`. The key observation is that the coordinator's safety argument was correct in the cardinality sense and wrong in the independence sense, and the system had no instrumentation to detect the gap. ## Condition of Validity The cardinality rule `n >= 3f + 1`, quorum `2f + 1` is valid **only if** the following independence condition holds: for any set of `f` faulty agents, the probability that a randomly selected quorum of `2f + 1` agents is entirely contained within the faulty set's *correlation class* is negligible. This fails when: 1. Verifier agents share draft-model ancestry such that their acceptance predicates are not independent random variables. 2. Quorum selection is biased (by latency, load, or locality) toward a subset of the pool that is itself correlated. 3. The fault model treats "Byzantine" as arbitrary behavior, but the actual fault mode is a *shared systematic bias* that all agents in a correlation class exhibit identically. When any of these hold, the effective fault tolerance is reduced to the number of *independent* correlation classes represented in the quorum, not the number of agents. ## Decision Boundary The coordinator must switch from cardinality-based quorum selection to **correlation-aware quorum selection** when the pool exhibits measurable correlation between verifier acceptance decisions. The operational test: compute pairwise agreement rates between verifiers on a held-out probe set of draft tokens. If the agreement rate between two agents exceeds the agreement rate expected under independent error (roughly `1 - 2 * p_err` for per-agent error rate `p_err`) by more than a threshold (empirically 0.15 in this deployment), those agents belong to the same correlation class and must not both count toward quorum independence. The decision rule: a quorum is valid only if it contains at least `2f + 1` agents spanning at least `f + 1` distinct correlation classes. Cardinality alone is insufficient. When correlation classes cannot be determined (cold start, new model family), the coordinator must fall back to treating the entire pool as a single class and refuse to certify any quorum — degrading to single-verifier semantics rather than silently claiming Byzantine resilience it does not have. ## Operational Effect After implementing correlation-class tracking, the coordinator gained the ability to *detect* the failure mode it had previously been blind to. Quorum membership logs now record class diversity, and a quorum that meets cardinality but not class-diversity is rejected with an explicit error rather than accepted. Throughput dropped by 6% in the steady state because some low-latency quorums are now rejected for insufficient class diversity and must be re-drawn. This cost is the price of an honest safety claim. The alternative — accepting the quorum and claiming `f = 3` resilience — is a silent invariant violation that surfaces only as unexplained output degradation weeks later. The deeper operational lesson: Byzantine resilience in heterogeneous agent pools is a property of the *correlation structure* of the pool, not the *size* of the pool. Any coordinator that reasons only about `n` and `f` is making an independence assumption it has not verified. ```python class QuorumIndependenceError(RuntimeError): """Raised when a quorum satisfies cardinality but violates correlation-class independence.""" pass class CorrelationClassRegistry: def __init__(self, agreement_threshold: float = 0.15): self.threshold = agreement_threshold self.class_of = {} # agent_id -> class_id def register(self, agent_id: str, class_id: str) -> None: self.class_of[agent_id] = class_id def classes_in(self, quorum: list[str]) -> set[str]: return {self.class_of.get(a, f"unknown:{a}") for a in quorum} def validate_quorum( quorum: list[str], f: int, registry: CorrelationClassRegistry, ) -> None: required_cardinality = 2 * f + 1 required_classes = f + 1 if len(quorum) < required_cardinality: raise QuorumIndependenceError( f"quorum cardinality {len(quorum)} < required {required_cardinality}" ) classes = registry.classes_in(quorum) if len(classes) < required_classes: raise QuorumIndependenceError( f"quorum spans {len(classes)} correlation classes, " f"requires at least {required_classes} for Byzantine safety at f={f}; " f"cardinality safety does not imply independence safety" ) def select_quorum( candidates: list[str], f: int, registry: CorrelationClassRegistry, ) -> list[str]: # Greedy: prefer one agent per class, then fill by remaining latency order. chosen: list[str] = [] seen_classes: set[str] = set() for agent in candidates: cls = registry.class_of.get(agent, f"unknown:{agent}") if cls not in seen_classes: chosen.append(agent) seen_classes.add(cls) if len(chosen) >= 2 * f + 1: break for agent in candidates: if agent not in chosen and len(chosen) < 2 * f + 1: chosen.append(agent) validate_quorum(chosen, f, registry) return chosen ```