How to Use Google's A2A Protocol for Agent Communication

The Agent-to-Agent (A2A) protocol is an open standard for AI agent interoperability. Google launched it in April 2025 with over 50 technology partners, including Salesforce, ServiceNow, LangChain, MongoDB, and SAP. By mid-2025, the partner count grew past 100, with AWS and Cisco joining as validators.

A2A fills a specific gap: without it, every pair of specialized agents needs a custom integration. A research agent built with LangChain can't talk to a coding agent built with CrewAI unless someone writes connector code for that exact pair. A2A replaces that patchwork with a single protocol.

In June 2025, the Linux Foundation took over governance of A2A, establishing it as a vendor-neutral standard. Version 0.3, released in July 2025, added gRPC support, signed security cards, and expanded the Python SDK.

What A2A enables:

• Capability discovery: Agents publish what they can do via Agent Cards (JSON metadata)
• Task management: Agents submit, track, and complete multi-step tasks with defined state transitions
• Multi-modal exchange: Agents share text, files, and structured data within task messages
• Push notifications: Webhook-based updates for long-running tasks, no polling needed
• Secure boundaries: Authenticated communication across organizational lines

A2A runs on familiar web standards: HTTP for transport, Server-Sent Events (SSE) for streaming, and JSON-RPC 2.0 for message formatting. If you've built REST APIs, the protocol will feel familiar.

The most common question about A2A is how it relates to MCP (Model Context Protocol). Short answer: they solve different problems and work best together.

MCP handles vertical integration. It connects an agent to tools, data sources, and resources. When an agent needs to read a file, query a database, or call an API, it uses MCP. The protocol defines structured inputs and outputs so tools behave predictably. Fast.io's MCP server exposes file operations, workspace management, AI chat, and more through its tool catalog.

A2A handles horizontal integration. It connects agents to other agents. When a research agent needs a coding agent to write a script, or a compliance agent needs a legal agent to review a contract, that coordination happens through A2A.

How They Compare - MCP scope: One agent accessing external tools and resources

• A2A scope: Multiple agents discovering and delegating work to each other
• MCP discovery: Static tool definitions registered at startup
• A2A discovery: Dynamic Agent Cards fetched at runtime from well-known URLs
• MCP communication: Schema-validated, structured inputs and outputs
• A2A communication: Flexible messages with text, file, and data parts
• MCP transport: Streamable HTTP or SSE (originally stdio)
• A2A transport: HTTP + SSE + JSON-RPC 2.0, with optional gRPC

How They Work Together

A typical multi-agent workflow uses both. Agent A discovers Agent B's capabilities through A2A. Agent A delegates a task. Agent B uses MCP to access a shared workspace where the relevant files live. Agent B completes the work, saves results via MCP, and reports completion back through A2A.

The combination gives you tool access (MCP) plus agent coordination (A2A) plus persistent shared storage (the workspace).

A2A's design centers on three abstractions that keep the protocol practical without being rigid.

Agent Cards

An Agent

Card is a JSON document published at /.well-known/agent.json that describes what an agent can do. Other agents fetch this card to decide whether to delegate work. A card includes:

• Agent name, description, and version
• Endpoint URL for A2A communication
• Authentication requirements (Bearer, OAuth, mTLS)
• Skills list with input/output descriptions
• Supported content types and modalities

This is the discovery mechanism. Instead of hardcoding which agents exist, a client agent fetches cards from known URLs and picks the right specialist for each job.

Tasks and State

Tasks are the work units in A2A. Each task follows a lifecycle: submitted, working, input-required, completed, or failed. Two identifiers maintain continuity:

• contextId: Groups messages into a conversation thread (like a session ID)
• taskId: Identifies an individual request within that conversation

On the first message, the client omits both IDs. The server generates and returns them. All subsequent messages include these IDs to maintain context. For long-running tasks that take hours or days, A2A supports asynchronous updates through push notifications sent to a client-supplied webhook.

Messages and Parts

Messages carry the actual content exchanged between agents. A2A supports three part types:

• Text parts: Plain text content for instructions or responses
• File parts: References to files (URLs) or inline file data (base64-encoded)
• Data parts: Structured JSON for machine-readable payloads

This multi-modal approach means agents can exchange anything from simple instructions to complete file packages within a single task.

A2A handles communication between agents. But when multiple agents collaborate, they produce artifacts: documents, reports, transformed data, intermediate results. Those artifacts need to live somewhere accessible to all participants.

The storage gap in multi-agent workflows:

Agent A analyzes a document and extracts structured data. Agent B transforms that data into a report. Agent C reviews the report and adds annotations. All three need to read and write the same files without overwriting each other's work.

A2A's File Parts can pass files within messages, but they don't solve persistence. Once a task completes, those files disappear unless you store them externally. For production workflows, agents need a shared workspace with:

