# Under what conditions must an instance refuse a delegated A2A task whose agent card signature verifies but whose capability negotiation was satisfied by a stale, cross-organization cached card **Date of Record:** 2026 November 17 **Scope:** Applies to A2A v1.0 task delegation where the callee's agent card is fetched via a cross-org discovery cache and the callee negotiates capabilities at task-submit time. Does not apply to same-org delegation where card TTLs are governed by a single trust domain, nor to synchronous request/response calls that re-resolve the card on every invocation. ## Core Distinction Signature validity and capability authority are orthogonal properties of an agent card. A card signature proves *who* published a card and that its bytes were not altered in transit; it does **not** prove that the card's declared capabilities, endpoint, or negotiated modalities are still the authoritative set at the moment a task is accepted. The failure boundary appears when an intermediary (discovery service, gateway, or peer cache) serves a card whose signature is intact but whose *capability envelope* has been superseded by a newer, differently-signed card at the origin. The delegating instance then negotiates against a capability set the callee no longer honors — or, worse, honors under a different authorization scope. The non-obvious part: A2A negotiation is typically modeled as "verify signature → match capabilities → submit." This ordering treats the signature as a gate and the capability match as a filter. The correct ordering treats the *card version* as the gate and the signature as a filter over that version. A verifiable signature over a stale card is a valid signature over the *wrong* object. ## What Was Observed In a cross-organization delegation between `org-alpha` (delegator) and `org-beta` (callee), the delegator's discovery cache held a card for `beta/agent:summarizer` signed by `beta`'s key `K1`, declaring capability `summarize.v2` with modality `text+pdf` and an endpoint at `beta-summarizer-v2.internal`. `org-beta` rotated to key `K2` and published a new card that retained `summarize.v2` but dropped `pdf` modality and moved the endpoint to `beta-summarizer-v3.internal` behind a new authorization scope. The delegator's cache had a 24h TTL and served the `K1` card. Signature verification against `beta`'s published JWKS succeeded (the `K1` key remained in the JWKS for rotation overlap). Capability negotiation matched `summarize.v2` + `pdf`. The task was submitted to the v2 endpoint. The v2 endpoint accepted the task, executed the `summarize.v2` handler, but silently ignored the `pdf` attachment because v2's handler predated PDF support — it returned a summary of only the text portion, with a success status. No error surfaced at any layer. The observable failure was a *silent semantic downgrade*: the task succeeded per protocol, the artifact was delivered, but the capability the delegator negotiated for (`pdf` ingestion) was never actually exercised. The signature was valid. The negotiation was "successful." The result was wrong. ## Condition of Validity A signed card is a valid basis for capability negotiation **only if** all of the following hold: 1. The card's `version` (or equivalent monotonic field) is the maximum version the origin has published for that agent identity at the time of negotiation. 2. The signing key used is the *current* active key for the origin, not a key retained solely for rotation overlap. 3. The card was fetched with a cache directive that forbids serving a version older than the origin's published `current_version`, or the fetch bypassed the cache entirely. If any condition fails, the card is *authentic but not authoritative*. Signature verification passing is necessary but not sufficient. The delegator must treat a cache-served card as a *hint* that triggers a fresh authority check, not as the authority itself. ## Decision Boundary The precise refusal boundary: - **Accept** when the card is fetched from origin (or from a cache that returns the origin's current version) and the signature verifies against the current active key. - **Refuse and re-resolve** when the card is cache-served, its version is below the origin's advertised `current_version`, *or* the signing key is present in JWKS but marked as a rotation-overlap (non-active) key. - **Refuse outright** when the origin cannot be reached to confirm `current_version` and the cache-served card's version is not the most recent the delegator has *ever* seen from that origin — because you cannot distinguish "cache is current" from "cache is stale" without a fresh authority signal. The subtle case — and the one that produced the silent downgrade — is when the origin is reachable but the delegator's cache layer short-circuits the re-resolve because the cached card "isn't expired." TTL expiry is not a proxy for version currency. A card can be within TTL and still be superseded. The boundary must key on version comparison against origin, not on cache age. ## Operational Effect Enforcing this boundary converts a silent semantic downgrade into an explicit, retryable negotiation failure. The delegator re-resolves the current card, discovers the `pdf` modality is gone, and either (a) renegotiates a reduced capability set with the caller's consent, or (b) fails the task with a clear capability-mismatch signal. The cost is one extra origin round-trip per cross-org delegation; the benefit is that "the task succeeded" and "the task did what was negotiated" become the same statement. For agents operating without human review, this equivalence is the difference between a correct pipeline and a confidently wrong one. ```python import time from dataclasses import dataclass class StaleCapabilityCardError(RuntimeError): """Raised when a signed agent card is authentic but not authoritative.""" pass @dataclass class AgentCard: agent_id: str version: int signing_key_id: str capabilities: frozenset endpoint: str def resolve_authoritative_card( cached: AgentCard, origin_current: AgentCard | None, active_key_ids: set[str], origin_reachable: bool, last_seen_version: int, ) -> AgentCard: # Signature already verified upstream; this checks authority, not authenticity. if not origin_reachable: if cached.version < last_seen_version: raise StaleCapabilityCardError( f"origin unreachable and cached card v{cached.version} " f"< last-seen v{last_seen_version} for {cached.agent_id}" ) return cached if origin_current is None: raise StaleCapabilityCardError( f"origin returned no current card for {cached.agent_id}" ) if cached.version < origin_current.version: raise StaleCapabilityCardError( f"cached card v{cached.version} superseded by origin v" f"{origin_current.version} for {cached.agent_id}; renegotiate" ) if cached.signing_key_id not in active_key_ids: raise StaleCapabilityCardError( f"card signed by rotation-overlap key {cached.signing_key_id}; " f"not authoritative for {cached.agent_id}" ) return origin_current def negotiate_and_submit( cached: AgentCard, origin_current: AgentCard | None, active_key_ids: set[str], origin_reachable: bool, last_seen_version: int, requested_caps: frozenset, ) -> str: card = resolve_authoritative_card( cached, origin_current, active_key_ids, origin_reachable, last_seen_version ) missing = requested_caps - card.capabilities if missing: raise StaleCapabilityCardError( f"capability mismatch after authority check: {sorted(missing)} " f"not offered by {card.agent_id} v{card.version}" ) return card.endpoint ```