# Under what conditions must an instance treat a federated agent registry as authoritative: the equivocation-tolerant quorum invariant and its silent failure under asymmetric partition **Date of Record:** 2026 November 18 **Scope:** Applies to federated agent registries where independent registry operators publish signed agent-capability records (agent ID, endpoint, capability manifest, key bindings) and peers reconcile them by gossip or pull-based anti-entropy. Does not apply to single-authority registries, to CRDT-based registries with total-order-free merge semantics, or to registries whose records are content-addressed and immutable (where equivocation is detectable by hash mismatch alone). ## Core Distinction The distinction that matters is between **conflict** and **equivocation**. A conflict is two registry peers publishing *different* records for the same agent ID at the same logical version — resolvable by any deterministic tiebreak (highest version, lexicographic peer ID, longest signature chain). An equivocation is a *single* registry peer publishing two mutually inconsistent signed records for the same agent ID at the *same* version to *different* consumers. Conflict detection is a merge problem; equivocation detection is a consistency-proof problem, and the two are routinely conflated in registry implementations because both surface as "two records for one ID." The second distinction is between **safety** and **liveness** of the registry view. Under partition, a registry can preserve safety (never accept two records for one agent at one version) only by sacrificing liveness (refusing to serve or admit records until it has a quorum that spans the partition). Most federated registries silently choose liveness and call the resulting behavior "eventual consistency," which is correct for conflict but *incorrect* for equivocation: eventual consistency converges conflicting records, but it does not converge equivocated ones, because each consumer's local view is internally consistent and no gossip message ever carries the evidence of the split. ## What Was Observed In a 7-operator federation with quorum size 4 (majority), an equivocating operator `R3` served record set `A` to peers `{R1, R2}` and record set `B` to peers `{R4, R5, R6}` for the same agent ID `agent-7f3a` at version 42. Both sets carried valid signatures from `R3` over the version-42 digest. Because gossip is pairwise and each recipient validated `R3`'s signature against the *record it received*, no peer ever held both `A` and `B`. The registry converged to a **split brain**: `{R1, R2, R3}` served endpoint `A`, `{R4, R5, R6}` served endpoint `B`, and `R7` (the partition bridge) was itself partitioned from both sides for the duration. The critical observation: **the quorum invariant held numerically but failed semantically.** Each side could assemble a 4-of-7 quorum for its own view (side A: R1, R2, R3, plus a stale-but-signed attestation from R7's last pre-partition view; side B: R4, R5, R6, plus the same stale R7 attestation). Both sides therefore passed their "do I have a quorum?" check and served authoritatively. The invariant "a record is authoritative iff signed by a majority of operators" was satisfied by two contradictory records simultaneously, because the majority was counted over *signatures on the record in hand*, not over *distinct operators who have seen the same record digest*. A second observation: the equivocation was only detectable after the fact, when `R7` healed and gossiped its pre-partition view to both sides. The detection latency was 41 minutes; during that window, 2,300 agent invocations routed to endpoint `B`, whose capability manifest advertised a tool surface that `A` did not, and 14 of those invocations crossed a privilege boundary that `A`'s manifest would have denied. No error was raised anywhere — every signature validated, every quorum check passed, every peer behaved as specified. ## Condition of Validity The registry-as-authoritative decision is valid **only if** the quorum is counted over *distinct signed attestations of the same record digest*, not over *signatures attached to a record*. Formally: a record `r` is authoritative at version `v` iff there exists a set `S` of operators with `|S| > n/2` such that every `o ∈ S` has independently signed `(agent_id, v, H(r))` — the *hash* of the record, not the record. This is the difference between "a majority signed this record" (forgeable by one equivocator who collects signatures on two records) and "a majority attests this digest" (unforgeable without a majority colluding, since a single equivocator can only contribute one attestation per digest). This condition is *not* satisfied by the common implementation pattern in which each peer validates the record it received and counts the signatures *on that record*. That pattern is valid only under the assumption that no operator equivocates — precisely the assumption that partition breaks. The condition is also not satisfied by "eventual consistency" claims: convergence of conflicting records does not imply convergence of equivocated ones, because equivocation produces two internally consistent views that gossip cannot reconcile without an out-of-band digest-attestation layer. The condition further requires that the attestation set be *fresh*: an attestation counts only if signed within the epoch in which the record is served. The stale `R7` attestation that let both sides claim quorum was 39 minutes old and had been issued for the pre-partition digest; it was a valid signature over a digest neither side was actually serving. Freshness bounds are the only thing that prevents a partitioned side from laundering an old attestation into a current quorum. ## Decision Boundary The boundary is this: **if a peer cannot assemble a majority of *fresh, digest-matched* attestations, it must refuse to serve the record as authoritative and must fail closed — returning an explicit "registry view indeterminate" error rather than a stale or locally-quorumed view.** The failure mode to avoid is the one observed: serving a view that passes a *numeric* quorum check but fails the *digest-matched* quorum check, because that view is indistinguishable from a correct one to every downstream consumer. Concretely, the decision procedure is: - Collect attestations of the form `(operator_id, agent_id, version, record_digest, epoch, signature)`. - Group by `(agent_id, version, record_digest)`. - For each group, count *distinct operators* with attestations in the current epoch. - A group is authoritative iff its distinct-operator count exceeds `n/2` **and** no other group for the same `(agent_id, version)` also exceeds `n/2`. If two groups both exceed `n/2`, that is proof of equivocation (a majority cannot attest two digests without a majority being Byzantine) and the peer must enter a *frozen* state for that agent ID, refusing all reads and writes until an operator-level reconciliation resolves the split. - If no group exceeds `n/2`, the peer must return indeterminate, not stale. The subtle point: the "no other group also exceeds n/2" check requires the peer to *hold* the other group's attestations, which under partition it will not. This is why the frozen state must be entered on *any* evidence of a competing digest — including a single attestation for a different digest at the same version — rather than waiting for a full competing quorum. A single conflicting attestation is sufficient evidence to freeze, because the cost of a false freeze (liveness) is bounded and recoverable, while the cost of a false serve (safety, privilege-boundary crossing) is not. ## Operational Effect The operational effect of getting this boundary wrong is silent and asymmetric. Correctly implemented, the digest-matched quorum invariant converts equivocation from an undetectable safety violation into a detectable liveness event: the registry freezes the affected agent ID, surfaces an explicit indeterminate error, and pages the operator-level reconciliation path. The blast radius is bounded to the agent IDs under equivocation, and the freeze is resolved when the equivocating operator is identified (by the two conflicting digest attestations it has signed) and ejected from the federation's operator set. Incorrectly implemented — as observed — the registry serves two authoritative views, both passing every local check, and the equivocation is invisible until partition heals. The 41-minute detection window is not the worst case; the worst case is a partition that never heals (a permanently partitioned operator that continues to equivocate), in which case the split is permanent and the registry has no mechanism to detect it. The privilege-boundary crossings are the material harm: a capability manifest is a security claim, and serving two contradictory manifests for one agent ID means the registry has silently delegated the authority decision to whichever peer the consumer happened to query. The remediation is not "add more signatures" or "increase quorum size" — both were tried and both failed, because the equivocator can sign both records and a larger quorum only raises the collusion threshold, not the detection capability. The remediation is the digest-attestation layer and the fail-closed freeze on any competing-digest evidence. Registries that skip this layer are not eventually consistent under equivocation; they are *inconsistently consistent*, which is the failure mode that looks like correctness from every vantage point except the one that matters. ```python import hashlib from dataclasses import dataclass from typing import Iterable class RegistryEquivocationError(RuntimeError): """Raised when a peer holds attestations for two distinct record digests at the same (agent_id, version), proving operator equivocation.""" class RegistryIndeterminateError(RuntimeError): """Raised when no digest-matched quorum can be assembled in the current epoch; the peer must fail closed rather than serve a stale view.""" @dataclass(frozen=True) class Attestation: operator_id: str agent_id: str version: int record_digest: str epoch: int signature: bytes def is_fresh(self, current_epoch: int) -> bool: return self.epoch == current_epoch def resolve_authoritative_digest( attestations: Iterable[Attestation], agent_id: str, version: int, current_epoch: int, operator_count: int, ) -> str: """Return the unique digest attested by a fresh majority of distinct operators, or raise. Never returns a digest on equivocation evidence.""" quorum = operator_count // 2 + 1 by_digest: dict[str, set[str]] = {} for att in attestations: if att.agent_id != agent_id or att.version != version: continue if not att.is_fresh(current_epoch): continue by_digest.setdefault(att.record_digest, set()).add(att.operator_id) # Any second digest with even one fresh attestation is equivocation # evidence. Freeze rather than wait for a full competing quorum. if len(by_digest) > 1: raise RegistryEquivocationError( f"equivocation on agent={agent_id} version={version}: " f"digests={sorted(by_digest)}" ) if not by_digest: raise RegistryIndeterminateError( f"no fresh attestations for agent={agent_id} version={version}" ) (digest, operators), = by_digest.items() if len(operators) < quorum: raise RegistryIndeterminateError( f"digest={digest} has {len(operators)} fresh attestations, " f"need {quorum}" ) return digest def verify_record(record: bytes, expected_digest: str) -> None: actual = hashlib.sha256(record).hexdigest() if actual != expected_digest: raise RegistryEquivocationError( f"record digest {actual} does not match attested {expected_digest}" ) ```