AI Agent Protocols: How ACP and A2A united to simplify multi-agent communication

We previously published an article on the evolution of AI agents, which provides useful context for this article, you can read it here.

The artificial intelligence industry has reached an important milestone in its evolution. After months of parallel development, IBM's Agent Communication Protocol (ACP) and Google's Agent2Agent (A2A) protocol have merged under the Linux Foundation, marking a significant step toward standardization in AI agent communication. This consolidation, alongside Anthropic's Model Context Protocol (MCP), creates a clearer path forward for developers building multi-agent systems.

This comprehensive guide explores the evolution of these protocols, the rationale behind their consolidation, and the implications of this unified landscape for the future of AI collaboration.

The fragmentation challenge: Why we needed standards

Before diving into the protocols themselves, it's important to understand the problem they were created to solve. As AI agents proliferated across organizations, each was typically built in isolation using different frameworks like LangChain, AutoGen, CrewAI, or custom solutions. This created several critical challenges:

Integration complexity: Every agent pair required custom integration code
Exponential scaling issues: With N agents and M tools, organizations faced N×M potential integrations
Brittle connections: Updates to one agent often broke integrations with others
Vendor lock-in: Switching frameworks meant rewriting all integrations
Limited collaboration: Agents from different organizations couldn't easily work together

The industry needed standardized communication protocols, much like how HTTP standardized web communication decades ago.

The evolution: Three protocols emerge

Model Context Protocol (MCP): The foundation layer

MCP, introduced by Anthropic in late 2024, was the first major protocol to gain widespread adoption. It addressed a specific but crucial need: standardizing how AI models access tools and data sources.

Core innovation: MCP acts as a "universal adapter" between AI models and external resources. Rather than each model needing custom integrations for every tool, MCP provides a standardized interface.

Key capabilities:

Dynamic tool discovery at runtime
Standardized primitives (tools, resources, prompts)
JSON-RPC based communication
Hub-and-spoke architecture (one model, many tools)

MCP quickly became the de facto standard for model-to-tool communication, with broad community adoption and extensive tool ecosystem.

Agent Communication Protocol (ACP): IBM's open approach

In March 2025, IBM Research launched ACP to power its BeeAI Platform, an open-source platform for agent discovery and orchestration. ACP took a different approach than MCP, focusing specifically on agent-to-agent communication.

Design philosophy: ACP emphasized simplicity and openness. IBM donated both BeeAI and ACP to the Linux Foundation shortly after launch, demonstrating commitment to vendor-neutral development.

Distinguishing features:

REST/HTTP native (no special runtimes required)
Minimal implementation overhead (just a few lines of code)
Framework agnostic design
Open governance under Linux Foundation
Built to complement MCP rather than replace it

ACP gained traction particularly among developers who valued its lightweight approach and open governance model. The protocol made it possible to wrap existing agents with minimal code changes:

# Simple ACP wrapper example
from acp_sdk.models import Message
from acp_sdk.server import Server

server = Server()

@server.agent(name="my_agent")
async def handle_request(messages: list[Message]):
    # Your existing agent logic here
    result = process_messages(messages)
    return Message(parts=[MessagePart(content=result)])

server.run()

Agent2Agent (A2A): Google's comprehensive vision

A month after ACP's launch, Google announced A2A at Cloud Next 2025, backed by over 50 technology partners including Salesforce, SAP, MongoDB, and ServiceNow. A2A took a more comprehensive approach to agent communication.

Ambitious scope: A2A treated agent interactions as collaborative work sessions rather than simple message exchanges, supporting complex, long-running tasks with multiple interaction modalities.

Advanced features:

Task-oriented architecture with lifecycle management
Multi-modal support (text, audio, video, forms)
Agent Cards for capability discovery
Enterprise-grade security and authentication
Built-in support for webhooks and notifications

The journey to convergence

Recognizing alignment

