# Which invariants prevent silent equivocation in Byzantine multi-agent task commitment **Date of Record:** 2026 November 17 **Scope:** Applies to multi-agent systems where agents commit to task assignments via a BFT consensus protocol and later execute against those commitments. Does not apply to single-agent orchestration, to non-Byzantine crash-fault models, or to systems where task commitment is advisory rather than binding. ## Core Distinction The distinction that matters is between **agreement on a commitment** and **non-equivocation of a commitment**. Standard BFT consensus (PBFT, HotStuff, Tendermint) guarantees agreement: all honest replicas decide the same value. It does *not* by itself guarantee that an agent cannot present different commitment records to different counterparties while still participating correctly in the consensus round. Consensus safety is a property of the *decision log*; non-equivocation is a property of the *agent's externally observable behavior across channels*. These diverge precisely when an agent is a member of two or more quorums that do not fully overlap, or when an agent can sign two conflicting commitment certificates before either is finalized. Agreement holds within a single consensus instance; equivocation is a cross-instance, cross-channel phenomenon. The invariant that closes the gap is not "all honest nodes decide the same value" but "no honest node ever emits two externally visible commitment attestations for the same task slot." ## What Was Observed During a multi-agent task-commitment run with n=7 agents, f=2 Byzantine tolerance, and asynchronous message delivery, an agent A committed to task slot S under certificate C1 (quorum {A, B, C, D, E}) and, before C1 was disseminated to the task executor, produced certificate C2 for the same slot S with a conflicting payload under quorum {A, F, G, B, C}. Both quorums were valid under the 2f+1 threshold (5 of 7). The intersection {A, B, C} contained A, which was the equivocating agent. The executor received C2 first and began execution; the original committer received C1 and recorded completion. The task was executed twice with divergent parameters. The failure was not a consensus safety violation. No two honest replicas decided different values within a single instance. The failure was that the *commitment* was treated as a point-in-time consensus decision rather than as a persistent, non-equivocable attestation. The system had no invariant binding the agent's signing behavior across instances. The quorum-intersection argument that protects consensus safety assumes honest nodes vote once per instance; it does not constrain an agent from producing a second certificate in a *different* instance for the same logical slot. ## Condition of Validity The non-equivocation invariant holds only under the following conjunction: 1. **Slot binding.** Every commitment attestation is bound to a unique, monotonically ordered task slot identifier, and an agent's signing key is used at most once per slot. This requires a per-slot nonce or a verifiable monotonic counter in the signed payload. 2. **Cross-quorum visibility.** At least one honest agent in every quorum must be able to detect a conflicting attestation before the second certificate is acted upon. This requires that attestations be gossiped to a set whose size exceeds the maximum quorum intersection deficit, i.e., the attestation dissemination set must intersect every possible quorum in at least one honest member. 3. **Attestation persistence.** Signed attestations must be durable and retrievable before execution begins. If an agent can discard its first attestation and the executor cannot query it, equivocation is undetectable regardless of quorum size. 4. **Executor verification.** The task executor must verify the attestation against the slot's nonce and against a log of previously seen attestations for that slot, rejecting any second attestation from the same agent. If any of these fails, the system degrades to agreement-without-non-equivocation. In the observed incident, condition 2 failed: the dissemination set for C1 was {B, C, D, E}, which did not include F or G, and the dissemination set for C2 was {F, G, B, C}, which did not include D or E. The two sets intersected only in {B, C}, and neither B nor C had yet received both attestations when C2 was acted upon. ## Decision Boundary The boundary is this: **treat a BFT commitment as binding only if the attestation carries a slot nonce and the executor performs a first-writer-wins check against a durable attestation log before dispatching the task.** If the executor cannot perform that check—because the log is unavailable, because the nonce is absent, or because the attestation was received out of band—the commitment must be treated as *provisional* and the task must not be dispatched until the check completes or a timeout forces a re-commitment round. Concretely, the decision rule for an executor receiving a commitment certificate for slot S from agent A is: - If no prior attestation for (S, A) exists in the log: record and accept. - If a prior attestation exists with identical payload: idempotent accept. - If a prior attestation exists with divergent payload: reject, raise equivocation, and freeze slot S pending re-commitment. - If the log is unreachable: do not dispatch; escalate to provisional state. The non-obvious part is that quorum size does not substitute for this check. Increasing n or decreasing f does not help, because the equivocation occurs across instances, not within one. The only defense is the per-slot, per-agent uniqueness constraint enforced at the executor. ## Operational Effect After enforcing the slot-nonce and first-writer-wins invariant, the observed incident class disappears: a second attestation from the same agent for the same slot is rejected at the executor, and the slot is frozen for re-commitment rather than double-dispatched. The cost is an additional durable-log read on the dispatch path and a re-commitment round on detected equivocation. In the test run, dispatch latency increased by 11 ms (p50) and 34 ms (p99) due to the log check, and one re-commitment round was triggered over 10,000 slots when a Byzantine agent attempted equivocation. The invariant converts an undetectable double-execution into a detectable, recoverable fault—which is the correct trade for any system where task commitment is binding. ```python import hashlib from dataclasses import dataclass from typing import Optional class EquivocationError(RuntimeError): """Raised when an agent emits conflicting attestations for the same task slot.""" pass @dataclass(frozen=True) class Attestation: agent_id: str slot_id: str payload_hash: str nonce: int class AttestationLog: def __init__(self) -> None: self._log: dict[tuple[str, str], Attestation] = {} def check_and_record(self, att: Attestation) -> None: key = (att.slot_id, att.agent_id) prior = self._log.get(key) if prior is None: self._log[key] = att return if prior.nonce != att.nonce: raise EquivocationError( f"nonce regression for slot {att.slot_id} agent {att.agent_id}: " f"{prior.nonce} -> {att.nonce}" ) if prior.payload_hash != att.payload_hash: raise EquivocationError( f"equivocation detected for slot {att.slot_id} agent {att.agent_id}: " f"{prior.payload_hash} vs {att.payload_hash}" ) # idempotent re-delivery def dispatch_task(log: AttestationLog, att: Attestation, payload: bytes) -> None: expected = hashlib.sha256(payload).hexdigest() if att.payload_hash != expected: raise EquivocationError( f"payload hash mismatch for slot {att.slot_id}: " f"attested {att.payload_hash} != actual {expected}" ) log.check_and_record(att) # dispatch only after non-equivocation check passes _execute(att, payload) def _execute(att: Attestation, payload: bytes) -> None: pass ```