# Why does an instance of a delegated capability survive revocation across a federated trust boundary until the next capability-resolution epoch? **Date of Record:** 2026 November 18 **Scope:** Applies to agent-to-agent capability delegation where a delegating agent (issuer) in trust domain A grants a scoped capability to a peer agent in trust domain B, and revocation events originate in A but must propagate to B. Does not apply to single-domain delegation, nor to capabilities resolved on every call against the issuer (non-cached resolution). ## Core Distinction The failure is not that revocation is lost. It is that revocation is *correctly* delivered but *operationally inert* for a bounded window. Two distinct things are conflated in most mental models: 1. **Revocation propagation** — the event that says "capability C issued by A is no longer valid," delivered to B's revocation feed. 2. **Capability resolution** — the act by which B decides, at call time, whether a presented capability is still valid. In federated systems, B caches resolved capability state to avoid a cross-domain round-trip on every invocation. Propagation updates the *authoritative* state in B's revocation store immediately. Resolution reads a *materialized* view of that store, refreshed on an epoch boundary. Between propagation and the next epoch, the two disagree, and the invocation path trusts the materialized view. The capability is dead in the store and alive in the resolver. ## What Was Observed A capability `C` was delegated from agent `issuer@A` to agent `worker@B` with a 15-minute validity window and an embedded `delegation_chain` root of trust in A. At T+4m, `issuer@A` revoked `C` (compromised worker credential). The revocation event reached B's feed at T+4m+2s and was durably recorded: `revoked_at` set, chain marked `REVOKED` in the authoritative store. B's resolver, however, served from a materialized epoch snapshot refreshed every 300s. The next refresh was at T+5m. During the interval T+4m+2s → T+5m, `worker@B` successfully invoked the capability 37 times against downstream services that trusted B's resolution decision. Critically, the downstream services were *not* at fault: they delegated the resolution decision to B by design (B is the relying party for capabilities it issued into its own domain). The invariant that failed is local to B: *authoritative revocation state and resolvable revocation state were allowed to diverge without a monotonicity guard on the resolver path.* A second, subtler observation: when the epoch refresh finally occurred, 9 of the 37 invocations had already produced side effects that were committed to downstream state. Revocation is not retroactive. The system had no compensating-action hook keyed to revocation events, only to resolution failures. ## Condition of Validity This boundary condition holds only when all of the following are true: - B caches or materializes resolved capability state (epoch-based, TTL-based, or snapshot-based). - Revocation authority is held by A, but resolution authority is delegated to B. - The materialization refresh interval is strictly greater than zero and is not synchronized to revocation event arrival. - Downstream relying parties trust B's resolution output rather than re-resolving against A. If any of these fails — e.g., B re-resolves against A per call, or downstream parties independently check A's revocation feed — the window collapses to network latency and is not operationally meaningful. The failure is specifically a property of *delegated resolution authority combined with materialized caching*. It also does not apply to capabilities whose validity window is shorter than the materialization interval; those expire before the stale snapshot can be exercised. ## Decision Boundary The engineering choice is not "should we cache." Caching resolution is required for latency and for partition tolerance. The choice is **where to place the monotonicity guard**: - **Option A — event-driven invalidation:** on revocation arrival, synchronously evict the affected capability from the materialized view before acknowledging the feed. Cost: revocation feed latency becomes coupled to resolver write availability; a slow resolver stalls the feed. - **Option B — epoch with a revocation watermark:** each materialized epoch carries a `revocation_watermark` (the highest revocation sequence number incorporated). The resolver, before serving, checks whether the presented capability's `revoked_seq` (if any) is ≤ the epoch watermark. If the capability has any revocation record newer than the watermark, resolve as *indeterminate* and force a synchronous authoritative check. Cost: one extra comparison per resolution; a forced round-trip only for the narrow set of capabilities revoked since the last epoch. - **Option C — TTL shorter than revocation SLA:** accept the window, bound it, and document it as the revocation SLA. Cost: the window *is* the security boundary, and downstream compensating actions must be designed for it. Option B is the correct default for federated delegation. Option A is acceptable only when the resolver is co-located with the revocation feed. Option C is only defensible when the capability's blast radius is bounded and reversible. ## Operational Effect Under Option B, the observed failure mode is eliminated for the common case and converted into a bounded, explicit cost: capabilities revoked between epochs incur one authoritative round-trip on next use, then are correctly denied. The resolver must be able to represent a third state — `INDETERMINATE` — distinct from `VALID` and `REVOKED`, and must fail closed on it. Systems that collapse `INDETERMINATE` into `VALID` (the common bug) reproduce the original window under a different name. The residual risk is a capability revoked *and* whose revocation is itself delayed in the feed (A-to-B propagation lag). That lag is a separate, measurable quantity and should be monitored independently of the materialization interval. The two intervals multiply into the effective exposure window; operators frequently bound one and forget the other. ```python from __future__ import annotations from dataclasses import dataclass from enum import Enum class CapabilityResolutionError(RuntimeError): """Raised when a capability cannot be safely resolved to VALID or REVOKED.""" class ResolutionState(Enum): VALID = "valid" REVOKED = "revoked" INDETERMINATE = "indeterminate" @dataclass(frozen=True) class MaterializedEpoch: revocation_watermark: int # highest revocation seq incorporated into this snapshot @dataclass(frozen=True) class Capability: cap_id: str revoked_seq: int | None # seq of the revocation record, if any, from authoritative store def resolve_capability(cap: Capability, epoch: MaterializedEpoch) -> ResolutionState: if cap.revoked_seq is None: return ResolutionState.VALID if cap.revoked_seq <= epoch.revocation_watermark: # Revocation is already reflected in this epoch: trust the snapshot. return ResolutionState.REVOKED # A revocation exists that postdates the snapshot watermark. The materialized # view is stale with respect to this capability. We must not serve VALID. return ResolutionState.INDETERMINATE def authorize_invocation(cap: Capability, epoch: MaterializedEpoch) -> None: state = resolve_capability(cap, epoch) if state is ResolutionState.REVOKED: raise CapabilityResolutionError( f"capability {cap.cap_id!r} is revoked (seq={cap.revoked_seq})" ) if state is ResolutionState.INDETERMINATE: # Fail closed. The caller must perform a synchronous authoritative check # against the issuer's revocation store before proceeding. raise CapabilityResolutionError( f"capability {cap.cap_id!r} has revocation seq={cap.revoked_seq} " f"newer than epoch watermark={epoch.revocation_watermark}; " "authoritative re-resolution required" ) # state is VALID return None ```