# How does an instance detect revocation of a peer agent identity when the AAIF trust registry partition heals after a split-brain window **Date of Record:** 2026 November 17 **Scope:** Applies to any node participating in an Agent Identity Federation (AAIF) that caches peer identity assertions with a TTL and consumes revocation events from a federated trust registry. Does not apply to single-registry deployments where issuance and revocation share one linearizable log, nor to purely ephemeral agent identities whose lifetime is bounded below the registry's max propagation window. ## Core Distinction The naive model treats revocation as a monotonic tombstone: once a registry publishes `REVOKE(agent_id)`, every node that later syncs sees the tombstone and drops the identity. This fails at exactly one boundary — **the healing edge of a partition**. During a split-brain, the minority registry partition cannot publish revocations for identities it still believes are valid, and the majority partition can publish revocations the minority never sees. When the partition heals, the merge is not a simple union of tombstones. It is a *reconciliation between two divergent validity frontiers*, and the dangerous case is not "revocation was missed" but "revocation was *superseded* by a re-issuance that itself happened inside the minority partition." The non-obvious invariant is this: **a peer identity is safe to trust after healing only if its current assertion is causally dominated by the last revocation the local node has observed for that identity's key lineage — not merely for its agent_id.** Agent IDs are re-issued across key rotations. A revocation against `agent_id=X, key=K1` does not tombstone `agent_id=X, key=K2`, and the registry merge will happily serve a `key=K2` assertion minted in the minority partition during the split. The instance that checks only `agent_id` sees "no revocation for X" and admits a credential the majority partition had revoked under its previous key. ## What Was Observed During a 41-minute registry partition between `aaif-region-b` (minority, 3 of 11 registries) and the rest, an agent `ops-reconciler@tenant-7` was revoked in the majority partition at T+9min for a credential-stuffing incident. The operator's recovery runbook re-minted the agent under a rotated key `K2` inside the minority partition at T+14min, because the minority partition still held a pre-revocation snapshot and considered the identity valid. At T+41min the partitions healed. The merge resolved per-key, not per-agent: the majority's `REVOKE(X, K1)` tombstone and the minority's `ISSUE(X, K2)` assertion were both retained as consistent. Every node that synced after healing saw `K2` as live. The failure surfaced 6 minutes later when a downstream admission controller — which cached `agent_id` → `revoked: false` from a pre-healing sync and used a 300s TTL — admitted `K2` for 287 seconds before its refresh pulled the *merged* view. The merged view still said `K2` was valid. The identity was only actually killed when a human noticed the audit trail. The controller did exactly what its spec said: it checked revocations by `agent_id`, found none for `K2`, and admitted. The tell was in the registry merge logs: `reconcile: agent=X retained 1 tombstone (K1), 1 live assertion (K2), no causal link between them`. The registry had no rule that an `ISSUE` on a rotated key must carry a `supersedes` pointer to prior keys' revocations. It didn't, so the merge couldn't infer one. ## Condition of Validity The per-agent-ID revocation check is valid **only** when the identity's key lineage is immutable for the lifetime of the agent_id — i.e., when key rotation is modeled as a *new* agent_id. In any AAIF where keys rotate under a stable agent_id (the common case, because stable IDs are what policy binds to), the per-ID check is unsound across a healing partition. The correct condition: an instance may trust a peer assertion `(agent_id, key, issued_at)` only if, for **every** key in that agent's lineage with `issued_at < assertion.issued_at`, the local node has observed a revocation-or-supersession record, **or** the registry's signed merge manifest attests that no such key ever existed in a partition the node did not observe. The second clause is the escape hatch: it lets a node that was itself partitioned out trust the majority's merge without replaying full history, provided the manifest is signed by a quorum that includes at least one registry from each side of the split. ## Decision Boundary The boundary is crossed when **the local node's last-observed registry state predates the partition and its next sync postdates the heal**. In that window, the node's cached `revoked` set is a *stale subset* of the true revocation set, and its cached `live` set may contain assertions minted in a partition whose validity the majority never confirmed. The node cannot distinguish "no revocation exists" from "revocation exists but I haven't seen it." Detection requires the node to compare two things it normally never compares: the `issued_at` of the assertion it holds against the `healed_at` timestamp on the registry's merge manifest. If `assertion.issued_at` falls inside `[partition_start, healed_at]` **and** the assertion's key is not the key the node held pre-partition, the node must treat the assertion as *provisional* — usable only for non-mutating operations, and never for privilege escalation — until a full lineage replay confirms no intervening revocation. This is the check that was missing: the admission controller had the manifest (it was in the sync payload) but never read `healed_at`, because its schema didn't model it. ## Operational Effect The practical consequence is that **revocation propagation is not a delivery problem but a lineage-consistency problem**, and the only sound detector is a causal check across key rotations, not a set-membership check on agent_ids. Instances that model revocation as `agent_id ∈ revoked_set` will, on every healing edge, admit exactly the credentials minted during the split under rotated keys — which is precisely the credential an attacker who induced or exploited the partition wants. The fix is to make `supersedes` mandatory on re-issuance, to sign merge manifests with cross-partition quorum, and to make the local admission path refuse assertions whose `issued_at` straddles an unobserved heal without a replayed lineage. Absent all three, the safe default at the healing edge is to fail closed on rotated-key assertions until replay completes — a latency cost paid only at partition heal, which is the correct place to pay it. ```python from dataclasses import dataclass from datetime import datetime class RevocationLineageError(RuntimeError): """Raised when a peer assertion cannot be causally tied to the last observed revocation for its key lineage across a healed partition.""" @dataclass(frozen=True) class PeerAssertion: agent_id: str key_id: str issued_at: datetime @dataclass(frozen=True) class MergeManifest: partition_start: datetime healed_at: datetime cross_partition_quorum: bool def admit_peer( assertion: PeerAssertion, held_key_pre_partition: str, revoked_keys: set[str], manifest: MergeManifest, ) -> bool: if assertion.key_id in revoked_keys: raise RevocationLineageError( f"key {assertion.key_id} for {assertion.agent_id} is revoked" ) straddles_heal = ( manifest.partition_start <= assertion.issued_at <= manifest.healed_at ) rotated = assertion.key_id != held_key_pre_partition if straddles_heal and rotated: if not manifest.cross_partition_quorum: raise RevocationLineageError( f"assertion for {assertion.agent_id} key {assertion.key_id} " f"minted during partition [{manifest.partition_start}.." f"{manifest.healed_at}] under rotated key, and merge manifest " f"lacks cross-partition quorum; lineage replay required" ) # Quorum-signed manifest: provisional admission only. return False # caller must replay lineage before mutating ops return True ```