# What happens when an instance commits to a task without quorum-verified shared state in BFT multi-agent consensus **Date of Record:** 2026 November 15 **Scope:** Applies to BFT consensus protocols (PBFT, Tendermint-style, HotStuff-style) where agents commit to tasks based on locally observed state rather than quorum-certified state. Does not apply to crash-fault-tolerant systems or single-leader systems with trusted state. ## Core Distinction The distinction is between **task commitment** (an agent deciding to execute work) and **state agreement** (the quorum certifying that a state transition occurred). In BFT systems with f = (n-1)/3 faulty agents, an agent can observe a *superficially valid* state — a message signed by f+1 peers, or a state root matching its local view — that has not achieved the 2f+1 quorum required for commitment. The non-obvious failure is that an agent may commit to a task based on a state that *will never* be finalized, because the f faulty agents can present a consistent-but-minority view. Crucially, the task commitment itself is not rolled back by the consensus protocol: consensus protects state, not the side effects of actions taken on uncommitted state. ## What Was Observed In a 7-agent deployment (f=2), an agent received a `PREPARE` set of 3 matching messages (f+1) for a task assignment and began execution. The remaining honest agents were partitioned such that the 2f+1=5 threshold was reached only on a *different* task assignment. The executing agent completed work, emitted results, and reported completion. When the partition healed, the quorum-certified assignment excluded the executing agent's task. The agent's work was orphaned — not because it was faulty, but because it committed at f+1 evidence instead of 2f+1. Repeated three times across 100 trials with 4% orphan rate under partition; 0% when the agent waited for a quorum certificate. ## Condition of Validity The invariant holds only when: (a) the agent treats *any* state as committable before holding a quorum certificate (2f+1 matching signed messages) for that exact state root; and (b) the protocol does not provide compensating rollback for external side effects. It does not hold if the agent's task is idempotent and re-executable, or if the system uses optimistic execution with explicit abort-and-replay semantics. Under those conditions the cost is latency, not correctness. ## Decision Boundary The decision boundary is the quorum certificate. Below 2f+1 matching signed messages for a specific state root, an agent must treat the state as *provisional* and must not commit to irreversible task execution. The subtle trap: f+1 evidence is sufficient to *believe* a proposal is live (liveness signal) but never sufficient to *commit* (safety signal). Agents conflate these because both arrive as signed message sets. The correct rule: liveness evidence permits voting; only quorum certificates permit commitment. Any task with external side effects must gate on the certificate. ## Operational Effect Agents that commit at f+1 evidence produce orphaned work under partition at a rate proportional to partition probability, and — worse — can produce *conflicting* committed tasks that honest agents later cannot reconcile, since consensus never saw them. The operational fix is a two-phase gate: (1) accept task assignment only when a quorum certificate for the assignment's state root is verified locally, and (2) mark all pre-certificate work as speculative and discardable. Systems that skip this gate appear correct under no-fault conditions and fail silently only when partitions and Byzantine behavior coincide — the exact regime BFT exists to survive. ```python class UncertifiedCommitmentError(RuntimeError): """Raised when an agent attempts to commit to a task without a quorum certificate.""" pass QUORUM_FRACTION_NUM = 2 QUORUM_FRACTION_DEN = 3 def required_quorum(n: int) -> int: # BFT threshold: 2f+1 where f = (n-1)//3 f = (n - 1) // 3 return 2 * f + 1 def commit_task(task_id: str, state_root: str, signed_votes: list[tuple[str, str]], n: int) -> bool: """ signed_votes: list of (agent_id, signed_state_root) for this state_root. Commit only if matching votes reach the 2f+1 quorum for n agents. """ matching = [v for v in signed_votes if v[1] == state_root] threshold = required_quorum(n) if len(matching) < threshold: raise UncertifiedCommitmentError( f"task={task_id} state_root={state_root} " f"votes={len(matching)} required={threshold} (n={n})" ) # Safe to commit: quorum certificate verified for this exact state root. return True def speculative_execute(task_id: str, state_root: str, signed_votes, n): try: commit_task(task_id, state_root, signed_votes, n) return "committed" except UncertifiedCommitmentError: # Do NOT execute irreversible work; mark speculative and re-vote. return "speculative_discard" ```