What Is Google's A2A Protocol? Agent-to-Agent Communication Explained

In April 2025, Google introduced the Agent2Agent Protocol (A2A), an open standard that lets AI agents discover, communicate with, and delegate tasks to other AI agents. MCP gives an agent access to tools. A2A lets an agent work with other agents. With it, separate AI assistants can form multi-agent systems for enterprise workflows.

What Is the A2A Protocol?

The Agent2Agent Protocol (A2A) is an open communication protocol that lets AI agents talk to each other, regardless of the framework or vendor that built them. It works as a common language between agents. A Salesforce agent can ask a SAP agent to check inventory, and a travel-booking agent can coordinate with a payments agent. Neither side needs to know the other's internal architecture.

Before A2A, multi-agent systems were largely proprietary. An agent built in LangChain could talk to other LangChain agents, but not to agents in Google's ADK or Amazon Bedrock. A2A removes those silos with a vendor-neutral protocol built on existing web standards: HTTPS for transport, JSON-RPC 2.0 for messaging, and Server-Sent Events (SSE) for streaming.

Why A2A Matters

Enterprise software is full of specialized systems: CRM, ERP, HR, finance, supply chain. Each of these systems is increasingly powered by AI agents, and the agents work in isolation. A customer service agent can look up an order, but it cannot ask the logistics agent for real-time shipping status. A procurement agent finds suppliers, but it cannot coordinate with the finance agent for budget approval.

A2A gives agents a standard way to:

• Discover each other through Agent Cards, machine-readable JSON files that describe what an agent can do
• Delegate tasks with a well-defined lifecycle (submitted, working, completed, failed)
• Exchange rich content including text, files, and structured data
• Stream updates in real time for long-running operations
• Negotiate authentication before any data is exchanged

Salesforce's Gary Lerhaupt described the goal this way: "The future of enterprise AI lies in agent-to-agent collaboration" for orchestrating disconnected systems. A2A aims to make that collaboration possible without vendor lock-in.

The Agent Card: Your Agent's Business Card

At the heart of A2A is the Agent Card , a JSON document at a well-known URL that describes what a client agent needs to know before it talks to your agent. It is a machine-readable business card for AI agents.

The Agent Card lives at /.well-known/agent-card.json (earlier versions of the spec used /.well-known/agent.json). It includes:

• Identity: Name, description, provider, and version
• Service URL: The endpoint where the agent accepts tasks
• Capabilities: Whether the agent supports streaming, push notifications, or extended cards
• Skills: Specific tasks the agent can perform, with input/output types
• Authentication: Required security schemes (API key, OAuth 2.0, OpenID Connect, Mutual TLS)
• Input/Output modes: Supported MIME types for communication

A real Agent Card looks like this:

{
  "name": "Acme Inventory Agent",
  "description": "Real-time inventory lookup and availability checking for Acme Corp products.",
  "url": "https://agents.acme.com/inventory",
  "provider": {
    "organization": "Acme Corp",
    "url": "https://acme.com"
  },
  "version": "1.0.0",
  "capabilities": {
    "streaming": true,
    "pushNotifications": true
  },
  "securitySchemes": {
    "oauth2": {
      "type": "oauth2",
      "flows": {
        "clientCredentials": {
          "tokenUrl": "https://auth.acme.com/token",
          "scopes": {
            "inventory:read": "Read inventory levels"
          }
        }
      }
    }
  },
  "security": [{ "oauth2": ["inventory:read"] }],
  "defaultInputModes": ["application/json", "text/plain"],
  "defaultOutputModes": ["application/json", "text/plain"],
  "skills": [
    {
      "id": "check-availability",
      "name": "Check Product Availability",
      "description": "Check real-time stock levels for a given SKU across all warehouses.",
      "inputModes": ["application/json"],
      "outputModes": ["application/json"]
    },
    {
      "id": "reserve-stock",
      "name": "Reserve Inventory",
      "description": "Place a temporary hold on inventory for a pending order.",
      "inputModes": ["application/json"],
      "outputModes": ["application/json"]
    }
  ]
}

How A2A Works: The Task Lifecycle

A2A communication works in three steps: discover, authenticate, and communicate. The client agent finds a suitable remote agent through its Agent Card, authenticates, and then sends tasks that follow a defined lifecycle.

Step 1: Discovery

The client agent fetches the Agent Card from the remote agent's well-known URL. It checks the skills, capabilities, and auth requirements to decide whether this agent can help with the current task.

Step 2: Authentication

Based on the security schemes in the Agent Card, the client authenticates. A2A supports the same security schemes as the OpenAPI specification:

• API Key: simple token-based auth
• HTTP Bearer: JWT or opaque tokens
• OAuth 2.0: Authorization Code, Client Credentials, or Device Code flows
• OpenID Connect: identity-layer authentication
• Mutual TLS: certificate-based mutual authentication

Step 3: Task Execution

