All blogs
5 min readEN

A2A Protocol: Introduction

  • A2A Protocol
  • MCP Protocol
  • Multi-Agent Systems
On this page

What is A2A and how does it work?

What is A2A?

Its is an open standard enables collaboration between AI Agents. You can use A2A with different SDK’s and frameworks. A2A itself (as a protocol) is NOT a framework or SDK. That’s why it gave the capability to use it between different SDK’s. So at enterprise level you will able to adapt different SDK’s according to different requirements of the internal teams.

What is NOT A2A?

It is not a replacement to MCP. MCP is mainly a standardized function call for the agents. Gives you an integration between an agent and outside world. A2A and MCP mainly work together at the enterprise level.

The high level architecture of how Multi-Agent Systems work
The high level architecture of how Multi-Agent Systems work

How it Works?

As you can except, client agents should somehow discover the agents it can interact with.

Agent Card

For that, it sends a request to A2A server to take the Agent Card. Agent card is like an ID for agents but in json. It gives the information about the agent such as:

  • name, description, version: Basic identity information.
  • supported_interfaces: Ordered list of endpoints and protocols where the A2A service can be reached.
  • capabilities: Supported A2A features like streaming or extended_agent_card. ( Example usage: Extended agent card is available for authenticated users, but normal version is available for all users.)
  • default_input_modes / default_output_modes: Default Media Types for the agent.
  • skills: A list of AgentSkill objects that the agent offers.
A2A Client sends requests to A2A Server
A2A Client sends requests to A2A Server

Agent card is comparable to robots.txt at the web side. It is typically at a place like: .well-known/agent-card.json

Agent Skills

There is also Agent Skills (not the skills you use at harnesses such as claude or ChatGPT(former codex))

Attributes of Agents Skills are:

  • id: A unique identifier for the skill.
  • name: A human-readable name.
  • description: A more detailed explanation of what the skill does.
  • tags: Keywords for categorization and discovery.
  • examples: Sample prompts or use cases.
  • input_modes / output_modes: Supported Media Types for input and output (e.g., "text/plain", "application/json").
  • security_requirements: Security schemes necessary for this skill.

Agent Skill Example:

# Defines the abilities or functions that agent can perform.
skill = AgentSkill(
id='echo_bot',
name='Echo Bot',
description='An example agent that acknowledges client request and responds with a "Hello World" message.',
input_modes=['text/plain'],
output_modes=['text/plain'],
tags=['a2a', 'echo-example'],
examples=['hi', 'how are you'],
)

Agent Card Example:

# Define a public-facing agent card that allows clients to discover your agent's capabilities.
public_agent_card = AgentCard(
# Basic identity information of A2A server
name='Hello World Agent',  # Identity
description='Just a hello world agent',
version='0.0.1',
# Default Media Types for the agent's interactions
default_input_modes=['text/plain'],  # Supported media types
default_output_modes=['text/plain'],
# Supported A2A features (like streaming or extended config)
capabilities=AgentCapabilities(streaming=True, extended_agent_card=True),
# Ordered list of endpoints and protocols where the service can be reached
supported_interfaces=[
AgentInterface(
protocol_binding='JSONRPC',
url='http://127.0.0.1:9999',
protocol_version='1.0',
)
],
# The list of AgentSkill objects that this agent offers
skills=[skill],
# Optional attributes (omitted here for simplicity):
# icon_url                         -> A URL to an icon representing the agent
)

Execution Modes

There are 4 types of execution modes for A2A protocol. The supported execution mode is defined at the agent card.

  • Synchronous: Waiting for an immediate response
Synchronous Communication
Synchronous Communication
  • Asynchronous: Proceeding without blocking for a reply.
Server side sends a task object
Server side sends a task object
Last response contains artifact which contains the answer of Agent B
Last response contains artifact which contains the answer of Agent B
  • Streaming: Transmitting continuous data flows. (It supports by using SSE)
Streaming: Server side push updates
Streaming: Server side push updates
  • Push Notifications: Alerting the other agents when specific events occur. (It supports by using Webhooks.)
Client provides a valid URL and Agent B sends push notification
Client provides a valid URL and Agent B sends push notification

These execution types allow you to create complicated systems only based on agents. They mostly cover all possible enterprise use-cases for A2A implementation. I recommend you to check A2A examples repo to check example implementations.

Conclusion

Now you have an idea about what is A2A and how it is used. The production ready implementation is complicated, and I will be making tutorials about this at the feature. Hopefully it helped you to understand what is A2A.

References