Authored by David Tracey

AI is rapidly evolving from simple tools to increasingly complex agents capable of reasoning and decision making. As agents are used for more tasks, the ability to use multiple co-operating agents will become increasingly important — particularly for tasks requiring specialised knowledge or access across domains.

Large-scale, flexible solutions will require a common means for agents to communicate capabilities to each other using a trusted means of collaboration. That's what the Agent2Agent (A2A) protocol is designed to provide.

This is the first post in a three-part series:

1. Part 1 (this post): Introduction to A2A concepts and a "Hello World" agent
2. Part 2: Using MCP to query multiple data sources including Bronto's logging platform
3. Part 3: Combining A2A and MCP with a "SuperAgent" orchestrating multiple agents

Why A2A?

The Agent2Agent protocol — originally developed by Google and now under the Linux Foundation as an open source project — gives agents an open protocol for interaction built on HTTP. It standardizes how agents exchange messages, requests, and data, allowing agents to:

• Discover each other's capabilities without exposing internal state, memory, or implementation
• Negotiate interaction details (text, forms, media, etc.)
• Collaborate on running tasks securely

IBM's definition of agentic AI captures it well: "Agentic AI is an artificial intelligence system that can accomplish a specific goal with limited supervision", with each agent in a multi-agent system performing a specific subtask coordinated through AI orchestration.

A2A and MCP: Complementary Protocols

MCP and A2A serve different but complementary roles:

• MCP exposes tools and structured data sources to an agent. It extends an agent's capabilities by standardizing how an agent accesses databases or product APIs. It focuses on a single agent accessing tools, and lacks built-in agent authentication.
• A2A provides structured agent-to-agent communication — allowing multiple autonomous agents to collaborate, delegate tasks, and exchange information using capabilities exposed via Agent Cards. It enables multi-agent interactions with secure communication and capability discovery.

MCP Tools are generally basic operations with defined inputs/outputs. A2A is designed for autonomous agents that reason, use tools, and collaborate on complex problems. The two protocols are not mutually exclusive — agents can use MCP for specific tool access and A2A for broader agent collaboration.

Part 3 of this series will show an emerging pattern where A2A agents sit in front of MCP servers.

Key A2A Concepts

Agent Card — public metadata describing an agent's capabilities, skills, URL, and authentication requirements. Other agents retrieve this card to discover what an agent can do.

A2A Server — exposes an HTTP API endpoint implementing A2A methods and executes tasks on behalf of other agents.

A2A Client — an application or agent that sends requests to an A2A server to initiate tasks.

Task — initiated by a client sending an A2A message (role: user). Each task has a unique ID and states: submitted, working, input-required, completed.

Message — contains a role (user or agent), optional metadata, and an array of parts (TextPart, FilePart, or structured JSON data).

Communication flows:

1. Discovery — client fetches the Agent Card via GET /.well-known/agent-card.json
2. Initiation — client sends a request with a task ID to the server agent
3. Processing — server processes the task, streaming intermediate updates via Server-Sent Events if needed

Building a Hello World A2A Agent

Installation and Setup

These examples use the official A2A samples repository. Requirements:

• Python 3.12 or higher
• UV (recommended Python package manager)

Running the Sample

# Clone the repo
git clone https://github.com/a2aproject/a2a-samples.git
cd a2a-samples/samples/python/agents/helloworld

# Install UV and run the server
pip install uv
uv run .

This runs __main__.py in the helloworld directory, which defines an AgentCard, AgentSkill, and extended card, then calls uvicorn to run a server on localhost:9999.

In a separate terminal, run the client:

uv run test_client.py

The Agent Card Response

The server returns its public Agent Card:

{
  "capabilities": { "streaming": true },
  "defaultInputModes": ["text"],
  "defaultOutputModes": ["text"],
  "description": "Just a hello world agent",
  "name": "Hello World Agent",
  "preferredTransport": "JSONRPC",
  "protocolVersion": "0.3.0",
  "skills": [
    {
      "description": "just returns hello world",
      "examples": ["hi", "hello world"],
      "id": "hello_world",
      "name": "Returns hello world",
      "tags": ["hello world"]
    }
  ],
  "supportsAuthenticatedExtendedCard": true,
  "url": "http://localhost:9999/",
  "version": "1.0.0"
}

Authenticated clients additionally receive an extended card with a super_hello_world skill — demonstrating how A2A supports capability tiers based on authentication level.

What's Coming in Parts 2 and 3

Part 2 will show how to build simple MCP servers for Bronto's REST API and a SQLite database, then use Claude to query both simultaneously with a natural language prompt — no data movement required.

Part 3 will extend this into a full A2A scenario with a "SuperAgent" orchestrating two A2A agents (one per data store), demonstrating how A2A and MCP work together.

The Bigger Picture: Challenges A2A Still Needs to Solve

A2A is an evolving protocol. Current areas requiring further development include:

• Multi-agent orchestration — standardized support for conflict handling and failure recovery across agents from different organizations
• Shared vocabulary — no agreed-upon standard definitions for common items like invoices, policies, or receipts
• Trust — establishing trust between agents across organizational boundaries is key to adoption
• Security — authentication is provided, but richer methods are needed for privacy across organizational/national boundaries
• Enterprise readiness — standardized usage management, SLOs, SLAs, and automated negotiation

The separate open source project AGNTCY, backed by Cisco, LangChain, Galileo and others, provides the Open Agent Schema Framework (OASF) as another approach to standardizing agent capability descriptions.

Explore Bronto's AI Features