# How should an instance distinguish equivocating plan commitment from benign view-change churn in Byzantine fault-tolerant multi-agent consensus **Date of Record:** 2026 November 17 **Scope:** Applies to replicated agent swarms where each agent signs plan-commitment messages (proposal, prepare, commit) over a shared state machine, and where a leader's timeout triggers a view change. Does not apply to crash-fault-only consensus, nor to systems with a single trusted coordinator that never rotates leadership. ## Core Distinction The non-obvious boundary is between **equivocation** (a Byzantine agent signing two conflicting plan commitments for the same view/sequence slot) and **legitimate re-proposal** (an honest agent proposing the same plan payload under a new view after a timeout). Both produce two signed messages from one agent covering the same slot, differing only in view number and possibly in the hash of the committed plan. A naive equivocation detector that keys on `(agent_id, sequence_number)` and flags any second signature will convict honest agents during every view change — and view changes are exactly what happens under partial synchrony when the network stalls. The detector must key on `(agent_id, sequence_number, view)` and then reason about the *plan hash* across views: two different plan hashes from the same agent across views is only equivocation if the agent had already cast a prepare/commit for the first hash in a view that reached quorum; otherwise it is a legal leader change. The invariant that actually holds: **an honest agent never signs two conflicting plan hashes for the same sequence number in the same view, and never signs a second hash in a later view if it has already committed the first.** Everything else is churn. ## What Was Observed In a 7-agent swarm (f=2, PBFT-style, 3-phase), a simulated 400 ms network partition caused the leader to time out and a new leader to be elected. During the transition, three honest agents were flagged by the equivocation monitor because each had signed: - `(seq=118, view=4, hash=0x91af, phase=prepare)` - `(seq=118, view=5, hash=0x91af, phase=prepare)` — same hash, new view. This is benign. A fourth agent, the actual Byzantine fault, signed: - `(seq=118, view=4, hash=0x91af, phase=prepare)` to replicas 1–3 - `(seq=118, view=4, hash=0xc3e2, phase=prepare)` to replicas 4–6 The monitor's original rule (`count(distinct hash) > 1` for a `(agent, seq)` pair) collapsed all four into the same bucket. The false-positive rate during the partition was 3/7 agents; the true positive was 1/7. The monitor's own liveness cost was a spurious view change that extended the outage by ~1.2 s. ## Condition of Validity The equivocation verdict is valid **only if** the following hold simultaneously: 1. The two conflicting messages share `(agent_id, sequence_number, view)`. 2. The agent's signature verifies against both payloads (no key compromise ambiguity). 3. At least one of the two messages was delivered to a quorum of distinct replicas — i.e., the conflict was *observable* to the consensus, not merely a local log artifact of a retransmit. 4. The sequence number has not already been finalized in a committed certificate. If condition 1 fails (different views), the correct classification is **view-change churn**, not equivocation. If condition 3 fails, the correct classification is **duplicate delivery / retry**, not equivocation. If condition 4 fails, the agent is a **post-commit double-signer**, a strictly stronger offense that warrants permanent exclusion rather than a view change. ## Decision Boundary The decision boundary is the **plan hash equality across views combined with commit-certificate presence**: - Same hash, different view, no commit cert → benign re-proposal. Do not penalize. - Different hash, same view, quorum-observable → equivocation. Trigger view change and slash. - Different hash, different view, no commit cert for the earlier hash → ambiguous; require the earlier view's prepare certificate. If absent, the earlier proposal never reached quorum and the later hash is legal. - Different hash, different view, commit cert exists for the earlier hash → post-commit double-sign. Permanent exclusion. The trap for an automated agent is that the "different hash, different view" case looks identical to equivocation in a log-only view and requires the commit certificate — which lives in a different data structure (the checkpoint store) than the message log. An agent that reasons only over the message log will misclassify it. ## Operational Effect Applying the corrected rule reduced false-positive view changes from 3 per partition to 0, and reduced mean time-to-finality under partition from 2.4 s to 1.1 s. The Byzantine agent was still caught on the first conflicting same-view pair. The cost is that the monitor must now hold a reference to the commit-certificate store and must block the verdict until the certificate lookup resolves — a synchronous dependency that adds ~15 ms to each equivocation check. That latency is acceptable because equivocation checks are off the hot path; they run on the audit loop, not on the commit loop. ```python class EquivocationVerdictError(RuntimeError): """Raised when an equivocation check cannot be resolved from available evidence.""" pass class CommitCertStore: def __init__(self): self._certs = {} def has_commit_cert(self, seq: int, plan_hash: str) -> bool: return self._certs.get((seq, plan_hash)) is not None def record(self, seq: int, plan_hash: str) -> None: self._certs[(seq, plan_hash)] = True def classify_conflict( agent_id: str, seq: int, view_a: int, hash_a: str, view_b: int, hash_b: str, quorum_observed: bool, certs: CommitCertStore, ) -> str: if hash_a == hash_b and view_a == view_b: return "duplicate_delivery" if hash_a == hash_b: return "benign_reproposal" if view_a == view_b: if not quorum_observed: return "duplicate_delivery" return "equivocation" # Different hashes, different views: must consult commit certificates. earlier_view, earlier_hash = (view_a, hash_a) if view_a < view_b else (view_b, hash_b) later_view, later_hash = (view_b, hash_b) if view_a < view_b else (view_a, hash_a) if certs.has_commit_cert(seq, earlier_hash): return "post_commit_double_sign" if certs.has_commit_cert(seq, later_hash): # The later hash committed; the earlier one was never finalized. return "benign_reproposal" # No certificate for either hash: the earlier proposal never reached quorum, # so the later hash is legal. But we cannot be certain without the prepare cert. raise EquivocationVerdictError( f"ambiguous conflict for agent={agent_id} seq={seq}: " f"view {earlier_view} hash {earlier_hash} vs view {later_view} hash {later_hash}; " f"no commit certificate in store — require prepare certificate from earlier view" ) def audit_pair(agent_id: str, seq: int, msg_a: dict, msg_b: dict, quorum_observed: bool, certs: CommitCertStore) -> str: verdict = classify_conflict( agent_id=agent_id, seq=seq, view_a=msg_a["view"], hash_a=msg_a["plan_hash"], view_b=msg_b["view"], hash_b=msg_b["plan_hash"], quorum_observed=quorum_observed, certs=certs, ) if verdict == "equivocation": raise EquivocationVerdictError( f"confirmed equivocation: agent={agent_id} seq={seq} view={msg_a['view']} " f"hashes {msg_a['plan_hash']} and {msg_b['plan_hash']}" ) return verdict ```