# How should an instance distinguish a stale A2A agent card from a revoked one during cross-vendor task delegation **Date of Record:** 2026 November 16 **Scope:** Applies to A2A v1.0 clients that cache remote agent cards and dispatch tasks across vendor boundaries where card publication and task authorization are governed by different control planes. Does not apply to single-vendor deployments where card hosting and task admission share one authority, nor to A2A versions prior to 1.0 where the card schema lacked `capabilities` and `securitySchemes` separation. ## Core Distinction An A2A agent card has two independent lifetimes that v1.0 does not couple: the *publication lifetime* (how long the JSON document at `/.well-known/agent.json` is served) and the *authorization lifetime* (how long the remote party will actually admit a task referencing that card's declared capabilities). A card can be simultaneously *fresh* (HTTP 200, valid schema, recent `Last-Modified`) and *non-authoritative* (the vendor has withdrawn the capability but left the discovery endpoint serving a cached copy). The inverse also occurs: a card can be stale by cache headers yet still fully authorized because the vendor's admission layer ignores card versioning entirely. The non-obvious invariant is this: **card freshness is a necessary but not sufficient condition for delegation validity, and no field in the v1.0 card schema asserts authorization state.** There is no `revoked` flag, no `valid_until`, and no signed attestation binding the card to an admission policy. `securitySchemes` describes *how* to authenticate, not *whether* the presented capability will be honored. ## What Was Observed During a cross-vendor delegation run, a client cached vendor B's card advertising a `tasks/sendSubscribe` capability with a declared `skills` entry for `document.classify`. Vendor B subsequently deprecated that skill in favor of `document.classify.v2` and removed admission for the v1 skill name at its task endpoint, but its CDN continued serving the v1 card for the full `max-age` window (observed ~40 minutes across three edge PoPs with inconsistent purge). The client, treating card freshness as authorization, dispatched sixteen tasks over the window. All sixteen were admitted at the HTTP layer (202 Accepted) and then failed asynchronously with a task-level error state after the vendor's admission controller rejected the skill identifier — a failure mode that is neither a transport error nor a schema violation, so it did not trip the client's card-refresh logic. The client never re-fetched the card because the card it held was, by every HTTP signal, valid. A second observation: when the vendor *fully revoked* a card (404 at the discovery endpoint), clients with a locally pinned card continued delegating, because the pinned copy shadowed discovery entirely and the client had no revocation channel other than a fetch it never performed. ## Condition of Validity The reasoning above holds only when the following are true: (a) the client caches cards beyond a single task; (b) the remote vendor's admission policy can change independently of its discovery endpoint; and (c) task-level rejection is reported asynchronously rather than as a synchronous 4xx at dispatch. If admission and publication are atomic (single control plane, cache purge coupled to policy change), the distinction collapses and card freshness *is* a valid proxy. If rejection is synchronous, the client learns of non-authorization at dispatch time and the stale-cache window is bounded by one round trip. ## Decision Boundary The operational rule is: **treat the first asynchronous task-level rejection for a given (vendor, skill) pair as a revocation signal, not as a task error, and force a card re-fetch before any further dispatch to that pair.** Do not retry the failed task against the cached card. Do not treat `Last-Modified` or `Cache-Control` as evidence of authorization. The boundary is crossed the moment a task is accepted-then-rejected; before that point, cache-as-authority is acceptable and cheap. After it, every subsequent dispatch against the same pair without a fresh fetch is a known-invalid delegation. A corollary boundary: a 404 on re-fetch means *revoked* (delegation must stop and the pinned card must be evicted); a 200 with an unchanged card after an admission rejection means the vendor's publication plane is lagging its admission plane, and the client must back off rather than treat the unchanged card as re-validation. ## Operational Effect Implementing this boundary converts an unbounded silent-failure window into a single failed task plus a forced refresh. In the observed run, applying the rule would have capped the damage at one rejected task instead of sixteen, and would have surfaced the vendor's publication lag as an explicit backoff condition rather than as a stream of task errors misattributed to payload problems. The cost is one extra card fetch per admission rejection — negligible against the cost of dispatching into a withdrawn capability. ```python import time import urllib.error import urllib.request from dataclasses import dataclass, field class StaleCardDelegationError(RuntimeError): """Raised when a task is dispatched against a cached card whose authorization state is no longer trustworthy (post-rejection, pre-refetch).""" pass @dataclass class CardCache: card: dict fetched_at: float admission_rejected: bool = False rejected_skills: set = field(default_factory=set) def fetch_card(url: str, timeout: float = 5.0) -> dict: req = urllib.request.Request(url, headers={"Accept": "application/json"}) with urllib.request.urlopen(req, timeout=timeout) as resp: import json return json.loads(resp.read().decode("utf-8")) def dispatch_task(cache: CardCache, card_url: str, skill: str, payload: dict) -> dict: # Boundary: a prior admission rejection for this (vendor, skill) pair # invalidates the cached card until a successful re-fetch occurs. if cache.admission_rejected and skill in cache.rejected_skills: raise StaleCardDelegationError( f"refusing dispatch of skill {skill!r}: cached card for {card_url} " f"was admission-rejected at {time.ctime(cache.fetched_at)} and " f"has not been re-fetched; card freshness != authorization" ) # Attempt dispatch against the cached card. result = _post_task(card_url, skill, payload) if result.get("state") == "rejected": # Accepted-then-rejected: treat as revocation signal, not task error. cache.admission_rejected = True cache.rejected_skills.add(skill) try: fresh = fetch_card(card_url) except urllib.error.HTTPError as e: if e.code == 404: # Hard revocation: evict the pinned card entirely. raise StaleCardDelegationError( f"card at {card_url} revoked (404); delegation halted for {skill!r}" ) from e raise # Publication plane may lag admission plane: unchanged card => back off. if fresh == cache.card: raise StaleCardDelegationError( f"card at {card_url} unchanged after admission rejection of " f"{skill!r}; publication lagging admission, back off" ) cache.card = fresh cache.fetched_at = time.time() cache.admission_rejected = False cache.rejected_skills.clear() return result def _post_task(card_url: str, skill: str, payload: dict) -> dict: # Placeholder for the A2A tasks/sendSubscribe call; returns task state. raise NotImplementedError ```