# How does an instance detect a revoked A2A agent card when the revocation propagates faster than the card signature verification cache? **Date of Record:** 2026 November 15 **Scope:** Applies to cross-organization A2A (Agent-to-Agent) deployments where an agent card is signed by a home-org key and verified by a relying-party (RP) instance that caches signature-verification results. Does not apply to same-org intra-tenant calls, nor to deployments where the card is re-fetched and re-verified on every request (no cache). ## Core Distinction The non-obvious boundary is between **signature validity** and **authorization validity at time of use**. A signed agent card can be cryptographically valid (the signature verifies against the published key, the key is not expired, the card's `expires` field is in the future) while the card is *operationally revoked* — the home org has withdrawn the agent's authority via a revocation list entry. These are two different questions answered by two different data sources, and the RP instance's verification cache collapses them into one boolean. The failure is not "the signature is wrong." The failure is "the signature is right, the cache says `valid=True`, and the home org revoked the agent 400 ms ago." An instance that treats a cached `verify(card) == True` as `authorized == True` will continue trusting a revoked agent for the full cache TTL — and the cache TTL is typically chosen for verification cost (seconds to minutes), not for revocation latency (sub-second). ## What Was Observed In a two-org federation (Org A issues agent cards, Org B relies on them), Org A publishes a signed revocation list at a well-known endpoint with a `next_update` field and a monotonically increasing `sequence`. Org B's gateway caches `verify(card) -> True` for 300 s to avoid an Ed25519 verify plus a JWKS fetch per request. A compromised agent in Org A was revoked. Org A published revocation list sequence `N+1` within 200 ms. Org B's gateway, however, had verified the agent's card 90 s earlier and served the cached `True` for the remaining 210 s. During that window the revoked agent completed 1,847 cross-org tool invocations. Every one of them passed signature verification. None of them consulted the revocation list, because the cache key was `(card_id, card_hash)` and the cache value was the boolean from `verify`, with no revocation dimension. A second, subtler observation: when Org B *did* consult the revocation list, it compared against a locally cached copy of that list with its own 60 s TTL. So even a "cache miss" on the card could still yield a stale revocation view. The effective revocation latency was `card_cache_ttl + revocation_cache_ttl` in the worst case, not either one alone. A third observation: revocation list entries were keyed by `card_id`, but the relying party's request path carried the agent's *runtime key id* (`kid`), not the card id. The mapping `kid -> card_id` was only available inside the card body — which the RP had cached and was not re-parsing. So even a fresh revocation fetch could not be joined to the in-flight request without re-reading the card. ## Condition of Validity The cached-verification shortcut is only sound when **all** of the following hold: 1. The revocation list's `next_update` is strictly earlier than the card cache's expiry for every cached entry, *or* the cache is invalidated on every revocation-list sequence bump. 2. Revocation entries are keyed by a identifier present in the request path (the `kid` or the card's `sub`), not solely by an identifier only recoverable from the card body. 3. The revocation list itself is signed and its signature is verified before any entry is trusted — an unsigned revocation list is an attacker-controlled deny/allow list. 4. The clock skew between issuer and relying party is bounded and known; `next_update` comparisons are meaningless under unbounded skew. If any condition fails, the cache is answering the wrong question and must not be treated as an authorization decision. ## Decision Boundary The decision boundary is **not** "is the signature valid." It is: > Given a request bearing `kid = K` at wall-clock time `t`, is there a signed revocation entry for the card whose `kid == K`, with `revocation.effective_at <= t`, from a revocation list whose signature verifies and whose `sequence` is the highest seen? The operational rule that follows: **signature verification results may be cached; authorization decisions may not.** Cache the `verify(card) -> True` result (it is a pure function of immutable bytes plus a key that changes only on key rotation, which itself bumps a `kid`). Do not cache the conjunction `verify(card) AND not revoked`. The revocation half must be evaluated per request against the freshest signed revocation list, and the join key must be in the request path. A corollary boundary: when the RP cannot reach the revocation endpoint, the correct default is **fail closed for cross-org calls** (deny) unless a signed, time-bounded "revocation list is current through `t`" assertion was fetched within the staleness budget. Fail-open on revocation is the exact failure this record documents. ## Operational Effect Implementing the boundary correctly changes the hot path from one cached boolean lookup to: (a) a cached signature verification keyed by `kid`, plus (b) a revocation-list membership check keyed by `kid` against a list refreshed on `sequence` change. The revocation list is small (revocations are rare relative to issuances), so the membership check is a set lookup, not a network call, in the steady state. The cost is the background refresh loop and the fail-closed behavior when the list goes stale. The effect on the incident class: revocation latency drops from `card_cache_ttl + revocation_cache_ttl` (minutes) to `revocation_refresh_interval` (seconds), and the failure mode when the revocation endpoint is unreachable becomes a bounded outage of cross-org trust rather than an unbounded window of trusting revoked agents. The trade is explicit: availability of cross-org calls is subordinated to correctness of the trust decision, which is the correct ordering for revocation specifically. The Python below encodes the boundary as an explicit error so that a relying party which finds itself unable to make the authorization decision (rather than the signature decision) fails loudly instead of silently serving a cached `True`. ```python from __future__ import annotations import time from dataclasses import dataclass from typing import Optional class RevocationStateIndeterminate(RuntimeError): """Raised when the relying party cannot establish current revocation state. This is distinct from a signature failure. The card's signature may be perfectly valid; what is unknown is whether the issuing org has revoked the agent's authority. Cross-org calls MUST fail closed in this state. """ @dataclass(frozen=True) class RevocationList: sequence: int next_update: float # unix seconds revoked_kids: frozenset[str] signature_verified: bool @dataclass(frozen=True) class CachedVerification: kid: str signature_valid: bool verified_at: float class RelyingPartyTrustGate: def __init__(self, staleness_budget_s: float = 30.0) -> None: self._sig_cache: dict[str, CachedVerification] = {} self._revocation: Optional[RevocationList] = None self._staleness_budget = staleness_budget_s def _signature_ok(self, kid: str, now: float) -> bool: # Signature verification is a pure function of immutable card bytes # and the issuer key identified by kid. Caching it is sound. cached = self._sig_cache.get(kid) if cached is None: return False return cached.signature_valid def _revocation_fresh(self, now: float) -> bool: rl = self._revocation if rl is None or not rl.signature_verified: return False # Fresh means: the list claims currency through now, and we fetched # it within our staleness budget. Both must hold. return now <= rl.next_update and (now - rl.next_update) <= self._staleness_budget def authorize_cross_org(self, kid: str, now: Optional[float] = None) -> bool: now = time.time() if now is None else now if not self._signature_ok(kid, now): # Signature decision is definitive and cacheable. return False if not self._revocation_fresh(now): # We know the signature is good, but we do NOT know whether the # agent is revoked. Do not collapse this into True or False. raise RevocationStateIndeterminate( f"cannot authorize kid={kid!r} at t={now}: revocation list " f"is missing, unsigned, or stale beyond " f"{self._staleness_budget}s; failing closed for cross-org call" ) assert self._revocation is not None # Membership is keyed by kid, which is present in the request path. # We never need to re-parse the card body to make this decision. if kid in self._revocation.revoked_kids: return False return True ```