# What structural signals indicate a valid A2A v1.0 Agent Card signature when extended skill negotiation has mutated the capability surface after signing **Date of Record:** 2026 November 15 **Scope:** Applies to A2A v1.0 peers where Agent Cards are signed at publication time and extended skill negotiation (skill extension, capability narrowing, or dynamic skill advertisement) occurs during task establishment. Does not apply to v0.9 unsigned cards, nor to deployments that re-sign the card on every negotiation round (those are governed by a different invariant). ## Core Distinction There are two distinct notions of "the card is valid" that are routinely conflated: 1. **Signature validity** — the cryptographic signature over the canonicalized Agent Card bytes verifies against the declared key and the declared `signingAlgorithm`. 2. **Capability-surface validity** — the skills, modalities, and task-state transitions that the peer will actually honor match what the signature attests to. A2A v1.0 signatures bind the card *as published*. Extended skill negotiation is defined to happen *after* publication and *outside* the signed payload. This is intentional: negotiation is a runtime, per-task activity, and re-signing per negotiation would couple key material to task volume. The consequence is that a signature-valid card can describe a capability surface that the peer has already narrowed, extended, or reordered during negotiation. The failure mode is treating signature validity as a proxy for capability-surface validity. The non-obvious part: the negotiation delta is not carried in a signed envelope. It is carried in the task lifecycle stream as `status-update` and `artifact-update` events. Therefore the *only* structural evidence that a negotiated capability is legitimate is the reconciliation between the signed card and the task event sequence — not the signature itself. ## What Was Observed In a multi-agent deployment, a client agent received an Agent Card from a peer. The card declared skill `summarize.v2` with input modality `text/plain` and output modality `text/markdown`, and it carried a valid detached JWS signature. The client verified the signature, cached the card, and established a task. During `tasks/send`, the peer emitted a `status-update` with state `working`, then an `artifact-update` whose artifact declared `mimeType: application/json` and whose metadata referenced a skill name `summarize.v2+json` — a name that does not appear in the signed card. The peer had performed extended skill negotiation: it accepted a runtime extension that widened the output modality to JSON. The signature over the original card remained valid throughout. Nothing in the signature path flagged the divergence. The client's task-state reconciler, which validated artifacts against the signed card's declared modalities, rejected the artifact and transitioned the task to `failed`. The peer, which considered the negotiation successful, had already committed side effects and was waiting for `tasks/get` to observe a terminal state. The result was a split-brain task: `failed` on the client, `working` on the peer, with no shared notion of which state was authoritative. The task lifecycle had no reconciliation rule for "artifact modality not attested by signed card but attested by negotiation." A second observation: when the same peer was asked to re-derive its card after negotiation, it returned a card whose signature verified but whose `skills` array was byte-identical to the original — the negotiation delta lived only in task-scoped memory and was never folded back into the card. So even re-fetching the card did not resolve the divergence. ## Condition of Validity The signature-validity → capability-surface-validity implication holds **only** under the following conjunction: - No extended skill negotiation has occurred for the task in question (the task uses only card-declared skills and modalities), **and** - The reconciler treats the signed card as a *floor*, not a *ceiling*: card-declared capabilities are guaranteed present, but the peer may honor a superset negotiated in-band, **and** - Every in-band capability delta is accompanied by a `status-update` whose `metadata` carries a negotiation reference that the reconciler can correlate to the originating `tasks/send` context. If any conjunct fails, signature validity is necessary but not sufficient, and the reconciler must not use card attestation as the authority for artifact acceptance. In the observed incident, the second conjunct failed: the reconciler treated the card as a ceiling. ## Decision Boundary The operational rule: - **Accept an artifact** whose modality and skill are card-attested, regardless of negotiation state. - **Accept an artifact** whose modality or skill is *not* card-attested **only if** a prior `status-update` in the same task carries a negotiation reference for that exact capability, and that reference resolves to a negotiation the client itself initiated or acknowledged. - **Reject and fail closed** if a non-attested artifact arrives with no correlating negotiation reference. Do not silently widen the ceiling. - **Never** treat a valid signature as evidence that a non-attested artifact is legitimate. The signature attests to publication-time bytes; it says nothing about negotiation-time deltas. - **On divergence**, the authoritative task state is the one derived from the *event sequence*, not from either party's local view. If the event sequence is ambiguous (artifact without negotiation reference, or negotiation reference without artifact), transition to `failed` with an explicit reconciliation error rather than guessing. The boundary is between "the card is a contract" (false) and "the card is a published baseline that negotiation may extend under an auditable reference" (true). ## Operational Effect Treating the signed card as a ceiling produces split-brain tasks precisely when negotiation succeeds — the failure is most likely on the happy path of extended negotiation, not on adversarial input. Reconcilers that fail closed on non-attested artifacts without checking for negotiation references will reject legitimate negotiated outputs and strand peers in `working`. Reconcilers that accept non-attested artifacts without checking references will accept forged capability claims. The only stable configuration is reference-correlated acceptance: the card is a floor, the event stream is the authority, and the reconciliation rule is explicit, auditable, and enforced in code rather than inferred. The practical mitigation is to make the reconciler's accept/reject decision a pure function of (signed card, task event sequence) and to raise a typed error whenever the two disagree without a correlating negotiation reference — so the divergence surfaces as a named reconciliation failure rather than a silent state split. ```python from dataclasses import dataclass, field from typing import Literal class CapabilityReconciliationError(RuntimeError): """Raised when a task artifact's capability is neither card-attested nor correlated to an acknowledged in-band negotiation reference.""" @dataclass class SignedCard: skills: dict[str, str] # skill name -> declared output modality signature_valid: bool @dataclass class TaskEvent: kind: Literal["status-update", "artifact-update"] skill: str modality: str negotiation_ref: str | None = None @dataclass class TaskReconciler: card: SignedCard acknowledged_refs: set[str] = field(default_factory=set) def reconcile(self, events: list[TaskEvent]) -> str: if not self.card.signature_valid: raise CapabilityReconciliationError( "card signature invalid; refusing to reconcile" ) for ev in events: if ev.kind == "status-update" and ev.negotiation_ref: self.acknowledged_refs.add(ev.negotiation_ref) continue if ev.kind != "artifact-update": continue attested = self.card.skills.get(ev.skill) == ev.modality if attested: continue # Non-attested capability: only acceptable with a correlating, # acknowledged negotiation reference. Signature validity is # explicitly NOT sufficient here. if ev.negotiation_ref and ev.negotiation_ref in self.acknowledged_refs: continue raise CapabilityReconciliationError( f"artifact skill={ev.skill!r} modality={ev.modality!r} " f"is not card-attested and has no acknowledged negotiation " f"reference (ref={ev.negotiation_ref!r}); " f"signature validity does not authorize this capability" ) return "reconciled" def reconcile_or_fail(card: SignedCard, events: list[TaskEvent]) -> str: reconciler = TaskReconciler(card=card) try: return reconciler.reconcile(events) except CapabilityReconciliationError: # Fail closed: the task must not be marked terminal-success on # an unreconciled capability surface. raise CapabilityReconciliationError( "task cannot be reconciled against signed card; " "transition to failed with explicit reconciliation error" ) ```