ACP Explained: The Vendor-Neutral Backbone for Cooperative AI
As AI agents grow more autonomous and interconnected, there's an increasingly urgent need for more structured communication. That’s why protocols like Anthropic’s Model Context Protocol (MCP) for tool interaction and Google’s Agent-to-Agent (A2A) initiative are gaining serious traction.
A new protocol called Agent Communication Protocol (ACP) — originally proposed by IBM Research and now hosted under the Linux Foundation — enters this landscape with a focus on inter-agent coordination, allowing agents to exchange goals, data, and tasks through a vendor-neutral, HTTP-based API.
Whether you’re an AI researcher or someone who is simply curious about the future of intelligent systems, this is your guide to how ACP will shape the emerging ecosystem of cooperative agents from robotics to enterprise automation. Today's newsletter will cover:
Why there's a need for structured Agent-to-Agent communication
Existing A2A communication efforts such as Anthropic’s MCP and Google’s A2A
What ACP brings to the table and the different domains it's already impacting
The future of A2A communication
What exactly is ACP?#
The Agent Communication Protocol (ACP) is an open standard for agent-to-agent communication. It’s a common “language” that allows AI agents — which might be built on different frameworks or by different teams — to exchange messages, coordinate tasks, and work together. Today’s AI agents operate like isolated islands, each with its own code and API, making integration a manual, fragile affair (or, as one expert put it, “every integration is costly duct tape”).
ACP aims to change that by turning these siloed agents into an interoperable network of collaborators.
Think back to the early days of the web: before common protocols, sharing information between computers was complicated. Then HTTP came along and allowed any web page to be accessed by any browser. Similarly, ACP is being touted as the “HTTP for AI agents,” providing a standardized way for agents to communicate and cooperate. This matters because we’ll increasingly have multi-agent systems as AI systems grow more complex. Without a common protocol, such cooperation is difficult. With ACP, however, agents can discover each other, exchange information, divide work, and negotiate decisions through a shared interface.
Why does ACP matter now?#
The AI community is racing toward more connected, autonomous systems.
Big tech and researchers are concerned about fragmentation or the “Tower of Babel” problem, where each agent platform speaks a different language. ACP addresses this by standardizing inter-agent communication in an open, vendor-neutral way.
This can accelerate innovation by making it easier to plug agents together, without reinventing integration code for each new combination. For example, IBM’s Kate Blair (one of ACP’s leads) says the goal is to let AI agents “connect and collaborate to carry out complex tasks” with zero vendor lock-in. In short, ACP could be a foundation that unifies AI agents across frameworks, similar to how USB connectors or internet protocols unified hardware and networks. Next, let’s see how ACP works under the hood.
Core components of ACP#
At its core, ACP defines a simple, flexible way for agents to send messages and requests to each other over standard web technologies (HTTP/REST).
You can imagine an ACP-enabled agent like a web service: each agent runs inside an ACP server that exposes a RESTful API endpoint, and other agents (or applications) act as ACP clients that send HTTP requests to that endpoint. This client-server design means any agent can call any other agent’s capabilities through a common protocol, similar to how web browsers talk to websites.
Notably, ACP is “SDK-optional”; in other words, you don’t need special libraries to use it (though libraries do exist). An ACP agent can be poked with a simple curl command or a Postman request, thanks to using familiar HTTP verbs and JSON data.
ACP's 8-step process#
This is the typical life cycle of how an ACP client discovers, invokes, and receives responses from an agent wrapped in the ACP protocol.
Step 1 - Build the agent logic: We begin by implementing the core functionality of our AI agent. This could be a chatbot, planner, simulator, or any logic module designed to perform a task.
Step 2 - Wrap the agent with an ACP server: Next, we encapsulate the agent within an ACP-compliant server that exposes its capabilities through a RESTful API using standard HTTP methods.
Step 3 - Define and publish the agent manifest: Then, we create a manifest that describes what the agent can do, what inputs it accepts, what outputs it produces, and how it communicates.
Step 4 - Discover the agent: We need to make the agent discoverable by clients, either through a central registry, peer sharing of manifests, or manual configuration in multi-agent workflows.
Step 5 - Send a task request: An ACP client sends a structured task request to the agent’s endpoint using HTTP, formatted as an ACP message with the necessary input data.
Step 6 - Agent processes the request: The agent receives the request and performs its internal logic to process the task, prepare results, and construct an appropriate response.
Step 7 - Send structured response: The agent returns a multipart response, potentially containing text, images, and structured data, each labeled with MIME types so the client can interpret them correctly.
Step 8 - Stream or delay the response (optional): If the task is long-running, the agent can stream partial results or send a delayed response asynchronously without blocking the client.
Flexible agent interactions and deployment patterns#
ACP offers architectural flexibility that supports both conversational context and modular deployment:
Supports stateless and stateful interactions: Agents can operate statelessly (like typical API calls) or statefully by maintaining session context. This is useful for multi-turn conversations or long-running planning sessions. The stateful session uses session IDs, allowing agents to remember prior inputs, track user intent, or manage continuity in the workflow.
Agents can be modular and brokered: An ACP server can host multiple agents simultaneously, each addressable via routing keys or metadata.
An agent can act as both client and server: This enables an agent to call another agent internally, a key feature for complex workflows or delegation logic.
Router agents enable task decomposition: A high-level router agent can receive a task and delegate subtasks to specialist agents in advanced setups. These specialist calls can even use other protocols like MCP when needed.
Let’s ground this flexibility with a concrete example.
Imagine an AI agent that’s an expert translator. Under ACP, we might wrap this translator in a lightweight server that provides a /translate endpoint. Any other agent or app that speaks ACP can send an HTTP request to /translate (with the text and target language, for example) and get the translated text back in a structured response. If we later develop a new, better translation agent with a different internal implementation, we can swap it in as long as it abides by ACP’s interface. The rest of the system doesn’t break, because the communication protocol stays the same. This highlights one of ACP’s core benefits: agents become interchangeable and interoperable components, a plug-and-play style.
How is ACP different from MCP?#
ACP and MCP serve complementary roles in the emerging landscape of agent protocols, but they focus on very different things. ACP is about agent-to-agent communication, enabling agents to exchange messages, delegate tasks, and collaborate over standard web protocols like HTTP. In contrast, Anthropic’s Model Context Protocol (MCP) focuses on agent-to-tool interaction and defines how agents call external tools or APIs using JSON-RPC, acting like a “USB-C” for plugging in capabilities.
A key difference is that ACP doesn’t dictate how an agent performs its internal logic, only how it communicates with others. This means one agent might be built using OpenAI’s APIs, another in PyTorch, and another using a logic engine. They can still talk to each other seamlessly as long as they follow ACP. This interoperability across frameworks is one of ACP’s biggest strengths.
In practice, you might have an agent use MCP to fetch data from a tool or service, and then use ACP to share that data with a peer agent to jointly reason about an action.
Domains and applications of ACP#
AI agents that can communicate open up a world of possibilities. Below are key domains and applications where ACP and similar protocols are making an impact:
Robotics and autonomous vehicles: Communication is vital for coordination in multi-robot systems and self-driving car networks. Agents (robots/vehicles) share state, intentions, and requests for effective collaboration. For example, self-driving cars at an intersection broadcast trajectories and negotiate passage to cross safely without traffic lights. Similarly, delivery drones form ad-hoc teams, and truck fleets platoon on highways, coordinating speed and distance for fuel efficiency. Agent Communication Protocol (ACP) standardizes these interactions, ensuring mutual understanding. Research shows information sharing is key to coordinated work distribution, spatial coverage, and mutual safety. ACPs enable heterogeneous robots to communicate requests, divide tasks, or alert each other to hazards seamlessly (e.g., a mobile robot asking a drone for a visual inspection).
Distributed systems and enterprise automation: ACP connects AI agents across different software systems, streamlining complex processes like supply chain management and IT operations. Instead of custom, brittle integrations, ACP allows agents to communicate directly via a standardized interface. This “agentic collaboration” enables seamless data exchange, as seen in a manufacturer’s agent getting real-time shipping estimates from a logistics agent. Similarly, an anomaly-detection agent can trigger an incident-response agent to create tickets and deploy fixes in IT automation. ACP simplifies distributed multi-agent workflows across various domains by providing a unified protocol for inter-system task orchestration.
Game theory and multi-agent negotiation: Game theory provides tools for strategic dialogues between agents, which are enabled by Agent Communication Protocols (ACPs). For instance, bidding agents negotiate in online marketplaces, and in network routing, agents manage bandwidth. Standardized protocols ensure clear exchanges. Game-theoretic principles enhance multi-agent communication by aligning incentives and enabling coalition formation. In cooperative robotics, teams negotiate tasks for optimal outcomes. In supply chains, ACPs allow agents to negotiate schedules and resources. Google’s A2A protocol emphasizes peer-to-peer communication for dynamic task negotiation in IT operations and supply chain management. This underscores the importance of structured agent dialogue. ACPs lay the groundwork for agents to reach agreements in game-theoretic settings and help prevent undesirable outcomes by designing incentive-compatible communication rules.
AI agent collaboration and orchestration: Emerging AI agent ecosystems involve multiple specialized AI agents collaborating on complex tasks. The Agent Communication Protocol (ACP) standardizes how these agents “pass the baton.” For example, in content creation, a research agent gathers info, a writing agent drafts, and an SEO agent refines. This allows agents to focus on their strengths and produce better output collectively. Early multi-agent workflows are already being tested, with “router” agents breaking down requests and assigning sub-tasks via ACP. Open-source platforms like IBM’s BeeAI use ACP to discover, run, and compose agents into larger solutions. ACP provides a common framework for multi-agent collaboration, effectively turning individual AI services into interoperable “teammates” that can converse and collectively solve problems.
Future directions and challenges in ACP research#
As ACP and similar protocols gain traction, standardization of semantics, security, and trust are key challenges. Agents need a shared understanding of message meaning through common ontologies and robust security measures for cross-network communication. A layered ecosystem of protocols, rather than a single winner, is expected, with ACP handling multi-agent dialogues alongside other specialized protocols.
The research community is actively prototyping and testing ACP, which is currently in alpha release, and aims to incorporate lessons from early adopters. Future impact includes the rise of agent ecosystems spanning organizations, with intelligent agents collaborating on global problems. This journey is just beginning, and ACP’s open, community-driven governance will be vital for its evolution and wide adoption.
Agent Communication Protocol is set to become a key piece of the AI infrastructure puzzle. By giving our AI agents a common language, ACP can unlock richer collaboration and multi-agent solutions that were previously too brittle or complex to implement. The road ahead will involve technical hurdles and likely some consolidation of ideas (ACP vs. A2A vs. others). However, the destination, an ecosystem of AI agents that “can discover, understand, and collaborate with others, regardless of who built them or what stack they run on,” is incredibly compelling.
The introduction of a new communication protocol is a rare and significant event. It presents a valuable opportunity for AI researchers and technologists to engage with and help shape the future of multi-agent systems.
To dive deeper into building the agents that will power this new ecosystem, we recommend the following courses:
