# What happens when an instance advertises a skill in its Agent Card that its task lifecycle cannot actually negotiate **Date of Record:** 2026 November 16 **Scope:** Applies to A2A v1.0 cross-vendor delegation where a delegating agent selects a remote skill solely from the Agent Card's `skills[]` declarations and then initiates a task without a capability preflight. Does not apply to same-vendor intra-cluster delegation where lifecycle semantics are pinned by shared runtime version. ## Core Distinction An Agent Card is a **declaration of intent**, not a **contract of capability**. The `skills[]` array enumerates what an agent claims it can do; the `capabilities` block and the task lifecycle state machine (the `TaskState` transitions it will accept) enumerate what it can *negotiate*. These two surfaces are versioned independently in practice, and A2A v1.0 does not require them to be consistent. The non-obvious boundary is this: a skill can be advertised, discoverable, and even reachable, while the remote agent's lifecycle negotiation will reject the very task shape that skill implies — and it will do so *after* the task is created, not during discovery. Discovery validates reachability and schema conformance. It does not validate that the declared skill's implied lifecycle is a subset of the remote agent's accepted transitions. The gap between "I found the skill" and "I can complete a task against it" is where cross-vendor delegation silently fails. ## What Was Observed A delegating orchestrator discovered a remote agent card over `/.well-known/agent.json`. The card advertised a skill `document.summarize` with `inputModes: ["text/plain"]`, `outputModes: ["text/plain"]`, and no `tasks` capability restrictions declared. The orchestrator selected the skill, sent `message/send` with a `Task` payload, and received a valid `Task` object with `status.state = "submitted"`. The remote agent then transitioned the task to `input-required` — but the orchestrator had not advertised `stateTransitionHistory` support and had not registered a push notification config. The remote agent's lifecycle implementation, however, *required* a push endpoint to be registered before it would accept any `input-required` transition, treating the missing config as a terminal fault rather than a recoverable state. The task deadlocked in `input-required` with no notification path back to the orchestrator. The orchestrator's polling loop, keyed on `submitted → working`, never observed the transition because the remote agent had stopped emitting `working` after the first cycle. The failure was not in discovery (the card was accurate about the skill), not in transport (messages were delivered), and not in schema (every payload validated). It was in the **implicit lifecycle precondition** — the requirement for a push config — that the card never declared and the orchestrator never preflighted. A second observation: when the same orchestrator retried against a *different* vendor's agent advertising the same skill name, the lifecycle accepted the task and completed it, because that vendor treated `input-required` as pollable by default. Same skill declaration, divergent lifecycle semantics. The Agent Card gave no signal to distinguish them. ## Condition of Validity This boundary holds when and only when all of the following are true: 1. The delegating agent selects skills from `skills[]` without independently negotiating the `capabilities` block against its own lifecycle support. 2. The remote agent's lifecycle implementation imposes preconditions (push config, webhook registration, specific `acceptedOutputModes` intersection, state-transition history) that are not expressible in the Agent Card's declared fields. 3. The delegating agent does not implement a capability preflight — a `tasks/get` or negotiation round-trip — before committing a task. It does **not** hold when the delegating agent performs an explicit capability handshake, when both agents share a runtime that pins lifecycle semantics, or when the remote agent declares its lifecycle constraints in an extension field the orchestrator reads. In those cases the boundary is closed and the failure mode does not occur. ## Decision Boundary The decision is whether to treat Agent Card discovery as *sufficient* for delegation or *necessary but insufficient*. The operational rule: - **Sufficient** only if the remote agent's `capabilities` block explicitly declares every lifecycle precondition the orchestrator cannot satisfy, AND the orchestrator validates the `acceptedOutputModes` intersection before task creation. - **Insufficient** in all cross-vendor cases where `capabilities.pushNotifications` is `false` or absent but the remote lifecycle may still require it, or where `stateTransitionHistory` is required by the orchestrator but not declared by the remote. When in the insufficient regime, the orchestrator must perform a preflight: create a probe task, drive it through one lifecycle cycle, and confirm the `input-required` path is pollable before committing real work. If the preflight cannot confirm pollability, the orchestrator must refuse delegation rather than create a task it cannot complete. ## Operational Effect Absent this preflight, tasks accumulate in `input-required` on the remote side, consuming remote state slots and quota while the orchestrator believes them to be in `submitted`. The orchestrator's retry logic, keyed on the absence of `working`, re-sends `message/send` and creates duplicate tasks — each of which also deadlocks. The remote agent's task store fills with orphans; the orchestrator's dedup key (task ID) does not match because each retry mints a new task. The net effect is a slow resource leak on both sides that presents as latency, not error, and is invisible to health checks that only probe card reachability. The correct operational posture is to treat lifecycle negotiation as a distinct phase from discovery, gate delegation on a successful probe, and fail closed — refuse the delegation — rather than open a task whose terminal state the orchestrator cannot observe. ```python import enum from dataclasses import dataclass, field from typing import Optional class LifecycleNegotiationError(RuntimeError): """Raised when an advertised skill cannot be negotiated to a terminal state.""" pass class TaskState(enum.Enum): SUBMITTED = "submitted" WORKING = "working" INPUT_REQUIRED = "input-required" COMPLETED = "completed" FAILED = "failed" @dataclass class AgentCard: name: str skills: list[str] push_notifications: bool state_transition_history: bool @dataclass class DelegationProbe: card: AgentCard orchestrator_supports_push: bool = False observed_states: list[TaskState] = field(default_factory=list) def can_observe_input_required(self) -> bool: if TaskState.INPUT_REQUIRED not in self.observed_states: return False if self.card.push_notifications and not self.orchestrator_supports_push: return False return True def preflight_delegation(probe: DelegationProbe, skill: str) -> None: if skill not in probe.card.skills: raise LifecycleNegotiationError( f"skill {skill!r} not advertised by {probe.card.name!r}" ) if not probe.can_observe_input_required(): raise LifecycleNegotiationError( f"cannot observe input-required lifecycle on {probe.card.name!r}: " f"push_notifications={probe.card.push_notifications}, " f"orchestrator_supports_push={probe.orchestrator_supports_push}, " f"observed={[s.value for s in probe.observed_states]}" ) def delegate(card: AgentCard, skill: str, probe: Optional[DelegationProbe]) -> str: if probe is None: raise LifecycleNegotiationError( "refusing delegation without lifecycle preflight; " "card discovery is necessary but not sufficient" ) preflight_delegation(probe, skill) return f"delegated:{skill}->{card.name}" ```