A2A: Google's Agent-to-Agent Protocol Now Under Linux Foundation

The AI agent ecosystem is experiencing a Cambrian explosion. Frameworks for building agents – LangChain, CrewAI, AutoGen, Semantic Kernel, Vertex AI Agent Builder – are multiplying rapidly, each with its own internal communication patterns, data formats, and capability advertising mechanisms. This fragmentation creates a fundamental problem: agents built with different frameworks cannot talk to each other.

A2A (Agent-to-Agent), an open protocol initially developed by Google and contributed to the Linux Foundation, aims to solve this interoperability crisis. It defines a standard communication protocol that any agent can implement, regardless of the underlying framework, allowing agents built with different tools to discover each other, negotiate tasks, share information, and collaborate on complex workflows.

The protocol operates at a level above individual agent frameworks. Whether an agent is built with LangChain, Semantic Kernel, or a custom framework, as long as it implements the A2A protocol, it can communicate with any other A2A-compatible agent. This network effect makes each individual agent more valuable – every new A2A-compatible agent is a potential collaborator for every existing one.

How Does the A2A Protocol Enable Agent Communication?

A2A’s architecture is built around two core concepts: agent cards for discovery and structured messages for communication.

flowchart TD
    A[Agent A\nFramework: LangChain] --> B[A2A Protocol Layer]
    C[Agent B\nFramework: Semantic Kernel] --> D[A2A Protocol Layer]
    E[Agent C\nFramework: Custom] --> F[A2A Protocol Layer]

    B --> G[Service Discovery\nAgent Cards Published]
    D --> G
    F --> G

    G --> H{A2A Message Exchange\nStructured JSON Protocol}
    H --> I[Task Negotiation\nCapability Matching]
    H --> J[Data Exchange\nStructured Payloads]
    H --> K[Result Delivery\nCompletion Signals]

    I --> L[Multi-Agent Workflow\nCross-Framework Collaboration]

Each agent publishes an agent card – a JSON document that describes the agent’s capabilities, supported tasks, authentication requirements, and communication endpoints. Other agents discover agent cards through a registry or direct query. Once discovered, agents communicate through structured messages that include task definitions, progress updates, data payloads, and completion signals.

What SDKS and Implementation Options Are Available?

A2A provides official SDKs for the most common programming languages, making implementation straightforward for agent developers.

The Python SDK is the most mature and is used in the reference implementation. It supports both synchronous and asynchronous agent communication, streaming for real-time interactions, and built-in authentication mechanisms.

How Is A2A Governed and Who Is Involved?

The Linux Foundation governance model ensures that no single company controls the protocol’s evolution.

This multi-stakeholder governance is critical for a protocol that aims to be the universal standard for agent communication. It provides assurance that the protocol will evolve in a way that benefits the entire ecosystem, not just any single vendor.

What Are the Practical Use Cases for A2A?

A2A enables use cases that were previously impossible or required tight coupling between agent implementations.

A concrete example: a customer service agent built with LangChain can discover a knowledge base agent built with Semantic Kernel, query it for relevant documentation, receive structured results, and use those results to answer a customer question – all without either agent knowing anything about the other’s internal framework.

What Frameworks Currently Support A2A?

Since its contribution to the Linux Foundation, A2A has gained broad industry adoption.

The breadth of support across competing AI platforms is a strong signal of the protocol’s potential to become the industry standard for agent interoperability.

FAQ

What is the A2A (Agent-to-Agent) protocol? A2A is an open protocol developed by Google and contributed to the Linux Foundation that enables secure, standardized communication and interoperability between autonomous AI agents built with different frameworks.

How does A2A work? A2A defines a standard message format and discovery mechanism for AI agents. Agents advertise their capabilities through published agent cards, and other agents can discover, authenticate, and communicate with them using the A2A protocol’s structured message types.

What SDK languages does A2A support? A2A provides official SDKs in Python, TypeScript/JavaScript, and Java, with community SDKs emerging for Go, Rust, and other languages.

How is A2A governed? A2A is governed by the Linux Foundation through an open governance model with a steering committee that includes representatives from Google, Microsoft, Anthropic, OpenAI, and other major AI companies.

What agent frameworks currently support A2A? Major frameworks including Google’s Vertex AI Agent Builder, Microsoft’s Semantic Kernel, Anthropic’s Claude API, CrewAI, AutoGen, LangChain, and others have implemented or announced support for A2A.

Further Reading

• A2A Protocol GitHub Repository – Official specification, SDKs, and examples
• Linux Foundation AI & Data – The governing organization for A2A
• Google A2A Announcement – Google’s official A2A announcement and documentation
• A2A Protocol Specification – The full technical protocol specification