A2A Agent Cards and Discovery: How Peer Agents Find and Connect

GCP Study Hub
November 14, 2026

Every A2A agent publishes an Agent Card as its discovery document at /.well-known/agent-card.json on the agent's domain. A client agent reads this document before sending any task, which lets it interact with a remote agent without knowing how that remote agent is built. Because the card follows the A2A specification, any compliant client can read it without custom integration work. For the Professional Agentic Architect exam, it is worth being precise about what the Agent Card declares, because scenarios often test how discovery, protocol bindings, and streaming capabilities work together and how A2A differs from neighboring standards.

What an Agent Card declares

Before a client agent submits work to a remote peer, it inspects the Agent Card to learn how to reach the agent and what to expect from it. The document lists four main categories of information:

  • The agent's skills, describing what the agent can do
  • Its capabilities, such as streaming
  • The interfaces it supports, along with their protocol bindings
  • The security schemes clients must use to authenticate

This structure reflects the purpose of A2A: enabling collaboration between independent agents that may not reveal their internals. One organization can expose an agent whose underlying models, tools, and code remain private while still letting another organization's agent submit requests. A2A models that work as tasks that can run for hours while the client tracks status and waits for the final result. Reading the published Agent Card tells a client how to reach the agent, what it can do, and how to authenticate so it can submit a task and retrieve the final result without knowing how the remote agent produces its output.

Protocol bindings in the Agent Card

An Agent Card lists the interfaces the agent exposes and the protocol bindings each interface supports. A2A defines three equal protocol bindings: JSON-RPC, gRPC, and HTTP+JSON. Every binding must offer the same functionality, so switching a client from one supported binding to another changes only the transport and message encoding, not the agent's behavior.

The bindings differ in how they encode messages. gRPC encodes messages with Protocol Buffers, a binary format that is generally more compact and faster to parse than JSON, so the choice of binding matters most when agents exchange large structured payloads. A client can call any interface the remote agent lists in its Agent Card, which means it can move from JSON-RPC to gRPC without any change to the remote agent when both are already listed, and it gets the same skills, capabilities, and results either way.

Declaring streaming and comparing update modes

The capabilities section of an Agent Card is where a remote agent declares whether it supports streaming. Because A2A tasks can run for minutes or hours, the protocol offers several ways for a client to follow a task while it runs. A standard SendMessage call returns only when the entire task is complete.

Streaming depends on two settings working together. The remote agent must set capabilities.streaming to true in its Agent Card, because an agent without that setting rejects streaming calls. The client then calls SendStreamingMessage instead of SendMessage. A2A streaming delivers task status updates and partial artifacts over Server-Sent Events with a text/event-stream response, so a client that keeps a connection open receives each update as the agent produces it.

A2A also supports two other ways to follow task progress, each suited to a different client pattern:

  • Polling with GetTask has the client repeatedly request status updates, and new results appear only at each poll.
  • Push notifications serve clients that cannot keep a connection open, delivering updates to a webhook instead of streaming over an open connection.

Because the streaming capability is published in the Agent Card, a client can see during discovery, before it sends any task, whether streaming is available from that agent.

Separating A2A Agent Cards from neighboring standards and services

On the Professional Agentic Architect exam, Agent Cards are often contrasted with other discovery formats and integration patterns that overlap in surface description but solve different architectural problems. Keeping their boundaries clear helps narrow down the right mechanism quickly:

  • OpenAPI specifications describe REST operations, not A2A skills, task behavior, or protocol bindings. Publishing an OpenAPI document does not allow a compliant A2A client to discover an agent's skills and interfaces.
  • MCP connects an agent to its own tools and data. Treating an external agent as a collection of MCP tools would require the owning organization to expose tools it wants to keep private, rather than collaborating with an independent peer that accepts tasks.
  • Gemini Enterprise makes agents available to an organization's own employees, not to another company's agents for cross-organization discovery.
  • Local sub-agents require access to the remote agent's code, which an external party will not share and which conflicts with separate team ownership when multiple applications call the agent.
  • Direct model endpoints skip the remote agent's logic entirely and require access to underlying models that an external provider has not exposed.

Our Professional Agentic Architect practice exams test A2A Agent Cards and discovery alongside A2A protocol bindings and streaming, with detailed explanations that drill these distinctions.

Get tips and updates from GCP Study Hub

arrow