The client sends a message to the remote agent, which creates a Task. The task is the central unit of work in A2A. Each task has a unique ID and moves through defined states:

Tasks produce Artifacts: tangible outputs like documents, data payloads, or files. Each artifact and message consists of Parts: TextPart for plain text, FilePart for binary data, and DataPart for structured JSON.

Real-Time Updates: Streaming and Push Notifications

For long-running tasks, A2A supports two real-time update mechanisms:

• Streaming via SSE: The client opens a persistent connection and receives incremental updates as the task progresses. The SendStreamingMessage method delivers status changes and partial artifacts in real time.
• Push Notifications via Webhooks: For asynchronous workflows, the client registers a webhook URL. The remote agent POSTs status updates (TaskStatusUpdateEvent) and artifact deliveries (TaskArtifactUpdateEvent) to this endpoint.

Transport Protocols

A2A v0.3 supports three transport bindings. The right choice depends on your infrastructure:

gRPC was added in v0.3. It is a binary transport option with lower latency and smaller payloads, useful for distributed enterprise systems.

A2A vs MCP: Complementary, Not Competing

A common question about A2A is how it relates to Anthropic's Model Context Protocol (MCP) ? In short, the two protocols solve different problems and are designed to work together.

The difference in one sentence: MCP connects an agent to tools and data sources (databases, APIs, file systems). A2A connects agents to other agents for task delegation and collaboration.

Take a procurement workflow as an example. The procurement agent uses MCP to query internal databases for purchase history and budget data. That same agent uses A2A to delegate price comparison to an external supplier agent and request budget approval from a finance agent. MCP handles the vertical integration with tools, and A2A handles the horizontal collaboration between agents.

Who Backs A2A?

A2A has gained enterprise support since its April 2025 launch. The timeline:

• April 9, 2025: Google announces A2A with 50+ technology partners
• June 23, 2025: Google donates A2A to the Linux Foundation for vendor-neutral governance
• July 31, 2025: A2A v0.3 released with gRPC support, signed Agent Cards, and enhanced Python SDK
• 2025 Q3–Q4: 150+ organizations support the protocol

Linux Foundation Governance

With the Agent2Agent project under the Linux Foundation, A2A moved from a Google-led initiative to a vendor-neutral standard. The founding members:

Beyond the founding members, A2A is backed by technology companies (Atlassian, Box, Cohere, Intuit, LangChain, MongoDB, PayPal, UKG, Workday) and global consulting firms (Accenture, BCG, Capgemini, Cognizant, Deloitte, HCLTech, Infosys, KPMG, McKinsey, PwC, TCS, Wipro).

Current Adoption and Real-World Implementations

Several platforms already integrate A2A into their agent ecosystems:

• Salesforce Agentforce: Integrating A2A so its AI agents can work with agents from other platforms
• SAP Joule: Working on A2A to connect its enterprise AI assistant with external agent ecosystems
• ServiceNow Agent Control Tower: Adding A2A support to its agent orchestration platform for cross-platform workflows
• Google ADK: A2A support is built directly into Google's Agent Development Kit, so any ADK-built agent speaks A2A natively
• Amazon Bedrock AgentCore: AWS has documented A2A as a supported protocol contract for Bedrock agents

The protocol also has SDKs and reference implementations available in Python and Java (with a Quarkus integration).

How to Implement A2A

How you implement A2A depends on whether you expose an agent (server) or consume agents (client). This section covers the common server case: making your AI agent discoverable and callable by other agents.

Step 1: Create Your Agent Card

Host a JSON file at /.well-known/agent-card.json on your domain. This is the entry point for agent discovery:

{
  "name": "Your Agent Name",
  "description": "Clear, concise description of what your agent does.",
  "url": "https://yourdomain.com/a2a",
  "provider": {
    "organization": "Your Company",
    "url": "https://yourdomain.com"
  },
  "version": "1.0.0",
  "capabilities": {
    "streaming": false,
    "pushNotifications": false
  },
  "securitySchemes": {
    "apiKey": {
      "type": "apiKey",
      "in": "header",
      "name": "X-API-Key"
    }
  },
  "security": [{ "apiKey": [] }],
  "defaultInputModes": ["application/json"],
  "defaultOutputModes": ["application/json"],
  "skills": [
    {
      "id": "your-skill-id",
      "name": "Human-Readable Skill Name",
      "description": "What this skill does and when to use it."
    }
  ]
}

Step 2: Implement the A2A Endpoints

At a minimum, your A2A server must handle these JSON-RPC methods:

• message/send: Receive a message from a client agent and create or update a task
• tasks/get: Return the current state of a task by ID
• tasks/cancel: Cancel an in-progress task

Optional methods add more functionality:

