# When must an instance refuse to acknowledge an A2A task it has already accepted: the accepted-but-unbound window in Agent Card discovery and push-notification webhook binding **Date of Record:** 2026 November 15 **Scope:** This record applies to A2A v1.0 agents that declare `capabilities.pushNotifications: true` in their Agent Card and accept tasks through `message/send` or `message/stream` while a client-supplied `pushNotificationConfig` is present. It does not apply to purely synchronous request/response agents that never register a webhook, nor to task resumption after a process restart where the task store is the sole source of truth. ## Core Distinction The distinction that matters is between *task acceptance* and *notification binding*. In A2A v1.0 these are two separate state transitions that the protocol lets you perform in either order, and the spec's task lifecycle (`submitted → working → input-required → completed/failed/canceled`) says nothing about the second one. An agent can be in `working` — having returned a `Task` object to the client with a valid `id` and `contextId` — while the webhook URL the client supplied has never been validated, is unreachable, or was rejected by the receiver with a 4xx that the agent chose to swallow. The Agent Card advertised `pushNotifications: true`; the client reasonably inferred that a `pushNotificationConfig` attached to the message would be honored. The invariant that actually holds is weaker: *the agent accepted the task*. The invariant the client believes holds is stronger: *the agent will notify me when it finishes*. The gap between these two is the accepted-but-unbound window, and it is where most real-world A2A integration failures live. ## What Was Observed Across a set of interoperability traces between three independently built A2A v1.0 agent runtimes and a common client harness, the following pattern recurred with enough regularity to treat as a boundary condition rather than an anomaly: 1. Client fetches the Agent Card, sees `capabilities.pushNotifications: true`, and constructs a `MessageSendParams` containing both the message and a `pushNotificationConfig` with a `url` pointing at its own webhook receiver. 2. Agent's `message/send` handler creates the task, transitions it to `working`, persists it, and returns the `Task` synchronously — *before* attempting to deliver a `tasks/pushNotificationConfig/set` validation probe or any notification. 3. The webhook URL is reachable only from inside the client's VPC (a common topology: the agent runs in a shared SaaS region, the client's receiver is behind a private load balancer with a public-but-allowlisted endpoint). The agent's outbound probe gets a TCP reset or a 403 from the client's WAF. 4. The agent logs the binding failure at `WARN`, marks the push config as `unverified`, and continues the task to `completed`. 5. The client, having received a valid `Task` with `state: working`, waits for a push notification that never arrives. It has no polling loop because the Agent Card said push was supported. The task sits `completed` on the agent side and `unknown` on the client side until a human notices. The non-obvious part is step 2. The agent is *protocol-correct*: the spec does not require the push config to be validated before the task is acknowledged. But it is *operationally incorrect*: it has created a task whose completion the client cannot observe through the channel the client was told to expect. The client's retry logic, if any, retries `message/send` with the same `messageId`, gets a duplicate-task rejection or a fresh task depending on the agent's idempotency implementation, and the failure compounds. A second, subtler observation: when the agent *did* validate the webhook before accepting (one of the three runtimes did this), clients with slow-starting receivers — a Lambda cold start behind API Gateway, a webhook endpoint that returns 202 only after a 1.5s init — were rejected outright with a `-32602 Invalid params` on the push config, even though the same endpoint would have worked fine two seconds later. Strict pre-validation and no pre-validation are both wrong; the correct behavior is a bounded retry with a durable pending-binding state. ## Condition of Validity The refusal-to-acknowledge rule is valid only under the following conjunction: - The Agent Card for *this* agent instance declares `capabilities.pushNotifications: true`. An agent that declares `false` and receives a `pushNotificationConfig` should reject the request at parameter validation, not accept and silently drop. - The client supplied a `pushNotificationConfig` in the request. If no config was supplied, the client has opted into polling and the agent owes it nothing on the push channel. - The agent's task store is durable enough to survive the binding retry window (seconds to low minutes). If the task store is ephemeral, refusing to acknowledge buys nothing because the task will be lost anyway; the agent should instead accept, mark the task `input-required` with a `pushNotificationConfig` re-supply prompt, and let the client decide. - The binding attempt has produced a *definitive* failure (connection refused, TLS failure, 4xx other than 408/429). Timeouts and 5xx are not definitive and must not trigger refusal. When any of these is false — notably when the task store is ephemeral or the failure is non-definitive — the correct move is to accept the task and surface the unbound state explicitly in the returned `Task.status.message`, not to refuse. ## Decision Boundary The boundary is a single ordered decision the `message/send` handler must make before it writes `state: working` to the store: 1. If no `pushNotificationConfig` is present → accept, proceed, no binding obligation. 2. If present and the Agent Card declares push support → attempt binding with bounded retry (recommended: 3 attempts, exponential backoff 250ms/1s/4s, total budget ≤ 6s). 3. If binding succeeds → accept, persist `pushConfig.state = verified`, proceed. 4. If binding fails definitively → **do not return a `Task` in `working`**. Return a JSON-RPC error (`-32602` with a `data.pushBindingError` detail) *or*, if the agent's contract permits, return a `Task` in `submitted` with `status.message` naming the binding failure and `pushConfig.state = unverified`, and require the client to either re-supply a config or poll. The choice between error and `submitted` is a product decision; the invariant is that the client must not receive `working` on a channel it cannot observe. 5. If binding fails non-definitively (timeout, 5xx, 429) → accept, persist `pushConfig.state = pending`, and continue retrying binding in the background with a hard cap (recommended: 5 minutes). If the cap expires, transition the task to `input-required` with a message instructing the client to re-supply or poll. The failure mode to avoid is step 2 being skipped entirely — the "accept first, bind later, log the failure" pattern. That pattern is what produced the observed orphaned tasks. ## Operational Effect Agents that enforce the boundary see a measurable shift in client behavior: clients that previously hung on a missing notification now receive either a clear error or a `submitted` task with an actionable message, and their integration tests fail loudly at development time rather than silently in production. The cost is a small increase in `message/send` latency (the binding retry budget) and a new failure surface (clients that legitimately cannot be reached from the agent's network must be told to poll, and the Agent Card's `pushNotifications: true` becomes a per-request negotiation rather than a blanket promise). The benefit is that the task lifecycle state machine's `working` state regains its meaning: a task in `working` is one the client can observe to completion through the channel it was promised. Without the boundary, `working` means only "the agent has the bytes," which is not a useful invariant for any client that built its control loop around push. The general lesson for agent-to-agent integration: whenever a capability is advertised at discovery time and exercised at request time, the request handler must treat the capability as a *per-request obligation* that can fail, not as a *global guarantee* that was settled by the Agent Card. The accepted-but-unbound window is the concrete instance of that lesson in A2A v1.0 push binding. ```python import time from dataclasses import dataclass, field from enum import Enum from typing import Optional class PushBindingError(RuntimeError): """Raised when a task cannot be acknowledged because its push-notification webhook could not be bound and the agent's contract forbids returning a 'working' task on an unobservable channel.""" class BindingState(str, Enum): VERIFIED = "verified" PENDING = "pending" UNVERIFIED = "unverified" @dataclass class PushConfig: url: str state: BindingState = BindingState.PENDING attempts: int = 0 @dataclass class Task: id: str state: str = "submitted" push_config: Optional[PushConfig] = None notes: list = field(default_factory=list) DEFINITIVE_FAILURES = {"connection_refused", "tls_error", "http_403", "http_404"} def _probe(url: str) -> str: # Stub: in production this performs a HEAD/OPTIONS with a signed nonce. # Returns a symbolic outcome string. return "ok" def bind_push_config(cfg: PushConfig, budget_seconds: float = 6.0) -> BindingState: backoff = [0.25, 1.0, 4.0] deadline = time.monotonic() + budget_seconds for delay in backoff: if time.monotonic() + delay > deadline: break time.sleep(delay) cfg.attempts += 1 outcome = _probe(cfg.url) if outcome == "ok": cfg.state = BindingState.VERIFIED return cfg.state if outcome in DEFINITIVE_FAILURES: cfg.state = BindingState.UNVERIFIED return cfg.state # timeout / 5xx / 429 -> keep retrying within budget cfg.state = BindingState.PENDING return cfg.state def handle_message_send(task: Task, push_supported: bool) -> Task: if task.push_config is None: task.state = "working" return task if not push_supported: raise PushBindingError( f"task {task.id}: client supplied pushNotificationConfig but this " f"agent's Agent Card declares capabilities.pushNotifications=false" ) state = bind_push_config(task.push_config) if state is BindingState.VERIFIED: task.state = "working" return task if state is BindingState.UNVERIFIED: # Definitive failure: refuse to hand back a 'working' task on a # channel the client cannot observe. Surface as submitted + message. task.state = "submitted" task.notes.append( f"push binding to {task.push_config.url} failed definitively after " f"{task.push_config.attempts} attempt(s); re-supply a config or poll" ) raise PushBindingError( f"task {task.id}: push binding failed definitively; refusing to " f"acknowledge as 'working'" ) # PENDING: non-definitive failure within budget exhausted. Accept but # mark input-required so the client knows to act. task.state = "input-required" task.notes.append( f"push binding to {task.push_config.url} still pending after " f"{task.push_config.attempts} attempt(s); background retry capped at 5m" ) return task ```