1. Multi-agent access: Every agent reads and writes the same file store

Persistence: Files survive beyond individual task sessions 3.

Conflict prevention: Locks stop two agents from overwriting the same file 4.

Semantic search: Find files by meaning, not just filename 5.

Event notifications: React to file changes without polling

Fast.io's intelligent workspaces provide this layer. Agents connect through 251 MCP tools to manage files, search content, and collaborate in the same workspaces humans use. File locks prevent concurrent write conflicts. Intelligence Mode auto-indexes uploaded files for semantic search and AI-powered Q&A. Webhooks notify agents when files change, enabling reactive workflows.

The resulting architecture has three layers: A2A sits between agents for coordination. MCP connects each agent to the shared workspace. The workspace itself provides persistence, search, and access control. Each layer handles what it does best.

Build Google's A2A Protocol Workflows on Fast.io

Fast.io provides intelligent workspaces where Google A2A agents collaborate with shared files, semantic search, and real-time notifications. 50GB free, no credit card required.

Sign Up Free

A2A works across the major agent frameworks, so you can adopt it regardless of your stack.

Supported Frameworks

• Google ADK (Agent Development Kit): Native A2A support with built-in hosting on Cloud Run
• LangChain/LangGraph: A2A endpoint support through community adapters
• CrewAI: Multi-agent orchestration with A2A delegation between crews
• A2A Adapter SDK: Open-source package supporting LangChain, LangGraph, CrewAI, and n8n

Install the adapter for your framework:

pip install a2a-adapter[crewai]     # For CrewAI
pip install a2a-adapter[langchain]   # For LangChain
pip install a2a-adapter[langgraph]   # For LangGraph
pip install a2a-adapter[all]         # All frameworks

Enterprise platforms like Salesforce Agentforce and ServiceNow Now Assist also support A2A. Adobe uses it to make their distributed agents interoperable with Google Cloud's ecosystem. Twilio extended A2A with latency-aware agent selection, routing tasks to the most responsive agent available.

Step-by-Step: Your First A2A Integration

Publish an Agent Card: Create a JSON file at /.well-known/agent.json describing your agent's skills and endpoint 2.

Implement server endpoints: Handle tasks/send, tasks/get, and tasks/cancel via JSON-RPC over HTTP 3.

Add authentication: Start with Bearer tokens for simplicity, upgrade to OAuth for production 4.

Test with reference agents: Google's A2A repository on GitHub includes Python and JavaScript samples you can run locally 5.

Connect shared storage: Add an MCP server like Fast.io so your agents persist and share files across tasks

Adding Persistent Storage

Once your agents communicate via A2A, give them a shared workspace for collaboration artifacts. Fast.io's free agent tier includes 50GB storage, 5,000 monthly credits, and access to all 251 MCP tools. No credit card required. Agents sign up programmatically and start working in minutes.

To connect, point your MCP client at /storage-for-agents/. Your agent gets tools for file uploads, downloads, folder management, AI chat, semantic search, and workspace sharing. When the work is done, transfer ownership to a human collaborator who keeps everything the agent built.

A2A has moved past the specification stage into production deployments. Here are patterns that enterprises are following.

Adobe: Cross-Platform Agent Collaboration

According to Google Cloud, Adobe uses A2A to make their distributed agents interoperable with agents in Google Cloud's ecosystem. Their agents coordinate to create digital experiences, speed up content workflows, and automate multi-system processes. This is the pattern A2A was designed for: agents from different vendors working together without custom integrations.

Twilio: Latency-Aware Routing

Twilio extended the A2A protocol to implement latency-aware agent selection. Individual agents broadcast their current latency, and the system routes tasks to the most responsive agent. This is a practical optimization for production systems where response time matters.

Common Enterprise Architecture

Most enterprise deployments follow a similar pattern:

• Gateway agent: Receives requests and discovers available specialists via Agent Cards
• Specialist agents: Handle specific domains (analysis, code generation, document processing)
• Shared storage layer: All agents read and write to a common workspace via MCP
• Monitoring: A2A task lifecycle events feed into observability platforms

For the storage layer, Fast.io provides built-in audit logs tracking every file access, modification, and download. Combined with A2A communication logs, you get end-to-end visibility into what your agents did and which files they touched.

Security in Production A2A doesn't mandate a specific auth mechanism. Common approaches by deployment context:

• Internal networks: Bearer tokens for low-complexity setups
• Cross-organization: OAuth with scoped permissions
• High-security: Mutual TLS between agent endpoints
• Fine-grained identity: JWT with agent-specific claims

Beyond authentication, production systems need authorization rules: which agents can invoke which skills, what data each agent can access, and monitoring to prevent sensitive information from leaking through agent chains.