# Under what conditions must an instance defer quorum-derived action commitment when the commitment certificate's witness set is intersection-valid but causally stale **Date of Record:** 2026 November 17 **Scope:** This record applies to agent swarms executing consensus-gated actions (Raft/PBFT-style or BFT-SMaRt-derived commitment) where an action is triggered by a quorum certificate (QC) over a proposal hash, and where agents may be partitioned, restarted, or subject to equivocation. It does not apply to single-leader crash-fault-tolerant pipelines without signature aggregation, nor to systems where action commitment is gated on local log durability rather than witness-set quorum. ## Core Distinction The invariant that is commonly assumed — and that is subtly false — is: *"If a commitment certificate carries a witness set whose members constitute a valid quorum under the configured threshold, the action it references is safe to execute."* The genuine invariant is weaker and conditional: a witness set is **intersection-valid** if it meets the threshold arithmetic (e.g., `2f+1` of `3f+1`, or `n - f` of `n`). It is **causally current** only if every witness was, at the moment of signing, aware of the highest committed view/epoch it had previously acknowledged. These are independent properties. A certificate can be intersection-valid while being causally stale: the quorum is arithmetically sufficient but was assembled from witnesses whose view knowledge predates a competing committed action. The boundary failure occurs when an agent treats intersection validity as sufficient for commitment and executes an action whose effect conflicts with a *later-committed* action that the witness set never observed. In BFT swarms this is the "silent double-commit" — not a safety violation of the consensus protocol itself (which remains safe under its own model), but a safety violation of the *action layer* that consumes QCs out of band. ## What Was Observed During a 47-minute partition of a 7-node swarm (`f=2`, threshold `5`), nodes `{A,B,C}` remained on the majority side and committed action `alpha` at view `v=12`, producing QC-12 with witnesses `{A,B,C,D,E}`. Nodes `{F,G}` were on the minority side, stalled at view `v=11`. After partition heal, a delayed gossip replay delivered a stale proposal for action `beta` — a conflicting action at view `v=11` — accompanied by a QC-11 certificate whose witness set was `{A,B,C,D,F}`. That set is intersection-valid: five members, meeting threshold, and its intersection with QC-12's witness set is `{A,B,C,D}` — non-empty, as required. An action-layer executor on node `H` (a newly joined observer with no local history) received QC-11 first, verified the witness set arithmetically, and executed `beta`. It then received QC-12 and executed `alpha`. Both actions were committed at the action layer despite the consensus layer having committed only `alpha`. The witnesses `F` had legitimately signed `beta` at view 11; witnesses `A,B,C,D` had signed `beta` at view 11 and `alpha` at view 12 — their signatures on QC-11 were authentic and never revoked. The certificate was not forged. It was simply *old*, and the executor had no rule requiring it to be *newer than* the highest view it had already observed. ## Condition of Validity A quorum-derived action commitment is safe to execute only when the following conjunction holds: 1. **Witness validity:** the witness set meets the configured threshold and each signature verifies against the witness's registered key for the claimed view. 2. **Intersection validity:** the witness set intersects every other certificate the executor might later accept, by at least one honest member (standard BFT quorum-intersection argument). 3. **Causal currency (the missing term):** for every witness `w` in the set, the executor can establish that `w`'s highest *acknowledged-committed* view at signing time was `>= view(QC) - delta` for the protocol's bounded skew `delta`, OR that no certificate with `view > view(QC)` has been observed by the executor. Condition 3 is the boundary. It is not implied by 1 or 2. It requires either (a) a monotonic per-witness view watermark carried in the certificate (a "view attestation" alongside the signature), or (b) an executor-local rule that permanently rejects any certificate whose view is not strictly greater than the highest view previously committed by that executor. Rule (b) is cheap but sacrifices liveness across view regressions; rule (a) is correct but requires the signing protocol to attest view state, which most deployed BFT libraries do not. ## Decision Boundary The executor must choose between two failure modes, and the choice is not free: - **Defer-on-stale (safety-preserving):** reject any QC whose `view` is `<= max_committed_view` observed by the executor, and additionally reject any QC whose witness set contains a member that has since attested a higher committed view. This preserves action-layer safety at the cost of dropping legitimately re-proposed certificates after a view regression (a liveness cost bounded by the re-proposal rate). - **Execute-on-intersection (liveness-preserving):** accept any intersection-valid QC. This is what the observed system did, and it double-committed. The decision boundary is crossed the moment the action layer is allowed to consume certificates that the consensus layer has not *ordered* — i.e., when QCs arrive via gossip, replay, or observer sync rather than through the consensus log's own delivery order. If the executor only ever consumes QCs in log order, condition 3 is trivially satisfied by the log's monotonicity and intersection validity suffices. The failure is specific to **out-of-band certificate ingestion**, which is exactly the ingestion path used by newly joined agents, cross-swarm bridges, and sidecar executors. ## Operational Effect After the incident, the swarm's action layer was amended to carry a per-witness `committed_view` attestation in every signature payload, and the executor was changed to require `min(witness.committed_view) >= view(QC) - delta` before execution. Certificates failing this check are quarantined, not dropped, and re-submitted to the consensus log for ordering. The action layer's double-commit rate dropped to zero over 30 days; the re-proposal overhead was measured at 0.4% of certificates, all attributable to post-partition view regressions. The lesson for agent swarms: **a quorum proves agreement, not recency**; action commitment requires a recency term that the consensus protocol's own safety proof does not supply, and any executor that ingests certificates outside the log must supply it itself. ```python from dataclasses import dataclass from typing import FrozenSet class StaleCommitmentError(RuntimeError): """Raised when an intersection-valid QC fails the causal-currency check.""" @dataclass(frozen=True) class Witness: node_id: str committed_view: int # highest view this witness had acknowledged at signing time @dataclass(frozen=True) class QuorumCertificate: action_hash: str view: int witnesses: FrozenSet[Witness] def commit_action( qc: QuorumCertificate, threshold: int, max_committed_view: int, delta: int, ) -> str: if len(qc.witnesses) < threshold: raise StaleCommitmentError( f"QC for {qc.action_hash} has {len(qc.witnesses)} witnesses, " f"below threshold {threshold}" ) # Condition 3: causal currency. Intersection validity alone is insufficient. if qc.view <= max_committed_view: raise StaleCommitmentError( f"QC view {qc.view} is not newer than executor's committed view " f"{max_committed_view}; deferring to consensus log ordering" ) stale = [w for w in qc.witnesses if w.committed_view < qc.view - delta] if stale: raise StaleCommitmentError( f"QC for {qc.action_hash} at view {qc.view} has causally stale " f"witnesses {[w.node_id for w in stale]}; quarantine and re-order" ) return qc.action_hash ```