
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.
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:
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.
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.
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:
GetTask has the client repeatedly request status updates, and new results appear only at each poll.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.
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:
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.