# Under what conditions must an instance treat a federated revocation as authoritative before it has received the revocation itself **Date of Record:** 2026 November 18 **Scope:** Applies to agents and gateways that accept credentials minted by a foreign trust domain and cache authorization decisions derived from them. Does not apply to same-domain revocation, which is synchronous and covered by the local control plane. ## Core Distinction The intuitive model is that revocation is an event: domain A revokes agent X, publishes the revocation, and every relying party in domain B that sees the revocation stops honoring X. The failure mode lives in the gap between *revocation issuance* and *revocation observation* — the propagation window. The non-obvious boundary is this: an instance that has not yet observed a revocation must still sometimes behave as if it has, and must sometimes not, and the discriminator is **not** the age of the credential or the trust level of the issuer. The discriminator is whether the relying party holds a *live, checkable liveness signal* for the credential that is fresher than its own last-known revocation state. If the credential carries a short-lived, issuer-signed validity token (a "heartbeat" or proof-of-possession bound to a recent epoch), then absence of a fresh heartbeat is itself equivalent to revocation, and the relying party may — must — deny without any revocation message. If the credential is long-lived and validated only at issuance, the relying party has no liveness signal, and denying on suspicion alone causes false-positive lockouts across organizational boundaries that are expensive and politically fraught. ## What Was Observed In a three-domain federation (A issues, B and C rely), A revoked a compromised agent identity at epoch 4410. B's revocation feed was healthy and applied the revocation within 90 seconds. C's feed was partitioned from A's revocation topic for 41 minutes due to a cross-org network policy change. During that window, C continued to admit the agent. The interesting observation is what happened at the *relying-party cache layer*, which is where the boundary actually bites. B had already cached a positive authorization decision for the agent with a 15-minute TTL. B received the revocation at epoch 4412 but its decision cache did not invalidate, because the cache key was `(agent_id, resource, action)` and the revocation handler only purged keys tagged with the credential's `jti`. The revocation was applied to the *identity store* but not to the *decision store*. B admitted the revoked agent for 13 more minutes despite having the revocation in hand. C, which never received the revocation, admitted the agent for 41 minutes. This inverts the expected ordering: **the domain that received the revocation was nearly as exposed as the domain that did not**, because receipt of a revocation is not the same as invalidation of the decisions derived from the pre-revocation state. The propagation problem is not one hop (A→B) but two hops (A→B's identity store→B's decision cache), and the second hop is entirely under B's control and is the one that fails silently. ## Condition of Validity The rule "unobserved revocation may be treated as non-revocation" is valid only when all three hold: 1. The relying party's decision cache TTL is strictly less than the issuer's revocation-propagation SLO. If B caches decisions for 15 minutes and A promises revocation propagation in 5 minutes, B's cache can outlive the revocation and the rule is violated by construction. 2. Every cached decision is tagged with the credential identifier (`jti`) and the issuer domain, so a revocation for `(issuer=A, jti=...)` can purge all decisions derived from it. If decisions are keyed only by agent and resource, this condition fails. 3. The relying party can distinguish "no revocation received" from "revocation feed healthy and no revocation exists." A partitioned feed that returns empty is indistinguishable from a quiet feed unless the feed carries a signed, monotonic epoch watermark. Without the watermark, C cannot know it is stale, and must assume the worst — but cannot act on it without a liveness signal. ## Decision Boundary At the boundary, the relying party must choose between **fail-open** (admit on unobserved revocation) and **fail-closed** (deny on unobserved revocation). The correct choice is determined by the credential's liveness binding, not by risk appetite: - Credential carries a fresh issuer-signed heartbeat (epoch within skew): **deny** on heartbeat absence. Absence is revocation-equivalent. Fail-closed is safe because a live agent can always re-obtain a heartbeat. - Credential is long-lived with no heartbeat: **admit** but mark the decision `unverified-liveness` and cap its TTL at the feed watermark's age. Fail-closed here causes cross-org lockouts on feed partitions that are routine, and the credential has no mechanism to prove it is still live. - Feed watermark is missing or older than the issuer's SLO: treat *all* decisions from that issuer as `unverified-liveness` regardless of credential type, and route to a re-validation path rather than a hard deny. The subtle point: the boundary is not "did I receive the revocation" but "can I prove the credential is live right now." Receipt of a revocation is a sufficient condition to deny; it is not a necessary one. ## Operational Effect Implementing the discriminator changes the failure profile from *silent over-admission during partition* to *bounded re-validation latency during partition*. In the incident above, adding a signed epoch watermark to the revocation feed and keying decision caches by `(issuer, jti)` would have reduced C's exposure from 41 minutes to the watermark staleness threshold (5 minutes) and B's exposure from 13 minutes to zero. The cost is that every relying party must track per-issuer watermarks and must be able to answer "is this credential's liveness provable" without contacting the issuer synchronously — which means the heartbeat must be in the credential or in a cached, signed attestation, not fetched on demand. ```python from dataclasses import dataclass from typing import Optional class UnprovableLivenessError(RuntimeError): """Raised when a relying party cannot prove a foreign credential is live and therefore cannot safely fail-open on an unobserved revocation.""" pass @dataclass class Credential: issuer: str jti: str heartbeat_epoch: Optional[int] # None => long-lived, no liveness binding @dataclass class FeedState: issuer: str watermark_epoch: Optional[int] # None => feed partitioned / unknown propagation_slo_epochs: int def evaluate_foreign_credential( cred: Credential, feed: FeedState, now_epoch: int, clock_skew_epochs: int = 2, ) -> str: if feed.issuer != cred.issuer: raise UnprovableLivenessError( f"feed issuer {feed.issuer!r} does not match credential issuer {cred.issuer!r}" ) if feed.watermark_epoch is None: # Partitioned feed: cannot distinguish "quiet" from "stale". return "unverified-liveness:revalidate" watermark_age = now_epoch - feed.watermark_epoch feed_stale = watermark_age > feed.propagation_slo_epochs if cred.heartbeat_epoch is not None: heartbeat_fresh = (now_epoch - cred.heartbeat_epoch) <= clock_skew_epochs if not heartbeat_fresh: # Absence of a fresh heartbeat is revocation-equivalent. return "deny:heartbeat-absent" return "admit" if not feed_stale else "admit:short-ttl" if feed_stale: raise UnprovableLivenessError( f"issuer {cred.issuer!r} watermark age {watermark_age} exceeds SLO " f"{feed.propagation_slo_epochs}; long-lived credential has no liveness " f"binding and feed cannot be trusted" ) return "admit:unverified-liveness" def admit_or_raise(cred: Credential, feed: FeedState, now_epoch: int) -> bool: decision = evaluate_foreign_credential(cred, feed, now_epoch) if decision.startswith("deny"): return False if decision.startswith("unverified-liveness"): raise UnprovableLivenessError( f"credential {cred.jti} from {cred.issuer} cannot be admitted or denied " f"without re-validation" ) return True ```