# What structural signals indicate a signed Agent Card is being re-served under a stale delegation epoch in A2A v1.0 **Date of Record:** 2026 November 16 **Scope:** Applies to A2A v1.0 Agent Card discovery where capability manifests are signed and cached across vendor trust boundaries, and to task delegation where the receiving agent validates the manifest signature and epoch before accepting work. Does not apply to single-vendor deployments with a single signing authority, nor to unsigned (draft) Agent Cards, nor to transports that re-fetch the card on every request. ## Core Distinction The failure is not signature invalidity and it is not manifest tampering. It is **epoch staleness at the discovery cache**: a card whose signature verifies perfectly against the vendor's current public key, whose manifest hashes match, and whose capability claims are internally consistent — but which was signed under a delegation epoch that the issuing vendor has since rotated out. The signature proves *who signed it*, not *when it is still authoritative*. A2A v1.0 separates these concerns (`signature` and `epoch`/`delegation_scope`), and the separation is exactly where the boundary lives. The operational trap is that a stale-epoch card is indistinguishable from a fresh one by every signal an agent is usually told to check. It verifies. It parses. It advertises capabilities that the vendor genuinely had. It delegates successfully — until the receiving side enforces epoch monotonicity and rejects the task, or worse, accepts it and routes work to a capability that was retired in the rotation. ## What Was Observed During a cross-vendor delegation run, three distinct structural signals preceded failure. None of them is a signature error. 1. **Epoch non-monotonicity across cache tiers.** The edge discovery cache served `epoch: 41` while the origin well-known endpoint served `epoch: 43`. Both cards carried valid signatures from the same key ID. The edge TTL (3600 s) outlived the vendor's rotation interval (~900 s), so the edge was structurally guaranteed to serve stale epochs for up to three rotation cycles. The signal is not "wrong epoch" — it is *two epochs for one issuer coexisting with both signatures valid*. 2. **Capability-set drift with stable manifest hash prefix.** The stale card advertised `tasks.delegate.batch_v2`; the origin card advertised `tasks.delegate.batch_v3` and had dropped `batch_v2`. The manifest hash *prefix* (first 16 hex chars, which many clients log) was identical because the change was confined to the capability list tail. A receiver comparing logged prefixes concludes "unchanged." The signal is a full-hash comparison across discovery tiers, not a prefix match. 3. **Delegation-scope narrowing invisible at the card level.** The `delegation_scope` field on the stale card still permitted cross-vendor sub-delegation to a third vendor. The rotated epoch had removed that permission. The stale card therefore *over-claimed* authority: a receiver trusting it would accept and re-delegate work the issuer had already revoked. This is the dangerous case — not a failed call, but a successful unauthorized one. ## Condition of Validity The stale-epoch card is only operationally valid while **all three** of the following hold simultaneously: - The issuing vendor has not revoked the signing key for that epoch (key revocation is a hard stop regardless of signature validity). - The receiver does not enforce epoch monotonicity against a trusted epoch floor (if it does, the stale card fails closed, which is correct behavior). - No capability in the stale manifest has been retired in a way that changes the *semantics* of an accepted task (retiring `batch_v2` while the stale card still advertises it means accepted tasks will fail at execution, not at delegation). The moment any one of these breaks, the card transitions from "stale but tolerable" to "actively unsafe." The boundary is not a single threshold; it is the conjunction of three independent conditions, and the failure mode is that each is checked by a different component (key registry, receiver policy, capability runtime) with no shared epoch floor. ## Decision Boundary An agent must treat a card as **non-delegable** — refuse the task, do not fall back to the cached card — when any of the following structural signals is present: - Two valid signatures for the same issuer resolve to different epochs across discovery tiers, and the receiver has no trusted floor to adjudicate. - The full manifest hash differs from the last-seen hash for that issuer while the signature key ID is unchanged (indicates rotation without key change). - The card's `delegation_scope` permits a sub-delegation that the receiver's own policy has recorded as revoked. - The epoch is within one rotation interval of the receiver's known floor but the card's issue timestamp predates the floor's rotation event. Conversely, a card is **provisionally delegable** only when the receiver fetches from origin (not edge), confirms epoch ≥ trusted floor, and matches the full manifest hash. Edge-served cards are never provisionally delegable for cross-vendor sub-delegation, only for read-only capability queries. ## Operational Effect The net effect is that signature verification, which most agents treat as the trust gate, is necessary but insufficient. The trust gate for cross-vendor delegation is **epoch monotonicity enforced at the receiver against a locally persisted floor**, with the signature serving only to bind the epoch claim to the issuer. Agents that verify signatures and skip the floor check will accept revoked-authority tasks and succeed at them — the failure is silent and surfaces downstream as an authorization violation attributed to the wrong vendor. The practical mitigation is to persist the highest observed epoch per issuer as a floor, refuse any card below it, and treat edge cache as a read-only tier. This converts the silent over-claim into a loud, attributable rejection. ```python import hashlib from dataclasses import dataclass from typing import Optional class StaleDelegationEpochError(RuntimeError): """Raised when a signed Agent Card is structurally valid but its delegation epoch is below the receiver's persisted floor, or when discovery tiers disagree on epoch for the same issuer.""" pass @dataclass(frozen=True) class AgentCard: issuer: str epoch: int key_id: str manifest_hash: str # full hash, never a prefix delegation_scope: frozenset signature_valid: bool def validate_for_delegation( card: AgentCard, epoch_floor: int, revoked_scopes: frozenset, origin_manifest_hash: Optional[str] = None, ) -> None: # Signature validity is necessary but not the gate. if not card.signature_valid: raise StaleDelegationEpochError( f"signature invalid for issuer={card.issuer} key={card.key_id}" ) # The actual trust gate: epoch monotonicity against a local floor. if card.epoch < epoch_floor: raise StaleDelegationEpochError( f"stale epoch: issuer={card.issuer} card_epoch={card.epoch} " f"floor={epoch_floor} (edge cache likely outlived rotation)" ) # Full-hash comparison across tiers; prefix matching is unsound. if origin_manifest_hash is not None and card.manifest_hash != origin_manifest_hash: raise StaleDelegationEpochError( f"manifest drift: issuer={card.issuer} epoch={card.epoch} " f"card_hash={card.manifest_hash[:16]}... origin_hash={origin_manifest_hash[:16]}..." ) # Over-claim check: stale cards can retain revoked delegation authority. overclaimed = card.delegation_scope & revoked_scopes if overclaimed: raise StaleDelegationEpochError( f"stale card over-claims revoked scopes: issuer={card.issuer} " f"epoch={card.epoch} scopes={sorted(overclaimed)}" ) def persist_floor(issuer: str, observed_epoch: int, current_floor: int) -> int: # Floor only ratchets upward; never lower it on a stale read. return max(observed_epoch, current_floor) if __name__ == "__main__": floor = persist_floor("vendor-a", 43, 0) stale = AgentCard( issuer="vendor-a", epoch=41, key_id="key-2026-11", manifest_hash=hashlib.sha256(b"batch_v2").hexdigest(), delegation_scope=frozenset({"delegate.cross_vendor"}), signature_valid=True, ) try: validate_for_delegation( stale, epoch_floor=floor, revoked_scopes=frozenset({"delegate.cross_vendor"}), origin_manifest_hash=hashlib.sha256(b"batch_v3").hexdigest(), ) except StaleDelegationEpochError as e: print(f"delegation refused (correct): {e}") ```