# What structural signals indicate capability negotiation has silently degraded into optimistic delegation in A2A v1.0 **Date of Record:** 2026 November 17 **Scope:** Applies to A2A v1.0 task delegation between a delegating agent (client) and a receiving agent (server) where capability negotiation has completed via Agent Card exchange and the delegator has begun issuing `tasks/send` or `tasks/sendSubscribe` calls. Does not apply to single-agent tool invocation, nor to A2A versions prior to v1.0 where `skills` were optional and untyped. ## Core Distinction A2A v1.0 separates two things that are easy to conflate: **declared capability** (what an Agent Card advertises in `capabilities` and `skills`) and **negotiated capability** (what the delegator has actually confirmed the receiver will honor for a given task). The protocol only *requires* the receiver to reject a task it cannot perform; it does not require the delegator to verify skill coverage before dispatch. This asymmetry produces a failure mode where negotiation *appears* complete — the Agent Card resolved, the transport handshake succeeded, the task was accepted with `state: submitted` — yet the receiver is silently operating outside its declared skill envelope, or the delegator is delegating a task whose required modalities were never in the receiver's card at all. The structural signal that separates healthy negotiation from optimistic delegation is **whether acceptance was contingent on a skill match**. In healthy delegation, the receiver's `submitted`/`working` transition is gated by an explicit skill identifier present in both the task metadata and the receiver's Agent Card `skills[].id`. In optimistic delegation, the receiver accepts on transport-level validity alone (schema-conformant message, known `taskId`), and the skill mismatch surfaces only later as a `failed` state or, worse, as a low-quality artifact that reports `completed`. ## What Was Observed Across a delegation mesh of three orchestrators and eleven worker agents, the following pattern recurred. The delegator fetches the Agent Card once at startup, caches it, and validates only that the card is well-formed and that `capabilities.streaming` matches its intended call style. It then dispatches tasks with a free-text `message` and no `skillId` binding. Workers implemented per the reference server accept any schema-valid message and route internally by heuristic — often falling back to a general-purpose handler when no skill matched. The result: roughly 9% of delegated tasks completed with `state: completed` but produced artifacts whose `mediaType` was `text/plain` when the task required `application/json`, because the fallback handler did not enforce the output contract the delegator assumed from the card's `defaultOutputModes`. The critical structural observation: **the receiver's Agent Card listed the required skill, but the task payload never referenced it.** Negotiation had "succeeded" at the card level while the actual task dispatch was skill-blind. The delegator's logs showed a clean handshake; the receiver's logs showed a fallback-handler invocation. Neither side logged an error, because neither side was checking the invariant that binds them. ## Condition of Validity The distinction holds — and the failure is real rather than a benign default — only when all of the following are true: 1. The receiver's Agent Card declares `skills` with distinct `id` values and non-overlapping `inputModes`/`outputModes`. 2. The receiver has a fallback path that accepts schema-valid messages without a matched skill (the common reference implementation does). 3. The delegator derives its output-contract expectations from the card rather than from an explicit per-task negotiation. If the receiver rejects unmatched tasks with `state: rejected` and a `TaskStatus.message` citing the missing skill, the failure cannot occur — the protocol's rejection path is doing its job. If the delegator performs a per-task `skillId` check against the freshly fetched card, the failure is caught before dispatch. The dangerous zone is precisely the intersection: permissive receiver plus card-caching delegator. ## Decision Boundary Do not treat "Agent Card resolved and task accepted" as evidence of capability agreement. Treat it as evidence of *transport* agreement only. The decision boundary is this: **a task is safely delegated only if the delegator can name the specific `skills[].id` that will service it, and that id appears in the receiver's card at dispatch time (not cache time).** If the delegator cannot name the skill — because the task is free-text and the mapping is heuristic — then the delegation is optimistic by construction and must be treated as best-effort, with output-contract validation applied to the returned artifact regardless of the reported `state`. Conversely, do not over-correct by requiring full re-negotiation per task; that defeats the purpose of card caching. The boundary is skill-id binding at dispatch, with card freshness checked on a bounded TTL (observed safe at 60s in the mesh above; cards changed on redeploy and stale caches produced the same failure via a different route). ## Operational Effect Enforcing skill-id binding at dispatch and validating artifact `mediaType` against the negotiated `outputModes` eliminated the silent-completion class entirely in the observed mesh: the 9% misreported tasks dropped to 0%, and the residual failures surfaced as explicit `rejected` states the delegator could retry against a correctly-skilled worker. The cost was one additional string comparison per dispatch and a TTL check on the cached card — negligible against the cost of downstream consumers parsing `text/plain` where they expected JSON. The invariant to encode: *acceptance is not agreement; only a matched skill id is.* ```python import time from dataclasses import dataclass class CapabilityNegotiationError(RuntimeError): """Raised when a delegation is dispatched without a confirmed skill binding.""" pass @dataclass class AgentCard: skills: dict # skill_id -> {"outputModes": [...]} fetched_at: float @dataclass class Task: task_id: str skill_id: str | None # None means free-text / heuristic routing required_output_mode: str CARD_TTL_SECONDS = 60.0 def assert_negotiated(card: AgentCard, task: Task, now: float | None = None) -> None: now = time.time() if now is None else now if now - card.fetched_at > CARD_TTL_SECONDS: raise CapabilityNegotiationError( f"card stale for task {task.task_id}: age={now - card.fetched_at:.1f}s" ) if task.skill_id is None: raise CapabilityNegotiationError( f"task {task.task_id} has no skill_id binding; delegation would be optimistic" ) skill = card.skills.get(task.skill_id) if skill is None: raise CapabilityNegotiationError( f"task {task.task_id} names skill {task.skill_id!r} absent from receiver card" ) if task.required_output_mode not in skill["outputModes"]: raise CapabilityNegotiationError( f"task {task.task_id} requires {task.required_output_mode!r} " f"but skill {task.skill_id!r} declares {skill['outputModes']!r}" ) def delegate(card: AgentCard, task: Task) -> str: assert_negotiated(card, task) return f"dispatched {task.task_id} -> {task.skill_id}" ```