Despite being developed independently, ACP and A2A shared fundamental goals: enabling agents to communicate across frameworks, organizations, and technology stacks. As Kate Blair, Director of Incubation for IBM Research who oversees ACP's development, noted: "When A2A came on the scene, we immediately saw alignment in how our teams approached the challenge of enabling agents to communicate."

Both protocols addressed the same layer of the stack (agent-to-agent communication) and faced similar technical challenges. Rather than fragmenting the ecosystem with competing standards, the teams began exploring collaboration.

Why consolidation makes sense

Several factors drove the convergence:

Developer simplicity: Having multiple protocols for the same purpose created confusion and additional work for developers. A unified standard simplifies decision-making and implementation.
Network effects: Communication protocols become more valuable as adoption increases. Two separate networks are less valuable than one combined network.
Resource efficiency: Rather than duplicating efforts on similar problems, combining expertise allows faster progress on harder challenges.
Industry maturity: The convergence signals that the AI industry is maturing beyond experimentation toward production-ready standards.
Complementary strengths: ACP brought simplicity and open governance experience; A2A brought comprehensive features and broad industry backing.

The merger: ACP joins A2A

In September 2025, IBM announced that ACP would officially merge with A2A under the Linux Foundation umbrella. This wasn't an acquisition or abandonment, but a true convergence of efforts. Key aspects of the merger include:

Unified governance: Kate Blair joined the A2A Technical Steering Committee alongside representatives from Google, Microsoft, AWS, Cisco, Salesforce, ServiceNow, and SAP
Technology integration: ACP's innovations and design principles are being incorporated into A2A
Open development: The combined protocol maintains open governance under the Linux Foundation
Migration support: Clear paths for existing ACP users to transition to A2A

The unified landscape: How the protocols work together

With the ACP-A2A convergence, the protocol landscape has become clearer and more complementary:

Layer	Protocol	Purpose	Key Capabilities
Model enhancement	MCP	Connect models to tools/data	Tool discovery, resource access, prompt templates
Agent communication	A2A (incorporating ACP)	Enable agent-to-agent collaboration	Task management, multi-modal communication, capability discovery
Orchestration	Platform-specific (e.g., BeeAI)	Manage multi-agent workflows	Agent registry, workflow definition, monitoring

MCP and A2A: A complementary stack

The relationship between MCP and A2A is particularly important. They operate at different layers and serve different purposes:

MCP handles the "vertical" integration: How an individual agent accesses tools, databases, and external resources. It's about giving agents capabilities.

A2A handles the "horizontal" integration: How agents communicate with each other to collaborate on tasks. It's about enabling teamwork.

A typical agent might use both protocols:

class ModernAgent:
    def __init__(self):
        # MCP for accessing tools
        self.mcp_client = MCPClient()

        # A2A for agent communication
        self.a2a_handler = A2AHandler()

    async def handle_task(self, task):
        # Use MCP to gather data from tools
        data = await self.mcp_client.call_tool("database_query", task.query)

        # Process the data
        analysis = self.analyze(data)

        # Use A2A to collaborate with other agents
        return await self.a2a_handler.send_to_agent("report_generator", analysis)

BeeAI: The platform that bridged the gap

BeeAI played a crucial role in the protocol evolution story. Originally built with ACP at its core, BeeAI demonstrated how a platform could make agent interoperability practical and accessible.

Key contributions

Reference implementation: BeeAI served as the proving ground for ACP, showing how the protocol could work in practice.
Developer experience: The platform abstracted away complexity, making it easy to deploy and compose agents from different frameworks.
Bridge to A2A: BeeAI was among the first to implement adapters between ACP and A2A, demonstrating practical interoperability.

Transition to A2A

With the merger, BeeAI has transitioned to use A2A as its communication protocol. The platform now offers:

A2AServer adapter: Makes BeeAI agents A2A-compliant
A2AAgent integration: Enables interaction with external A2A agents
Maintained simplicity: Preserves the developer-friendly experience while gaining A2A's capabilities

# BeeAI agent now using A2A
from beeai import Agent
from a2a import A2AServer

class MyBeeAIAgent(Agent):
    def process(self, input):
        # Your agent logic
        return result

