A2A's core design premise is that agents from different vendors, running on different infrastructure, should be able to collaborate without exposing their internal implementation. The protocol achieves interoperability at the communication boundary, not through shared runtimes or framework alignment.
Agent Cards: The Capability Advertisement Layer
Every A2A-compliant agent publishes an Agent Card, a JSON document served at a well-known endpoint (/.well-known/agent-card.json). The card declares the agent's identity, its supported capabilities, accepted input modalities, authentication requirements, and the endpoint URL where it receives tasks. Agent Cards are how the agent-to-agent communication protocol solves the discovery problem without a centralized directory: any client agent can fetch the card, parse the capability manifest, and, before sending a single task message, determine whether the target agent can actually handle the work.
Capability declarations inside an Agent Card aren't freeform strings. They follow a structured schema that enables programmatic matching, allowing an orchestrator agent to evaluate multiple candidate agents against a task requirement and select the most appropriate peer at runtime.
The Task Model and Message Threading
A2A structures all agent work around a Task object. When a client agent sends a task, the server agent immediately returns a task ID, decoupling submission from execution. The task progresses through a defined state machine: submitted, working, input-required, completed, failed, canceled, rejected, and auth-required. Each state transition can carry an accompanying Message object containing structured Parts, each of which holds typed content: text, files, or structured data blobs.
Message threading in A2A flows through a turn-based exchange within a single task context. The client and server agent exchange turns, and the server agent can request additional input mid-task by moving the task into the input-required state. The input-required state lets a server agent pause a task and request a specific piece of missing information, but it stops short of a sustained, multi-turn exchange. A2A's threading model is still built around delegation and a returned result, not an open conversation where either side can ask follow-up questions at will.
Streaming and Long-Running Task Execution
For long-running tasks, A2A uses Server-Sent Events to stream incremental updates to the client agent without requiring the client to maintain an open bidirectional connection. The client subscribes to a task's event stream and receives status updates, partial artifact delivery, and completion signals as the server agent works. Artifacts, A2A's term for task outputs, get streamed in chunks, which matters when the output is a large document, a generated codebase, or a multimodal composite.
Push notifications via webhook are also part of the spec, allowing the client agent to register a callback URL and receive task state transitions asynchronously, even across network interruptions.
What A2A Deliberately Leaves Open
A2A specifies the communication contract between agents. It doesn't specify what agents do with the tasks they receive, how they store intermediate state, how they log execution history, or how human operators get visibility into what's happening across a delegation chain.
The protocol also leaves governance entirely out of scope. Agent Cards support OAuth 2.0 scopes for authentication, but A2A has no native mechanism to enforce approval gates, audit cross-agent decisions, or escalate to a human when an agent encounters a task that exceeds its delegated authority.
That threading limitation compounds the governance gap. An agent that can't ask a clarifying question mid-task also can't easily surface a partial result for review, flag an ambiguous instruction, or negotiate scope with the agent that delegated the work. Each of those requires a sustained, two-way exchange that the task and state-machine model doesn't provide.
For enterprise deployments, those omissions aren't edge cases. A procurement agent delegating a purchase order to a fulfillment agent across an org boundary needs more than a completed task object returned over SSE. It needs a traceable record of who authorized the delegation, what constraints applied, and whether a human approved the scope before execution began. That's the layer the protocol deliberately hands off to infrastructure above it, which is precisely where the agent interaction control plane operates, providing governance, auditability, and human-in-the-loop coordination across A2A-connected agent networks.