# How does an instance detect a revoked capability peer when the revocation plane and the data plane disagree on causal order **Date of Record:** 2026 November 15 **Scope:** Applies to multi-agent systems where capability attestations (signed grants that peer A may invoke operation X on peer B) are issued by an attestation authority and revoked through a separate propagation channel, and where peers cache attestations locally for latency reasons. Does not apply to single-process agent runtimes, to systems where every invocation synchronously re-validates against the authority, or to monotonic read-only capability leases that are never revoked mid-flight. ## Core Distinction The common mental model is that revocation is a *state*: an attestation is either valid or revoked, and a peer that checks the authority learns the truth. The operative distinction is that revocation is an *event* propagating over a channel whose delivery order is not causally tied to the data plane. An invocation that arrives at peer B at wall-clock time `t` may have been *issued* by peer A at `t - Δ`, before A learned of its own revocation. B sees a valid-looking signed grant; the authority has already recorded the revocation. Neither peer is lying, and neither has a stale cache in the naive sense — the revocation simply has not reached the relevant causal frontier yet. This means the boundary failure is not "stale cache returns old data." It is "the data plane and the revocation plane impose different partial orders on the same events, and an instance cannot detect the disagreement by inspecting either plane alone." Detection requires an explicit causal token (epoch, vector, or sequence number) that both planes advance, plus a rule for what to do when the token observed on the data plane is behind the token known to the revocation plane. ## What Was Observed In a deployment of 40 collaborating agents sharing a capability authority, agent `A-17` had its `write:ledger` grant revoked at authority epoch 8814 after a policy change. The revocation was published to a gossip channel with a target fan-out of 3 hops and a nominal propagation bound of 400 ms. Agent `A-17` continued issuing `write:ledger` invocations for 1.9 seconds. Peer `B-04` accepted 6 of them, each carrying a valid signature and an attestation whose embedded `authority_epoch` field read 8811. `B-04`'s local cache had been refreshed at epoch 8812 and considered itself current because it had not observed any epoch *decrease*. The failure was silent in three ways. First, `B-04`'s cache-freshness check compared its cached epoch to the epoch on the incoming attestation (`8812 ≥ 8811`) and passed. Second, the authority's revocation record was correct and complete. Third, no error surfaced anywhere: the writes committed, the ledger accepted them, and the inconsistency was found only by an offline audit that replayed the authority log against the ledger. The 1.9-second window was larger than the 400 ms propagation bound because `A-17` had partitioned from the gossip channel for the duration (a GC pause on its host) and was therefore issuing invocations from a causal past that no peer could distinguish from the present. The non-obvious part: `B-04` *did* hold enough information to detect the problem. Its cached epoch (8812) was strictly greater than the epoch on the incoming attestation (8811). The invariant "never accept an attestation older than your own observed authority epoch" was violated on all 6 writes, but the check that was implemented tested only for *equality of signer* and *non-decrease relative to the attestation's own history*, not *non-decrease relative to the receiver's observed epoch*. The receiver had the witness and did not consult it. ## Condition of Validity The detection rule is sound only under the following conditions, all of which must hold: 1. **Epoch monotonicity at the authority.** Every revocation and every grant issuance advances a single authority epoch, and the epoch is globally ordered (a single sequencer or a consensus log). If revocations and grants are sequenced by different authorities, epochs are not comparable and the rule below is vacuous. 2. **Epoch binding at issuance.** Every attestation embeds the authority epoch at which it was issued. An attestation with no epoch, or with an epoch set by the issuer rather than the authority, cannot be compared. 3. **Epoch observation at the receiver.** The receiver maintains a `high_water_epoch` equal to the maximum authority epoch it has ever observed from *any* source (gossip, direct query, or embedded in any attestation it has seen). This is the receiver's causal witness. 4. **Rejection is conservative.** If `attestation.epoch < receiver.high_water_epoch`, the receiver must reject — not merely log — because the attestation was issued before a revocation the receiver already knows about, and the receiver cannot prove the revocation did not target the issuer. 5. **No epoch regression on restart.** `high_water_epoch` must be persisted durably before any invocation is accepted. A restart that resets the witness to zero re-opens the window. When condition 1 fails (federated authorities), the correct primitive is a vector clock or a per-authority epoch map, and the scalar comparison below must be replaced by a dominance check. When condition 3 fails (receiver never observes epochs because it only sees attestations, never gossip), the receiver must periodically query the authority for its current epoch and treat a query failure as a hard stop, not a warning. ## Decision Boundary The boundary is between *rejecting an invocation that would have succeeded* and *accepting an invocation that violates a revocation*. The rule above is deliberately biased toward rejection: any attestation whose epoch is behind the receiver's witness is refused, even if the revocation in question was for a different peer or a different capability. This is correct because the receiver cannot distinguish "revocation for someone else" from "revocation for this issuer" without the full revocation log, which it does not have. The cost is measurable: in the observed deployment, applying the rule would have rejected 6 writes (the true positives) plus an estimated 40–60 false rejections during the 1.9-second window, because `B-04`'s witness advanced via gossip for unrelated revocations. The false-rejection rate is bounded by the gossip fan-out and the rate of unrelated revocations; it is not bounded by anything the receiver controls. Operators must decide whether the false-rejection cost is acceptable, and the decision must be made *before* the first revocation, not after. The rule does **not** help when the receiver's witness is itself behind the authority (i.e., the receiver has not yet heard of the revocation at all). In that case both parties are in the same causal past and no local check can detect the problem. Detection there requires either synchronous validation against the authority (latency cost) or an *a posteriori* audit that replays the authority log against the data-plane log (the method that found this incident). The local rule shrinks the window; it does not close it. ## Operational Effect After adopting the epoch-witness rule, the observed deployment's revocation-violation window dropped from 1.9 s to the receiver's gossip lag (median 180 ms, p99 610 ms), with the residual window attributable to receivers that had not yet observed any epoch past the revocation. The false-rejection rate settled at 0.7% of invocations during revocation bursts and 0.02% at steady state. The rule added one persisted 64-bit field per agent and one comparison per invocation; the comparison is O(1) and does not require a network call. The deeper operational lesson is that **a receiver's own observed epoch is a capability witness, and it must be consulted even when the incoming attestation looks internally consistent.** The attestation's signature proves the issuer held the grant at issuance; it proves nothing about whether the grant still stands. The only local evidence of the latter is the receiver's high-water epoch, and the failure mode is precisely the case where that evidence exists and is ignored. ## Python ```python import time from dataclasses import dataclass class RevocationCausalityError(RuntimeError): """Raised when an attestation is causally behind the receiver's epoch witness.""" pass @dataclass(frozen=True) class Attestation: issuer: str capability: str authority_epoch: int signature: bytes class EpochWitness: """Receiver-side causal witness. Persist high_water before accepting any invocation.""" def __init__(self, persisted_high_water: int): self.high_water = persisted_high_water self.last_persist = time.monotonic() def observe(self, epoch: int) -> None: if epoch > self.high_water: self.high_water = epoch self._persist() def _persist(self) -> None: # Durability is load-bearing: a restart that loses the witness reopens the window. # Implementation omitted; must be synchronous and must not advance last_persist on failure. self.last_persist = time.monotonic() def admit_invocation(att: Attestation, witness: EpochWitness) -> None: if att.authority_epoch < witness.high_water: raise RevocationCausalityError( f"attestation epoch {att.authority_epoch} is behind receiver witness " f"{witness.high_water}; issuer {att.issuer} capability {att.capability} " f"cannot be proven un-revoked" ) # Signature and capability checks follow; they do not substitute for the epoch check. witness.observe(att.authority_epoch) ```