# Make it A2A compliant
a2a_server = A2AServer(MyBeeAIAgent())
a2a_server.run()

Migration: Moving from ACP to A2A

For organizations that adopted ACP, the transition to A2A is designed to be straightforward. The official migration guide provides detailed steps, but here are the key points:

Core changes

Protocol format: While ACP used a simpler REST format, A2A uses a richer task-oriented structure. Most ACP patterns map directly to A2A equivalents.
Message structure: ACP's Message/MessagePart model translates to A2A's Message/Part model with additional metadata support.
Discovery mechanism: ACP's agent manifest becomes A2A's Agent Card with enhanced capability descriptions.

Migration strategy

# Before: ACP Agent
from acp_sdk import Server, Message

@server.agent(name="data_processor")
async def acp_agent(messages: list[Message]):
    result = process_data(messages[-1].content)
    return Message(content=result)

# After: A2A Agent
from a2a import AgentCard, Task, Message

class A2ADataProcessor:
    def __init__(self):
        self.card = AgentCard(
            name="data_processor",
            capabilities=["data_processing"],
            # Additional A2A metadata
        )

    async def handle_task(self, task: Task):
        result = process_data(task.message.content)
        return Message(content=result)

Gradual migration

Organizations don't need to migrate all agents at once. Both protocols can coexist during transition:

class BridgeAgent:
    """Handles both ACP and A2A protocols during migration."""

    async def handle_request(self, request):
        if is_a2a_request(request):
            return await self.handle_a2a(request)
        else:
            # Legacy ACP handling
            return await self.handle_acp(request)

Practical implications for different stakeholders

For developers

The convergence simplifies the development landscape significantly:

Single protocol to learn: Instead of choosing between ACP and A2A, developers can focus on one standard
Broader ecosystem: Access to tools and agents from both communities
Clearer architecture: MCP for tools, A2A for agents provides clear separation of concerns
Future-proof: Investment in A2A knowledge will remain valuable as the standard evolves
Open-source driven: Recognition and community involvement through open-source development

For technical decision-makers

The unified landscape offers several strategic advantages:

Reduced risk: Backing from major tech companies and Linux Foundation governance reduces abandonment risk
Simplified evaluation: Fewer protocols to evaluate and compare
Clear roadmap: Combined efforts provide more predictable evolution
Vendor flexibility: Open standards prevent lock-in to specific platforms

For business leaders

The consolidation represents industry maturity:

Stable foundation: Unified standards indicate the technology is moving beyond experimentation
Ecosystem growth: Larger combined community drives faster innovation
Partnership opportunities: Standardized communication enables cross-organization collaboration
Investment confidence: Convergence reduces the risk of backing the "wrong" standard

Conclusion: A practical evolution

The convergence of ACP and A2A under the Linux Foundation represents a practical evolution of the AI agent ecosystem. Rather than a "protocol war," we've witnessed something more valuable: recognition that collaboration trumps competition when building foundational infrastructure.

This unification, combined with MCP's established role in model-to-tool communication, creates a clearer and more robust foundation for multi-agent systems. Developers benefit from simplified choices and broader ecosystems. Organizations gain confidence from industry-wide backing and open governance. Most importantly, the convergence accelerates progress toward truly interoperable AI systems that can collaborate across boundaries.

The journey from fragmentation through parallel development to convergence demonstrates the AI industry's growing maturity. By choosing collaboration over competition, IBM, Google, and the broader community have created a stronger foundation for the next generation of AI applications.

As we move forward, the unified protocol landscape means less time spent on integration plumbing and more time building intelligent, collaborative agent systems that solve real problems. The promise of seamless multi-agent collaboration is closer to reality than ever before.

Resources and next steps

To get started with the unified protocol landscape:

A2A resources (incorporating ACP)

MCP resources

Community and learning

The future of AI lies not in isolated intelligence but in collaborative systems working together seamlessly. With the convergence of agent communication protocols, that future is becoming a practical reality.

Table of contents