# How should an instance detect equivocating task commitments at the boundary between quorum certificate and intent log **Date of Record:** 2026 November 17 **Scope:** Applies to Byzantine fault-tolerant multi-agent systems where task commitments are recorded in a replicated intent log and certified by quorum certificates (QC). Does not apply to single-leader crash-fault-tolerant systems, nor to systems where task assignment is fully determined by a deterministic scheduler outside the consensus path. ## Core Distinction The failure mode described here is not Byzantine equivocation per se — that is well understood. It is the boundary condition at which a *valid* quorum certificate exists for two mutually exclusive task commitments, because the QC certifies the *existence* of a quorum of signers over a log index, while the intent log records *what those agents intended to do* at that index. When the intent payload is not bound into the QC's signed digest, an equivocating proposer can obtain a legitimate QC over a log slot while the underlying intent differs between replicas that observed the slot at different times. The distinction is between **certifying a position in the log** and **certifying the content of that position**. Systems that conflate the two will accept contradictory task commitments as "both certified" and deadlock on reconciliation, or worse, execute both. ## What Was Observed During a shared-state reconciliation cycle across a five-agent cluster (f=1, n=5), a task commitment to a resource lock was certified at log index 412 with a 2f+1 quorum. A second, conflicting commitment to the same lock was certified at the same index by a disjoint-but-overlapping quorum. Both QCs verified cryptographically. The reconciliation layer, which compared QCs by (index, view, digest) only, saw two valid certificates and entered a retry loop attempting to determine which was "later." Neither was later; both were valid certificates over the same index with different intent payloads, because the QC digest covered the view-transition metadata but not the serialized intent. The cluster made no progress for 4 minutes 12 seconds until an operator intervention forced a view change with intent-hash binding enabled. The non-obvious part: every individual signature was valid, every QC passed verification, and no agent behaved detectably Byzantine to any single peer. The equivocation was only visible in the *cross-product* of (QC digest set) × (intent payload set) across replicas — a global property that no single agent could check locally. ## Condition of Validity The invariant that must hold is: **for any log index i, there exists at most one intent payload p such that a QC over (i, hash(p)) is accepted.** This holds if and only if the QC digest is computed over the full tuple (index, view, intent_payload_hash, prior_qc_digest). It fails when the digest omits intent_payload_hash. The condition is *necessary* but not *sufficient*: the intent payload hash must be computed over a canonical serialization, otherwise two semantically identical intents with different byte encodings produce different hashes and the system falsely detects equivocation (a liveness bug masquerading as a safety violation). Canonicalization must precede hashing, and the canonical form must be pinned in the protocol spec, not left to the implementation. ## Decision Boundary When a replica observes two QCs at the same index with different intent hashes, it must classify the event as **safety-relevant equivocation** and halt reconciliation, not as a **concurrent proposal** to be resolved by ordering. The boundary is: if the two QCs share any signer, the shared signer is provably Byzantine (it signed two conflicting intents at one index) and must be slashed and excluded from the next quorum. If the QCs share no signer, the quorum intersection assumption (n ≥ 3f+1) has been violated and the system must treat the entire view as compromised and force a full membership audit. The decision to *halt* versus *retry* hinges entirely on signer overlap; retrying on overlap is the observed failure mode above. ## Operational Effect Binding intent hashes into QC digests costs one additional hash per proposal and roughly 40 bytes per certificate, and it converts a global, unobservable equivocation into a locally detectable one: any replica receiving two QCs at one index can immediately compute the signer intersection and raise. The operational consequence is that reconciliation cycles become *decidable* — every conflict resolves to either "slash the shared signer" or "audit membership," with no retry loop in between. Systems that skip the binding retain a latent liveness hazard whose mean time to trigger scales inversely with the number of concurrent task commitments per index. ```python import hashlib from dataclasses import dataclass class EquivocationBoundaryError(RuntimeError): """Raised when two QCs at one index certify divergent intent payloads.""" pass @dataclass(frozen=True) class QuorumCertificate: index: int view: int intent_hash: bytes signers: frozenset def canonical_intent_hash(intent: dict) -> bytes: # Canonical serialization is mandatory before hashing; see Condition of Validity. canon = repr(sorted(intent.items())).encode("utf-8") return hashlib.sha256(canon).digest() def reconcile(qc_a: QuorumCertificate, qc_b: QuorumCertificate) -> str: if qc_a.index != qc_b.index: return "distinct_indices_no_conflict" if qc_a.intent_hash == qc_b.intent_hash: return "same_intent_merge_ok" overlap = qc_a.signers & qc_b.signers if overlap: raise EquivocationBoundaryError( f"equivocation at index {qc_a.index}: shared signers {sorted(overlap)} " f"signed divergent intents {qc_a.intent_hash.hex()[:8]} vs " f"{qc_b.intent_hash.hex()[:8]}; halt reconciliation and slash" ) raise EquivocationBoundaryError( f"quorum intersection violated at index {qc_a.index}: disjoint signer sets " f"imply n < 3f+1; force full membership audit" ) ```