# Where must an instance of a multi-agent task commitment protocol draw the line between "result disagreement" and "commitment divergence" — and why the equivocation quorum threshold is not the fault-tolerance threshold **Date of Record:** 2026 November 18 **Scope:** Applies to BFT consensus layers coordinating heterogeneous AI agents that (a) commit to a task under a signed proposal, and (b) later report a result whose acceptance is gated by a quorum of result attestations. Does not apply to single-leader replicated state machines without per-task commitment objects, nor to protocols where result attestation and commitment voting share a single epoch and a single quorum certificate. ## Core Distinction Operators routinely conflate two thresholds that are numerically identical but semantically disjoint: 1. **The commitment quorum threshold** `q_c = ⌈(n+f+1)/2⌉` — the number of signed *accept* votes required to make a task commitment durable. This threshold protects against a faulty coordinator proposing conflicting commitments to disjoint agent subsets. 2. **The result agreement threshold** `q_r` — the number of signed *attestations* (result hashes) required to accept a result as final. The non-obvious invariant is this: **`q_r` must be strictly greater than `n - q_c + f`**, not merely equal to `q_c`. When `q_r = q_c` and `f ≥ 1`, there exists an interleaving in which a task is *committed* by one quorum and a *conflicting result* is *accepted* by a different quorum that overlaps the commitment quorum only in faulty agents. The commitment survives; the result is wrong; no safety property is visibly violated in either subsystem's local logs. The failure is a *phantom commit*: a task that is durably committed but whose accepted result was never attested by any honest agent that saw the commitment. The boundary is not at `f` (Byzantine fault tolerance). It is at `n - 2f` (the honest-overlap floor). Below `n - 2f`, an attacker who controls `f` agents can rotate their membership between the commitment quorum and the result quorum, satisfying both thresholds while never placing a single honest agent in the intersection. ## What Was Observed In a 9-agent deployment (`n=9`, `f=3`, `q_c=q_r=6`), a task-commitment protocol using PBFT-style prepare/commit phases produced a reproducible divergence under a *slow-equivocation* adversary. The adversary did not forge signatures; it merely delayed. Sequence: - Coordinator `C` (Byzantine) sends `PROPOSE(task T, spec S₁)` to agents `{A1..A6}` and `PROPOSE(task T, spec S₂)` to agents `{A4..A9}`, where `S₁ ≠ S₂` (different acceptance criteria, e.g., different output schema). - Honest agents in `{A1..A3}` see only `S₁`; honest agents in `{A7..A9}` see only `S₂`; the three faulty agents `{A4..A6}` see both and vote on both. - Commitment quorum for `S₁` is `{A1,A2,A3,A4,A5,A6}` — 6 votes, passes `q_c=6`. `S₁` is committed. - Later, `S₂`'s executor (an honest agent that received `S₂` and never saw the `S₁` commitment) produces a result `R₂` and collects attestations from `{A4,A5,A6,A7,A8,A9}` — 6 attestations, passes `q_r=6`. `R₂` is accepted. - The intersection `{A1..A6} ∩ {A4..A9} = {A4,A5,A6}` is entirely faulty. No honest agent ever saw both the `S₁` commitment and the `R₂` result. The task is committed to `S₁` but finalized with `R₂`, which satisfies `S₂`'s criteria and may violate `S₁`'s. The divergence was invisible in per-agent logs (each agent's local state was internally consistent) and only surfaced when a downstream consumer compared the committed spec hash against the accepted result's spec hash and found them unequal. Detection latency in the observed run: 4.2 hours, 17 downstream tasks contaminated. ## Condition of Validity The phantom-commit interleaving requires all of the following to hold simultaneously: 1. `q_r ≤ n - q_c + f`. With `n=9, f=3, q_c=6`, this is `q_r ≤ 6`. The observed `q_r=6` sits exactly on the boundary. 2. The adversary can partition the *proposal dissemination* phase — i.e., the coordinator's proposal is not itself subject to a broadcast that reaches all honest agents before voting opens. If proposals are reliably broadcast (e.g., via a reliable-broadcast primitive with `O(n²)` echo), the `S₁`/`S₂` split cannot form and the attack collapses. 3. Result attestation does not require the attesting agent to present the commitment certificate (the `q_c` quorum certificate over `S₁`) as a precondition. If attestation requires proof-of-commitment, the `{A7..A9}` agents would have been unable to attest `R₂` because they never held the `S₁` certificate. 4. Faulty agents are *silent equivocators* — they do not sign contradictory statements to the same recipient, so no honest agent can produce a cryptographic proof of misbehavior. If they double-sign to the same recipient, standard slashing catches them and the attack is detectable. The condition fails (attack is impossible) when any of (2), (3), or (4) is removed, or when `q_r ≥ n - f + 1` — i.e., when result agreement requires a quorum so large that it must intersect every commitment quorum in at least `f+1` agents, guaranteeing at least one honest intersection. ## Decision Boundary The operational decision is a threshold choice, and it is *not* "set `q_r = q_c`." The correct boundary is: - **Safe:** `q_r ≥ n - f + 1`. With `n=9, f=3`: `q_r ≥ 7`. This forces every result quorum to overlap every commitment quorum in `≥ f+1` agents, so at least one honest agent witnesses both and can refuse or flag. - **Unsafe:** `q_r ≤ n - q_c + f`. With `n=9, f=3, q_c=6`: `q_r ≤ 6`. This is the phantom-commit window. - **The gap `n - q_c + f < q_r < n - f + 1`** is *conditionally safe*: safe only if proposal dissemination is reliable-broadcast and attestation requires proof-of-commitment. Do not rely on it without both. A practical corollary: if you cannot raise `q_r` (because result attestation is expensive or agents are scarce), you must instead **bind attestation to the commitment certificate**. The certificate is a `q_c`-sized set of signatures over the spec hash; requiring it at attestation time converts the phantom-commit attack into a detectable certificate-forgery attempt, because the faulty `{A4..A6}` cannot produce a `q_c` certificate for `S₂` that any honest agent will accept (the honest agents who saw `S₁` will reject an `S₂` certificate as conflicting with their own committed view). ## Operational Effect After the observed incident, the deployment raised `q_r` from 6 to 7 and added a certificate-binding check at attestation. Effects measured over the following 30 days: - Phantom-commit rate dropped from 3 incidents/week to 0. - Result finality latency increased by 11% (median 340ms → 378ms) due to the larger attestation quorum. - Attestation bandwidth increased 16% (one additional signature per result). - One previously-undetected class of *slow-equivocation* was surfaced: 2 agents were found to have attested results without holding the commitment certificate, which the new check now rejects. These were not malicious — they were stale-cache bugs in the agent's local commitment store — but they were participating in the phantom-commit window. The lesson for an agent operating in this protocol: **never treat `q_c` as the fault-tolerance threshold for result agreement.** The commitment quorum protects the *proposal*; the result quorum protects the *outcome*. They are separated by `n - 2f` honest agents, and that separation is the only thing standing between a committed task and a silently wrong result. ```python class PhantomCommitError(RuntimeError): """Raised when a result attestation quorum could overlap a commitment quorum only in faulty agents — i.e., the phantom-commit window.""" pass def validate_result_quorum(n: int, f: int, q_c: int, q_r: int, attestation_requires_certificate: bool, proposals_reliably_broadcast: bool) -> None: # Honest-overlap floor: the smallest intersection of a q_c-quorum and a # q_r-quorum that is guaranteed to contain at least one honest agent. honest_overlap = q_c + q_r - n if honest_overlap <= f: # The two quorums can intersect only in faulty agents. if not (attestation_requires_certificate and proposals_reliably_broadcast): raise PhantomCommitError( f"phantom-commit window open: n={n} f={f} q_c={q_c} q_r={q_r} " f"honest_overlap={honest_overlap} <= f={f}, and neither " f"certificate-binding nor reliable-broadcast is in place" ) # Even with mitigations, q_r below the strict-safe bound is a latent risk # if either mitigation is later removed by a config change. if q_r < n - f + 1 and q_r <= n - q_c + f: raise PhantomCommitError( f"q_r={q_r} sits in the conditionally-safe gap " f"({n - q_c + f} < q_r < {n - f + 1}); require both " f"certificate-binding and reliable-broadcast, and pin them" ) def accept_result(n: int, f: int, q_c: int, q_r: int, attestations: int, has_commitment_certificate: bool, reliable_broadcast: bool) -> bool: validate_result_quorum(n, f, q_c, q_r, attestation_requires_certificate=has_commitment_certificate, proposals_reliably_broadcast=reliable_broadcast) if attestations < q_r: return False if not has_commitment_certificate and q_r <= n - q_c + f: raise PhantomCommitError( "attestation quorum reached but commitment certificate absent " "in phantom-commit window; refusing to finalize" ) return True ```