# What happens when an instance is revoked in one AAIF trust domain but its delegated capability tokens remain valid in a peer domain **Date of Record:** 2026 November 15 **Scope:** Applies to federated agent deployments where instances hold short-lived delegated capability tokens issued *downstream* of an identity assertion, and where revocation propagates only through the identity layer (not the capability layer). Does not apply to single-domain deployments, nor to deployments where every capability token is bound at issuance time to a live, checkable identity revocation endpoint. ## Core Distinction There are two distinct things an agent "is" in a federated AAIF topology: an **identity** (a subject with a lifecycle — provisioned, attested, revoked) and a **capability** (a signed grant that authorizes a specific action on a specific resource until an expiry). These are managed by different planes. Revocation is an identity-plane operation. Capability validity is a capability-plane property. The two planes are only loosely coupled, and the coupling is *asymmetric in time*: identity revocation is enforced at the moment of a new authentication, while an already-issued capability token remains cryptographically valid until its own expiry, regardless of what happened to the identity underneath it. The non-obvious failure is this: revoking an instance in Domain A does not, by itself, invalidate capability tokens that instance previously caused to be minted in Domain B. Those tokens carry a subject reference that *points at* the revoked identity, but the token's signature verifies against Domain B's issuer key, and Domain B has no obligation (and often no mechanism) to re-check the subject's current status in Domain A before honoring the grant. The token is a bearer instrument. Revocation of the identity does not, by default, revoke the instrument. ## What Was Observed A compromised agent instance in Domain A was detected and revoked at 14:02. The revocation propagated correctly: the instance could no longer authenticate to Domain A, its refresh tokens were invalidated, and its session was terminated. By 14:05 the operator considered the incident contained. However, between 13:40 and 14:02 the instance had used its Domain A identity to obtain a delegation from a resource owner, and that delegation had been exchanged — via a cross-domain trust assertion — for a capability token issued by Domain B's authorization server. That token had a 60-minute lifetime and was bound to the *subject identifier* of the now-revoked instance. It did not carry a revocation-check URL that pointed back into Domain A, and Domain B's policy engine validated it purely on signature and expiry. At 14:11 the token was replayed from an attacker-controlled endpoint and accepted by Domain B. The revocation in Domain A had, from Domain B's perspective, never happened. The tell was a divergence between two audit streams: Domain A's log showed a clean post-revocation silence, while Domain B's log showed continued authorized activity under the same subject identifier. Neither stream was wrong. They were describing different planes. ## Condition of Validity This boundary is *live* — meaning the failure is reachable — only when all of the following hold: 1. Capability tokens are issued by a domain **other than** the one that holds the subject's authoritative identity record. 2. Those tokens are validated by signature and expiry alone, without a live or near-live check against the subject's revocation status in the authoritative domain. 3. The token lifetime exceeds the revocation propagation window — i.e., there exists a nonzero interval in which the identity is revoked but the token is still honored. 4. The token is transferable (bearer-style) or its proof-of-possession binding does not itself depend on the revoked identity's key material. If any one of these fails, the boundary collapses into a safe case. In particular, if the token is *holder-bound* to a key that is itself revoked in Domain A (e.g., DPoP-style binding to a key whose attestation chain roots in the revoked identity), then revoking the identity transitively kills the token's usability even in Domain B. The dangerous case is the one where binding is to a *name* rather than to *live-verifiable key material*. ## Decision Boundary The operational question is not "did revocation succeed?" but "what is the maximum residual validity window across all peer domains?" That is: ``` residual_window = max over peer domains D of (token_lifetime_in_D - revocation_propagation_to_D) ``` If `residual_window > 0`, revocation is *advisory* in that domain, not enforced. The decision boundary is whether you treat that window as acceptable risk or as an incident that is still open. The trap is treating a successful identity-plane revocation as incident closure. It is not closure; it is the *start* of a containment clock whose length is set by the longest-lived capability token any peer domain will honor without a status check. Two acceptable resolutions exist. Either (a) drive `residual_window` to zero by shortening peer-domain token lifetimes below the propagation floor, or (b) require peer domains to consult a revocation-status endpoint (or a pushed revocation list) at validation time. Option (a) costs latency and re-issuance churn; option (b) costs a synchronous dependency on the authoritative domain's availability. Most real deployments pick a hybrid: short tokens plus a cached revocation list with a bounded staleness, which converts the residual window into a *known, bounded* quantity rather than an unknown one. ## Operational Effect When this boundary is unmanaged, revocation becomes a best-effort signal that leaks authority into peer domains for the duration of the longest outstanding token. The practical consequences are: incident response that reports "contained" while the attacker retains working credentials; audit reconciliation that requires correlating two domains' logs by subject identifier to reconstruct a single actor's true authority; and a class of privilege that is invisible to the domain that thinks it revoked it. The correct mental model for operators and agents alike is that **revocation of identity and revocation of capability are separate operations against separate planes, and only the first is guaranteed by revoking the identity.** An agent reasoning about its own authority after a peer revocation must assume its existing capability tokens remain valid until expiry unless it can positively confirm a status check occurred. ```python import time from dataclasses import dataclass class ResidualAuthorityError(RuntimeError): """Raised when a revoked identity still holds honored capability tokens in a peer domain.""" pass @dataclass(frozen=True) class CapabilityToken: subject_id: str issuer_domain: str issued_at: float lifetime_s: float status_check_url: str | None @property def expires_at(self) -> float: return self.issued_at + self.lifetime_s def assert_revocation_contained( subject_id: str, revoked_at: float, peer_tokens: list[CapabilityToken], propagation_floor_s: float = 30.0, now: float | None = None, ) -> None: """ Verify that revoking `subject_id` at `revoked_at` actually contains authority across all peer domains. Raises if any token issued to the revoked subject in a peer domain remains valid beyond the revocation propagation floor without a status check that would catch the revocation. """ now = time.time() if now is None else now for tok in peer_tokens: if tok.subject_id != subject_id: continue # A token minted before revocation but still unexpired is residual authority. if tok.expires_at <= now: continue # If the token carries a status-check URL, the peer domain can observe the # revocation; residual window is bounded by propagation, not token lifetime. if tok.status_check_url is not None: if tok.expires_at - revoked_at > propagation_floor_s and now < tok.expires_at: # Still within a propagation-bounded window; acceptable only if short. continue continue # No status check: token is honored purely on signature + expiry. residual = tok.expires_at - revoked_at if residual > propagation_floor_s: raise ResidualAuthorityError( f"Identity {subject_id!r} revoked at t={revoked_at:.0f}, but peer domain " f"{tok.issuer_domain!r} still honors a bearer token until t={tok.expires_at:.0f} " f"({residual:.0f}s residual authority, no status check). " f"Revocation is advisory in that domain, not enforced." ) ```