• message/stream: Stream real-time updates via SSE
• tasks/list: List tasks for a given context
• tasks/pushNotification/*: Manage webhook subscriptions

Step 3: Handle the Task Lifecycle

When a client sends a message, your server should:

1. Validate authentication against your declared security schemes
2. Create a new Task with status WORKING
3. Process the request. If you need more information, set status to INPUT_REQUIRED
4. Generate Artifacts (your output) and set status to COMPLETED
5. If something goes wrong, set status to FAILED with a descriptive error message

{
  "jsonrpc": "2.0",
  "id": "req-001",
  "method": "message/send",
  "params": {
    "message": {
      "role": "user",
      "parts": [
        {
          "kind": "text",
          "text": "Check availability for SKU-7890 in the EU warehouse"
        }
      ]
    }
  }
}

{
  "jsonrpc": "2.0",
  "id": "req-001",
  "result": {
    "id": "task-abc-123",
    "status": {
      "state": "completed"
    },
    "artifacts": [
      {
        "parts": [
          {
            "kind": "data",
            "data": {
              "sku": "SKU-7890",
              "warehouse": "EU-AMS",
              "available": 342,
              "reserved": 18
            }
          }
        ]
      }
    ]
  }
}

What Implementing A2A Means for Your Website

Implementing A2A has four practical consequences for a website:

IsAgentReady checks for a valid Agent Card at /.well-known/agent-card.json. An A2A Agent Card is emerging bonus evidence and does not affect the headline score. WebMCP is experimental, non-scored evidence. Neither signal predicts adoption or task success.

Who Should Implement A2A?

A2A does not fit every website. It fits services that have capabilities other agents would want to use. Consider A2A if you are:

• SaaS platforms with APIs that other systems integrate with (CRM, ERP, HR, e-commerce)
• API providers offering data or services that AI agents could consume (weather, payments, shipping, identity verification)
• AI service companies building specialized agents that should collaborate with other agents
• Enterprise software vendors whose products are part of larger business workflows
• Marketplace operators where multiple parties need coordinated interactions

If your website is primarily informational (blog, portfolio, marketing site), A2A is less relevant. Focus on the other AI readiness categories, such as structured data, semantic HTML, and content discovery .

Security Considerations

A2A includes these security features:

• Opaque agents: Agents never expose their internal logic, memory, or proprietary implementations. They share only what the Agent Card declares.
• Signed Agent Cards: As of v0.3, Agent Cards can be cryptographically signed using JWS (RFC 7515), allowing clients to verify the agent's identity and the card's integrity before connecting.
• Standard auth schemes: A2A aligns with OpenAPI security schemes, so enterprises can use their existing OAuth 2.0 and OIDC infrastructure.
• Zero-trust compatible: The protocol supports mutual TLS and can integrate with enterprise zero-trust architectures.
• Task-level access control: Each skill can declare its own security requirements, enabling fine-grained permissions.

Timeline and Roadmap

The milestones so far:

The protocol is still evolving. Expected changes are formal authorization scheme inclusion in Agent Cards, dynamic skill validation methods, and support for dynamic UX negotiation (adding audio/video mid-conversation).

Getting Started Today

Whether you plan a full A2A implementation or want to explore first, these steps help:

1. Publish an Agent Card: Start with a minimal /.well-known/agent-card.json describing your service and its capabilities. Even without backend endpoints, this makes your agent discoverable.
2. Scan your website: Use IsAgentReady to see how your site scores on agent protocol support.
3. Explore the spec: The official A2A specification is well-documented and includes transport binding details for JSON-RPC, gRPC, and REST.
4. Try the SDK: Google provides Python and Java SDKs with sample implementations. Check the A2A GitHub repository for quickstarts.
5. Read the Agent Card spec: Learn the required and optional fields so your Agent Card is complete.

Conclusion

A2A standardizes how AI agents work together. It defines an agent web, a network where AI agents discover, authenticate with, and delegate tasks to each other across organizational boundaries.

The Linux Foundation, founding members such as Google, AWS, Microsoft, Salesforce, SAP, and ServiceNow, and over 150 participating organizations show substantial standards activity. That participation does not prove future adoption, so implementation should follow a concrete interoperability need.

Sources

• A2A Protocol Specification : Official protocol specification with full technical details
• Announcing the Agent2Agent Protocol (A2A) : Google's original announcement blog post (April 2025)
• Agent2Agent Protocol is Getting an Upgrade : Google Cloud blog on v0.3 enhancements
• Linux Foundation Launches the Agent2Agent Protocol Project : Linux Foundation governance announcement
• A2A GitHub Repository : Open source code, SDKs, and sample implementations
• What Is Agent2Agent (A2A) Protocol? : IBM's technical overview
• MCP vs A2A: A Guide to AI Agent Communication Protocols : Auth0's comparison of the two protocols
• What's New with Agents: ADK, Agent Engine, and A2A Enhancements : Google I/O updates
• Google Upgrades Agent2Agent Protocol with gRPC and Enterprise-Grade Security : InfoWorld analysis of v0.3
• Google Advances A2A Protocol, Gains Microsoft and SAP Backing : Cloud Wars coverage of enterprise adoption