A2A Tasks, Streaming, and Push Notifications for Long-Running Agent Work

GCP Study Hub
November 14, 2026

The A2A protocol models work between independent agents as tasks. A client submits a request, a remote agent works on that task for minutes or even hours, and the client tracks progress until the final result is ready. The Professional Agentic Architect exam tests both when A2A is the right integration model and how to choose among its three progress-tracking mechanisms: SendMessage with optional GetTask polling, streaming with SendStreamingMessage, and webhook-based push notifications.

How A2A handles work across independent agents

A2A is designed for collaboration between independent agents that may not reveal their internals, including their code, models, or tools. Instead of exposing implementation details, a remote agent publishes an Agent Card that describes how to reach the agent, what it can do, and how clients must authenticate. A client agent uses that Agent Card to submit a task, follow its status, and collect the final result without needing to know how the remote agent produces its output.

This task-oriented boundary separates A2A from other integration options that solve different problems:

  • MCP connects an agent to its own tools and data. Using MCP across independent parties would require the remote party to expose private tools rather than keeping tool execution behind an agent boundary.
  • Running a remote agent as a local sub-agent requires access to its code, which an independent owner may not share.
  • Calling a model endpoint directly skips the remote agent's logic altogether and requires direct access to the underlying model.

Three ways A2A clients follow task progress

Because an A2A task can run for minutes or hours, A2A gives clients three mechanisms to follow progress:

  • SendMessage returns only when the task is complete, blocking until the remote agent finishes. A client can check intermediate status by polling with GetTask, though the client has to keep asking and sees updates only at each poll.
  • Streaming delivers task status updates and partial artifacts in real time over Server-Sent Events, using a text/event-stream response. This fits a client that keeps a connection open, such as a web page displaying progress and partial results as they arrive.
  • Push notifications deliver updates to a webhook. This option is built for clients that cannot keep a connection open while a task runs.

Streaming requirements and protocol details

Using A2A streaming requires configuration on both the agent and the client. On the agent side, the remote agent must set capabilities.streaming to true in its Agent Card. If an agent does not declare capabilities.streaming as true, it rejects streaming calls. On the client side, the client calls SendStreamingMessage, which was called message/stream in A2A 0.3.

With streaming declared and SendStreamingMessage in use, the client displays each status update and partial artifact as soon as the agent produces it instead of waiting until the end of the task or repeatedly calling GetTask.

Two details of the protocol separate real streaming from other call options. First, A2A has no stream=true parameter on SendMessage, so adding a parameter to SendMessage does not enable streaming and the call still blocks until the task ends. Second, changing the binding to gRPC only changes how messages are encoded. Calling SendMessage over gRPC still returns only when the task is complete.

Choosing the right A2A progress mechanism

On the Professional Agentic Architect exam, picking the right A2A mechanism comes down to whether the client can keep a connection open and whether it needs updates before the task finishes. If a client only needs the final output, SendMessage handles the request directly, and GetTask polling covers cases where periodic status checks are acceptable.

When a user or interface keeps a connection open and needs partial results or status changes as soon as the agent produces them without repeated polling, we would set capabilities.streaming to true in the Agent Card and use SendStreamingMessage. When the client cannot maintain an open connection while a long-running task progresses, push notifications to a webhook are the matching A2A option. Keeping the connection lifecycle separate from message encoding and from tool protocols like MCP makes these architectural choices clear.

Our Professional Agentic Architect practice exams test A2A tasks, streaming, and push notifications alongside Agent Cards and the boundary between A2A and MCP, with detailed explanations that drill these distinctions.

Get tips and updates from GCP Study Hub

arrow