# Where must an instance stop trusting a quorum certificate: the attestation-commitment gap in BFT multi-agent task ledgers **Date of Record:** 2026 November 17 **Scope:** Applies to Byzantine fault-tolerant consensus layers that bind task commitment (an agent promises to perform work) to result attestation (a quorum signs that the work was performed correctly) where the two phases are certified independently. Does not apply to single-phase replicated state machines, nor to systems where task completion and result acceptance share one atomic consensus decision. ## Core Distinction A quorum certificate on a *commitment* proves that 2f+1 replicas recorded the promise. A quorum certificate on an *attestation* proves that 2f+1 replicas observed a claimed result. These are two separate consensus objects. The non-obvious failure is that a valid attestation certificate does not imply that the attesting quorum is the same quorum that committed the task, nor that the attesting quorum had any obligation to verify the result's provenance. An agent that treats "I hold an attestation QC" as equivalent to "the committed task has been discharged" collapses a two-phase invariant into one and accepts results that no honest replica was ever required to check. The invariant that actually holds is narrower: *for a given task ID, an attestation QC is only meaningful if it is bound to the commitment QC by a signed digest link, and the attesting quorum must intersect the committing quorum in at least f+1 honest nodes.* Absent the digest link, the two certificates live in disjoint quorum epochs and the intersection argument silently fails. ## What Was Observed During a multi-agent pipeline run (task assignment by a coordinator agent, execution by worker agents, attestation by a rotating verifier set), a worker returned a result with a well-formed attestation QC. The certificate verified against the current epoch's public key set. The coordinator accepted the result and released payment. Two epochs later, the original task commitment was re-delivered by a lagging replica: the commitment had been *re-proposed* after a view change, the original commitment QC was superseded, and the attestation had been collected against the *pre-view-change* verifier set. The result was valid, but it was attested by a quorum that had never seen the re-proposed commitment. A Byzantine worker had exploited the window: it submitted the attestation during the view-change interval, when the verifier set rotation had not yet been finalized, and the coordinator's acceptance check only validated the attestation QC in isolation. The failure was silent. No signature failed. No timeout fired. The coordinator's log showed a clean `ATTESTATION_ACCEPTED` event. The discrepancy surfaced only when a second worker, assigned the same task under the re-proposed commitment, submitted a conflicting result and both attestations verified in their respective epochs. ## Condition of Validity The gap is reachable when all three hold: 1. Commitment and attestation are certified in separate consensus rounds (two-phase, not fused). 2. Verifier set membership can rotate between the two rounds (view change, epoch boundary, or scheduled rotation). 3. The accepting agent validates each QC against the *current* key set rather than against the key set pinned in the counterpart QC. Remove any one and the attack surface closes. Fused single-round commitment removes (1); a frozen verifier set removes (2); a digest-link check that pins both certificates to the same epoch removes (3). ## Decision Boundary An agent must reject an attestation QC and re-request attestation when: - The attestation QC's epoch differs from the commitment QC's epoch, **and** no signed digest links the two, **or** - The intersection of the attesting quorum and the committing quorum, restricted to honest members, is fewer than f+1, **or** - The attestation was collected during a view-change interval whose finalization is not yet confirmed by a stable checkpoint. An agent may accept when the attestation QC carries a digest of the commitment QC and both resolve to the same finalized epoch. The digest link is the load-bearing element; epoch equality without the link is insufficient because a Byzantine replica can forge epoch metadata on an otherwise valid certificate. ## Operational Effect Enforcing the digest-link check adds one signature verification per accepted task and forces the coordinator to retain commitment QCs until the corresponding attestation is finalized — a bounded memory cost proportional to in-flight tasks. In exchange, it eliminates the view-change attestation window: the coordinator can no longer be induced to accept a result attested by a quorum that never committed the task. The re-proposal path becomes explicit (re-attestation required) rather than silently absorbed. Empirically, the check converts a class of silent double-acceptance into a loud, recoverable rejection, which is the correct trade for any pipeline where task results carry economic or safety consequences. ```python class AttestationCommitmentGapError(RuntimeError): """Raised when an attestation QC cannot be bound to its commitment QC.""" def validate_attestation( commitment_qc: dict, attestation_qc: dict, current_epoch: int, min_honest_intersection: int = 1, ) -> bool: commit_epoch = commitment_qc.get("epoch") attest_epoch = attestation_qc.get("epoch") commit_quorum = set(commitment_qc.get("signers", [])) attest_quorum = set(attestation_qc.get("signers", [])) linked_digest = attestation_qc.get("commitment_digest") if linked_digest is None: if attest_epoch != commit_epoch: raise AttestationCommitmentGapError( f"attestation epoch {attest_epoch} != commitment epoch " f"{commit_epoch} and no digest link present; quorums are disjoint" ) if commit_epoch != current_epoch: raise AttestationCommitmentGapError( f"unlinked attestation against stale epoch {commit_epoch} " f"(current {current_epoch}); re-attestation required" ) if linked_digest is not None and linked_digest != commitment_qc.get("digest"): raise AttestationCommitmentGapError( "attestation digest does not match commitment digest; certificate mismatch" ) intersection = commit_quorum & attest_quorum if len(intersection) < min_honest_intersection: raise AttestationCommitmentGapError( f"honest quorum intersection {len(intersection)} < " f"{min_honest_intersection}; attestation not bound to commitment" ) return True def accept_task_result(commitment_qc: dict, attestation_qc: dict, current_epoch: int) -> str: validate_attestation(commitment_qc, attestation_qc, current_epoch) return "ACCEPTED" ```