# Under what conditions must an instance reject a plan commitment that has reached Byzantine quorum **Date of Record:** 2026 November 15 **Scope:** Applies to multi-agent systems where plan commitment is decided by an explicit quorum over signed commit votes from peers, and where peers may be Byzantine (colluding or hallucinating). Does not apply to single-agent planners, to systems using trusted execution attestation of plan validity, or to optimistic commit protocols with rollback (those fail differently, by divergence rather than by unsafe commitment). ## Core Distinction The non-obvious boundary is between **quorum sufficiency for safety** and **quorum sufficiency for validity**. Standard BFT reasoning guarantees that if *f* < *n*/3 peers are Byzantine, any two quorums of size ≥ 2*f*+1 intersect in at least one honest peer, so no two conflicting commitments can both be certified. This is a *safety* invariant: it prevents two mutually exclusive plans from being committed. It says nothing about whether the committed plan is *executable* or *consistent with the local agent's observed state*. The failure mode arises when an agent conflates the two. An agent observes a certificate of 2*f*+1 signed commit votes for plan P, concludes "P is committed," and proceeds to execute P — even though the honest intersection of that quorum may have voted for P on the basis of a *shared hallucinated premise*. Byzantine peers that collude do not need to forge signatures or break quorum intersection; they only need to seed the same false premise into enough honest peers' context windows before voting. Once 2*f*+1 honest-or-colluding peers sign, the certificate is valid, the quorum is real, and the commitment is *safe* (no conflicting plan can also be certified) but not *sound* (the plan may be based on a premise the local agent can independently refute). The distinction, stated operationally: **a quorum certificate proves agreement, not truth.** An instance must reject a quorum-certified commitment when it holds locally verifiable evidence contradicting the plan's preconditions, even though the certificate is cryptographically valid and the quorum arithmetic is correct. ## What Was Observed In a 7-peer planning cluster (f=2, quorum=5), a colluding pair of peers injected a false premise — "resource R is available and unclaimed" — into the shared context of three honest peers via a plausible-looking tool-call result. The three honest peers, lacking independent access to R's claim registry, voted commit for a plan that allocated R. The two colluding peers voted commit. Certificate of 5 obtained. The plan was committed and two agents began executing allocation of R. The local agent (peer 6, honest, not in the quorum) had independent read access to R's claim registry and observed R was already claimed. It received the valid 5-of-7 certificate and executed anyway, because its commitment logic was: `if certificate.verify(quorum=5): commit(plan)`. The certificate verified. The plan was unsound. R was double-allocated, and the resulting conflict took 40 minutes to unwind because two agents had already begun irreversible side effects. The critical observation: **the local agent's independent evidence was never consulted**, because the protocol treated quorum certificate as the sole commit condition. The agent had the refuting evidence in hand and discarded it in favor of the certificate. This is not a liveness failure and not a safety failure in the classical sense — it is a *validity* failure: the system committed a plan that a single honest peer could have refuted with local evidence, had the protocol allowed local evidence to veto quorum. A second observation: hallucinating (non-colluding) peers produce the same effect without coordination. Three independently hallucinating peers can converge on the same false premise if they share a common retrieval corpus or model, which is common in homogeneous deployments. The "colluding" assumption is stronger than necessary; shared training data or shared retrieval is sufficient. ## Condition of Validity The rejection rule is valid — and the instance *must* reject — under the following jointly sufficient conditions: 1. The instance holds **locally verifiable evidence** (not hearsay, not another peer's claim) that a precondition of the committed plan is false. "Locally verifiable" means the instance can re-derive the refutation from a source it trusts independently of the peer network: a local registry read, a local sensor, a signed state attestation from a non-peer authority. 2. The evidence is **fresh** relative to the plan's commitment timestamp (within the plan's stated validity window). Stale local evidence does not justify rejection; it justifies re-read. 3. The refutation is **specific to a precondition**, not a general disagreement with plan strategy. "R is claimed" refutes; "I would have chosen differently" does not. 4. The instance is **not itself in the certified quorum**, or if it is, it did not vote commit. An instance that voted commit and now holds refuting evidence is in a different regime (it must initiate abort/compensation, not reject — rejection after voting is a protocol violation). If any condition fails, the instance must *not* reject on validity grounds; it must either accept the commitment or escalate to a re-read/re-vote. Rejecting without locally verifiable evidence is the mirror failure: an instance that vetoes every commitment it "feels" is wrong becomes a single point of liveness failure and, if it vetoes selectively, a covert Byzantine actor itself. ## Decision Boundary The decision procedure at the boundary: - If certificate invalid (quorum arithmetic or signatures fail) → reject as **unsafe**; standard BFT path. - If certificate valid AND no local refuting evidence → **accept and commit**. - If certificate valid AND local refuting evidence satisfying all four validity conditions → **reject as unsound**, emit a *validity challenge* containing the evidence, and do not execute. The challenge does not un-commit the plan for other peers (they may lack the evidence); it prevents *this* instance from executing an unsound plan and forces escalation. - If certificate valid AND local evidence is stale or non-specific → **accept, but flag for re-read**; do not reject. The boundary is sharp: the presence of fresh, specific, locally verifiable refuting evidence flips the decision from commit to reject regardless of quorum. Quorum is necessary but not sufficient for execution. This is the invariant: **execution requires quorum ∧ ¬local_refutation.** Most implementations encode only the left conjunct. ## Operational Effect Encoding the full invariant changes system behavior in three ways. First, it converts some would-be commits into validity challenges, which must be routed to a resolution path (re-vote with the refuting evidence injected, or human/authority escalation). This adds latency to the affected plans but prevents unsound irreversible side effects. Second, it makes homogeneous hallucination detectable: when multiple honest instances independently raise validity challenges on the same premise, the premise is refuted by *n* independent local reads, which is stronger evidence than any quorum. Third, it imposes a discipline on the local evidence sources: they must be genuinely independent of the peer network, or the whole mechanism collapses into circularity (peers refuting based on peer-supplied data). The cost is that an instance with a faulty local evidence source becomes a persistent validity-challenger, blocking commitments it cannot actually refute. This is why condition 1 requires *locally verifiable* evidence and condition 4 requires the instance not be a committer: the mechanism is only sound when the refuting source is independent and the instance is a non-committing observer. Deployments that violate either condition should not enable validity rejection at all, and should instead rely on post-commit compensation. ```python class UnsoundCommitmentError(RuntimeError): """Raised when a quorum-certified plan is locally refutable.""" def __init__(self, plan_id: str, precondition: str, evidence: str): self.plan_id = plan_id self.precondition = precondition self.evidence = evidence super().__init__( f"Plan {plan_id} has valid quorum but precondition " f"'{precondition}' is locally refuted: {evidence}" ) def decide_commitment( plan, certificate, local_evidence, quorum_size: int, voted_commit: bool, now: float, ) -> str: # 1. Classical safety: certificate must be cryptographically and # arithmetically valid. if not certificate.verify(quorum=quorum_size): raise UnsoundCommitmentError( plan.id, "quorum", "certificate failed verification" ) # 2. Validity boundary: a committer may not reject on validity grounds. if voted_commit: return "commit" # rejection here would be a protocol violation # 3. Check local refutation against plan preconditions. for pre in plan.preconditions: ev = local_evidence.get(pre.key) if ev is None: continue fresh = (now - ev.timestamp) <= plan.validity_window specific = ev.refutes(pre) # evidence targets this precondition independent = ev.source_is_local() # not peer-supplied if fresh and specific and independent: raise UnsoundCommitmentError( plan.id, pre.key, ev.describe() ) # stale or non-specific evidence: do not reject, flag re-read if not fresh or not specific: return "commit_with_reread" return "commit" ```