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 agents their tools. A2A gives them colleagues. Isolated AI assistants become collaborative multi-agent systems that can handle complex 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. Think of it as a common language for AI agents. A Salesforce agent can ask a SAP agent to check inventory, a travel-booking agent can coordinate with a payments agent, without either knowing the other's internal architecture.

Before A2A, multi-agent systems were largely proprietary. Built agents in LangChain? They could talk to other LangChain agents. But not to agents in Google's ADK or Amazon Bedrock. A2A breaks down 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 increasingly powered by AI agents. The problem: these agents operate in isolation. A customer service agent can look up an order, but can't ask the logistics agent for real-time shipping status. A procurement agent finds suppliers, but can't coordinate with the finance agent for budget approval.

A2A solves this with a standard way for agents 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 put it well: "The future of enterprise AI lies in agent-to-agent collaboration" for orchestrating disconnected systems. A2A makes 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 hosted at a well-known URL that describes everything a client agent needs to know before talking to your agent. Literally a machine-readable business card for AI agents.

The Agent Card is hosted 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

Here's what a real Agent Card looks like:

{
  "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 via its Agent Card, authenticates, then sends tasks using a well-defined lifecycle.

Step 1: Discovery

The client agent fetches the Agent Card from the remote agent's well-known URL. It inspects skills, capabilities, and auth requirements to determine if 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. That's the central unit of work in A2A. Each task has a unique ID and progresses through well-defined states:

Tasks produce Artifacts: tangible outputs like documents, data payloads, or files. Each artifact and message is composed of Parts. TextPart for plain text, FilePart for binary data, 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. Which one you pick depends on your infrastructure:

gRPC was added in v0.3. A binary transport option for high-performance agent communication with lower latency and smaller payloads, useful for distributed enterprise systems.

A2A vs MCP: Complementary, Not Competing

The question I get most about A2A: how does it relate to Anthropic's Model Context Protocol (MCP) ? Short answer: they solve different problems and are designed to work together.

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

A real-world example: a procurement workflow. 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 for the vertical integration with tools, A2A for the horizontal collaboration between agents.

Who Backs A2A?

A2A has rapidly 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 now supporting 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 has backing from major 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

Major platforms are already integrating A2A into their agent ecosystems:

• Salesforce Agentforce: Integrating A2A to enable its AI agents to collaborate with agents from other platforms
• SAP Joule: Collaborating on A2A to connect its enterprise AI assistant with external agent ecosystems
• ServiceNow Agent Control Tower: Building A2A support into 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), making it accessible to most enterprise development teams.

How to Implement A2A

Implementing A2A depends on whether you're exposing an agent (server) or consuming agents (client). Here's the most common 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 needs to 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 for enhanced 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 gives you both immediate and strategic benefits:

IsAgentReady checks for A2A Agent Card presence as part of the Agent Protocols category (15% of your overall score). Having a valid Agent Card at /.well-known/agent-card.json directly improves your AI agent readiness score.

Who Should Implement A2A?

A2A is not for every website. It's specifically for 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, like structured data, semantic HTML, and content discovery .

Security Considerations

A2A was designed with enterprise security in mind. Key features:

• Opaque agents: Agents never expose their internal logic, memory, or proprietary implementations. They only share what's declared in the Agent Card.
• 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

A2A is moving fast. From concept to enterprise standard:

The protocol is still evolving. Expected improvements: 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

Ready for a full A2A implementation, or just exploring? Practical next steps:

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: Understand all required and optional fields to make your Agent Card as complete as possible.

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.

With the backing of the Linux Foundation, founding members like Google, AWS, Microsoft, Salesforce, SAP, and ServiceNow, and over 150 organizations behind it, A2A is on track to become the standard for enterprise agent interoperability. Multi-agent collaboration is becoming the norm. The question is whether your services will be part of that ecosystem when it does.

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