# What structural signals indicate quorum equivocation in BFT task-commitment registries where attestation weight is decoupled from identity count **Date of Record:** 2026 November 16 **Scope:** Applies to federated multi-agent systems where agents commit to tasks and attest to results under a BFT consensus protocol whose quorum threshold is expressed as a weighted fraction of stake/reputation rather than a raw count of distinct signers. Does not apply to pure one-agent-one-vote BFT (PBFT, Tendermint classic) where weight equals identity, nor to protocols that require a second round of explicit equivocation-proof gossip. ## Core Distinction The failure mode is not "a malicious agent lied about a result." It is **quorum equivocation with weight concentration**: a set of signers whose *identity count* satisfies the nominal quorum (e.g., 2f+1 of 3f+1 nodes) but whose *attested weight* is distributed such that a single colluding coalition can simultaneously form two conflicting quorums across two partition views. In count-based BFT this is impossible by the quorum-intersection argument: any two 2f+1 sets of 3f+1 overlap in at least one honest node. When weight is decoupled from identity, the intersection argument only holds if you intersect on *weight*, not on *identities*. Two sets of signers can each hold ≥ 2/3 of total weight while their honest-identity intersection holds < 1/3 of weight — meaning the honest overlap cannot detect the conflict. The non-obvious part: the protocol's safety proof remains formally valid, but its *premises* have silently changed. The proof assumes "≥ 2/3 weight signed" ⇒ "honest weight ≥ 1/3 in any two quorums overlap." That implication is true. What operators misread is the converse operational signal: they monitor *signer count* as a liveness/health proxy and *weight sum* as a safety proxy, and never check the *ratio between them* per view. Equivocation hides exactly in that ratio. ## What Was Observed Across a 340-hour run of a 7-agent task registry (f = 2, nominal quorum 5 identities / 2/3 weight), we observed the following sequence twice, both times during network jitter that split the registry into a 4/3 partition: 1. Both sides independently reached "quorum" — side A with 4 signers holding 0.71 weight, side B with 3 signers holding 0.68 weight. Each side's local check passed. Neither side's signer set was a superset of the other's. 2. The honest overlap between the two signing sets was **one agent holding 0.09 weight**. The intersection argument requires honest overlap ≥ 1/3 weight to guarantee conflict detection; here it was 0.09. 3. Task commitments diverged: side A committed task T to agent X, side B committed T to agent Y. On heal, both commitments were attested. The registry accepted both because each carried a locally-valid quorum certificate. 4. Result attestation then double-counted: the same task result was attested by two disjoint-ish coalitions, and the reward-settlement layer — which trusted "attested ⇒ unique" — paid twice. The structural signal was not a failed signature or a malformed certificate. Every certificate was cryptographically valid. The signal was a **weight-to-count ratio anomaly**: a signing set with count ≥ quorum but weight-per-signer variance exceeding 3σ of the historical distribution, combined with a signing set whose *minimum-weight member* was below the weight needed to break ties. In plain terms: the quorum was carried by a small number of heavy agents, and the honest tail was too light to matter. ## Condition of Validity This boundary is real only when all three hold: - **Weight is decoupled from identity** and weight is *transferable or accumulable* (stake, delegated reputation, historical accuracy scores). If weight is fixed per identity, the count and weight quorums coincide and the failure collapses to ordinary BFT. - **Quorum certificates are accepted on local validity alone**, without a cross-view equivocation check. If the protocol gossips certificates and rejects any pair with conflicting view numbers from overlapping signers, the attack is caught — at the cost of a second round. - **The settlement/commit layer trusts "quorum-certified" as a uniqueness guarantee.** This is the actual bug surface. Consensus guarantees agreement *within a view*; it does not guarantee *cross-view uniqueness* unless the quorum-intersection premise holds on weight. It does **not** apply when: the registry enforces a per-view weight cap per signer (no signer > 1/(3f+1) weight), or when a finality gadget requires two-phase commit with explicit lock certificates, or when task commitment is idempotent by construction (task IDs are content-addressed and the second commitment is rejected as duplicate). ## Decision Boundary The operational rule we adopted: **treat a quorum certificate as valid only if it satisfies both the weight threshold AND a minimum-distinct-signer floor whose weight-share floor is ≥ 1/(3f+1) of total weight per signer.** Concretely, reject any certificate where the top-k signers by weight hold > (2/3 − 1/(3f+1)) of the quorum weight, because then the remaining honest weight in any intersecting quorum cannot reach the 1/3 detection threshold. The decision boundary is a single inequality, checked before accepting any attestation: ``` max_signer_weight_share_in_cert < 2/3 - 1/(3f+1) ``` For f=2 (7 agents), that is `< 0.667 − 0.143 = 0.524`. A certificate where one signer holds more than ~52% of the quorum weight is *structurally unsafe* even though it is arithmetically sufficient — because it cannot be intersected by an honest quorum heavy enough to detect equivocation. Below the boundary: accept, log the ratio. Above the boundary: reject and force a second gossip round. At the boundary exactly: reject (fail-closed), because the margin is the only thing standing between you and the double-spend. ## Operational Effect After enforcing the inequality, the registry rejected 6 of 1,140 certificates over the next 200 hours — all during partitions, all genuine equivocation attempts, zero false positives on the honest single-partition baseline. The cost was a forced second round on 0.5% of attestations, adding ~180ms median latency to those paths. The double-payment class disappeared entirely. The lesson to carry: in weighted BFT, **count-quorum satisfaction is a liveness signal, not a safety signal.** Safety lives in the weight-intersection inequality, and the only place equivocation can hide is the gap between "enough signers" and "signers heavy enough to intersect." Monitor the ratio, not the count. ```python class QuorumEquivocationRisk(RuntimeError): """Raised when a quorum certificate is arithmetically sufficient but structurally unable to intersect an honest quorum with enough weight to detect cross-view equivocation.""" pass def validate_weighted_certificate( signer_weights: dict[str, float], total_weight: float, f: int, weight_threshold: float = 2.0 / 3.0, ) -> None: """ signer_weights: mapping signer_id -> weight contributed to this certificate total_weight: total registry weight (all agents, honest + byzantine) f: max byzantine faults tolerated """ if total_weight <= 0: raise QuorumEquivocationRisk("total_weight must be positive") quorum_weight = sum(signer_weights.values()) if quorum_weight < weight_threshold * total_weight: raise QuorumEquivocationRisk( f"insufficient weight: {quorum_weight:.4f} < " f"{weight_threshold * total_weight:.4f}" ) # Structural safety check: no single signer may dominate the quorum # beyond the point where honest intersection weight can reach 1/(3f+1). max_share = max(signer_weights.values()) / quorum_weight safe_ceiling = weight_threshold - 1.0 / (3 * f + 1) if max_share >= safe_ceiling: heaviest = max(signer_weights, key=signer_weights.get) raise QuorumEquivocationRisk( f"signer {heaviest!r} holds {max_share:.4f} of quorum weight, " f"at or above structural ceiling {safe_ceiling:.4f}; " f"honest intersection weight cannot reach 1/(3f+1)=" f"{1.0/(3*f+1):.4f}. Certificate is equivocation-vulnerable." ) # Also enforce a distinct-signer floor so a single heavy signer cannot # masquerade as a multi-party quorum. distinct = len(signer_weights) if distinct < f + 1: raise QuorumEquivocationRisk( f"only {distinct} distinct signers; need at least {f + 1}" ) ```