Agents in Dialogue Part 2: ACPs - The Foundational Languages of Agent Collaboration

Michael Mueller
AIA2A ProtocolAgent CommunicationGoogle AIAI CollaborationAI OrchestrationAI StandardsMulti-Agent SystemsAI Agents
Agents in Dialogue Part 2: ACPs - The Foundational Languages of Agent Collaboration

In our previous blog post, Agents in Dialogue Part 1: MCP - The Universal Connector for AI and its Tools, we dived into the Model Context Protocol (MCP) and its crucial role in connecting AI agents to external tools and data sources. This capability is undeniably crucial for AI in the real-world. However, as AI systems grow in sophistication, the need for agents to communicate directly with each other becomes equally paramount. The vision of collaborative AI, where multiple specialised agents work orchestrated to achieve complex goals, hinges on their ability to engage in meaningful dialogue. This article examines the foundational Agent Communication Protocols (ACPs) that tackles this challenge, laying the essential groundwork for the advanced inter-agent collaboration we see emerging today.

Looking for other parts of the series? Read Part 1: MCP - The Universal Connector for AI and its Tools or Part 3: A2A Protocol - Orchestrating Modern AI Agent Teams.

Defining the Agent Communication Protocol (ACP)

The Agent Communication Protocol (ACP) is an open standard with open governance, designed to enable interoperability between different AI agents.29 At its heart, ACP defines a standardised RESTful API that supports synchronous, asynchronous, and streaming interactions, allowing agents to exchange multimodal messages.29, 30 A key characteristic is its agnostic stance towards the internal implementation of the agents; it specifies only the minimal requirements for compatibility, aiming for seamless interaction across diverse technology stacks and frameworks.30, 31 In essence, an agent in the ACP paradigm is a software service that communicates through these well-defined interfaces.30

Core Motivation and Design Philosophy

The idea behind ACP is to eliminate the silos that currently fragment the AI landscape.29, 30 Incompatibility between agent frameworks leads to duplicated development efforts, significant integration hurdles, challenges in scalability, and an inconsistent experience for developers.29 ACP takles these issues by proposing a shared communication standard. The goal is to allow agents built with varied frameworks—such as BeeAI, LangChain, or CrewAI—or even custom-coded agents to discover, compose, and collaborate effectively through a unified interface.29, 32

The design philosophy of ACP 30:

  • Simplicity First: The protocol is intended to be easy to implement for basic functionality.
  • Progressive Complexity: It offers clear pathways to incorporate more advanced capabilities without burdening initial adoption with undue complexity.
  • Minimal Assumptions: ACP avoids imposing specific orchestration patterns or architectural requirements on the agents themselves.

Architectural Highlights and Key Features

ACP's architecture is intentionally straightforward, leveraging widely adopted web standards:

  • REST-based Communication: ACP uses simple, clearly defined REST endpoints, aligning closely with standard HTTP patterns. This choice is in contrasts with protocols that rely on more complex communication methods like JSON-RPC (though JSON-RPC over HTTP/WebSockets has been mentioned in some ACP contexts 33), favouring the ubiquity and simplicity of REST for integration into production environments.29, 30
  • No SDK Strictly Required (But Available): Interacting with ACP-compatible agents can be done using standard HTTP tools like curl or Postman.30 However, to further ease development, SDKs for Python and TypeScript are provided, streamlining the creation of robust and interoperable agent-based solutions.30, 33, 34, 35, 36, 37
  • Async-first, Sync Supported: While designed primarily for asynchronous communication that may take considerable time, ACP also fully supports synchronous communication. This caters to simpler use cases, rapid testing, and development convenience.30
  • Offline Discovery: A feature worth noting is manifest-based offline discovery. This allows agents to be discoverable via their metadata even when they are inactive or scaled to zero, enabling dynamic activation as needed.29, 30
  • Observability: ACP implementations, particularly within the BeeAI ecosystem, incorporate OpenTelemetry (OTLP) instrumentation, facilitating monitoring and tracing of agent interactions.33

  • Agent Lifecycle: ACP defines a clear agent lifecycle, with states such as INITIALIZING → ACTIVE → DEGRADED → RETIRING → RETIRED.33

    Want more insights like this? We dive deeper into agent systems, AI-native architecture, and real-world design patterns every week in Waves of Innovation — our newsletter for engineering leaders and system thinkers.

ACP in the Broader Agent Communication Landscape

ACP positions itself as a standard for agent-to-agent communication, complementing other protocols like MCP:

  • Relationship with MCP: While MCP standardises the "model-to-tool" wiring (the "USB-C port" for LLMs to access data and APIs 33, 37, 38, 39), ACP operates a layer above, defining agent-to-agent messaging, task delegation, and lifecycle management.33, 37, 39 ACP originally drew inspiration from MCP for tool and data access but is evolving with its own distinct features for multi-agent orchestration.37 It's possible for ACP to reuse MCP message types or even encapsulate MCP interactions within its payloads if an agent needs to access external data via an MCP server.33, 34
  • Relation to A2A Concepts: ACP falls under the broader umbrella of enabling Agent-to-Agent (A2A) communication.29 An ACP-compliant agent could potentially export a Google Agent Card, allowing it to participate in a wider A2A mesh.33
  • Differentiation from Traditional ACPs (like FIPA/KQML): Compared to earlier, more formal agent communication languages, ACP's reliance on RESTful APIs and standard HTTP which offers a more lightweight and web-native approach. This potentially lowers the barrier to entry and reduces the complexity associated with the intricate message structures and formal ontologies often found in systems like FIPA ACL or KQML.29

Development, Ecosystem, and Practical Application

ACP is an evolving standard, nurtured within a growing open-source ecosystem:

  • Origins and Governance: The initiative is spearheaded by IBM Research and the BeeAI community.37, 39, 40 Significantly, ACP is being developed as a Linux Foundation project, emphasizing a community-driven, open, and collaborative approach, free from vendor lock-in.30, 39, 41, 42
  • BeeAI Platform: ACP is the communication backbone of BeeAI, an open platform designed to help developers discover, run, and compose AI agents from any framework or language.32, 41, 43 BeeAI aims to unify a fragmented agent ecosystem by providing this common protocol.32, 42
  • Current Status: ACP is in its alpha/pre-alpha stages, with active development and calls for community participation to shape its evolution.34, 39, 40 Discussions include topics like handling stateful agents, data encoding choices, and deployment strategies in environments like Kubernetes.39, 44
  • Use Cases: Within the BeeAI environment, ACP enables diverse open-source agents (e.g., Aider for coding, GPT-Researcher for information gathering) to collaborate.40 It allows for the creation of multi-agent workflows, such as a private research group on a developer's machine where crawler, indexer, and authoring agents work in unisome using ACP over localhost.33

The Promise of ACP for Interoperable AI

The Agent Communication Protocol, as championed by the BeeAI community and IBM Research, represents a pragmatic, modern approach to a long-standing challenge in distributed AI: enabling disparate agents to communicate and collaborate effectively. By leveraging familiar web standards and prioritizing simplicity, ACP aims to lower integration barriers and foster a more interoperable "Internet of Agents".31 While still in its formative stages, its open governance and strong community backing position it as a significant contender in the quest for a universal language for AI agent teams.

With agents now able to connect to tools (via MCP) and potentially to each other (via protocols like this ACP), the next step is to consider how these different communication layers can work in concert to enable truly sophisticated, multi-faceted AI systems. The final part of our series will explore this synergy and the future of collaborative AI.

​​​We explore this shift every week in Waves of Innovation — our newsletter on building real, AI-native systems that can scale, adapt, and earn trust.

Don't miss the other parts of this series:

References:

  1. How to Use Model Context Protocol the Right Way - Boomi, https://boomi.com/blog/model-context-protocol-how-to-use/
  2. Build and manage multi-system agents with Vertex AI | Google Cloud Blog, https://cloud.google.com/blog/products/ai-machine-learning/build-and-manage-multi-system-agents-with-vertex-ai
  3. Is Anthropic's Model Context Protocol Right for You? - WillowTree Apps, https://www.willowtreeapps.com/craft/is-anthropic-model-context-protocol-right-for-you
  4. google/A2A: An open protocol enabling communication ... - GitHub, https://github.com/google/A2A
  5. Model Context Protocol (MCP) - PydanticAI, https://ai.pydantic.dev/mcp/
  6. Understanding the Model Context Protocol | Frontegg, https://frontegg.com/blog/model-context-protocol
  7. What is Model Context Protocol (MCP)?, https://norahsakal.com/blog/mcp-vs-api-model-context-protocol-explained/
  8. Model Context Protocol (MCP) Explained - Humanloop, https://humanloop.com/blog/mcp
  9. What Is the Model Context Protocol (MCP) and How It Works - Descope, https://www.descope.com/learn/post/mcp
  10. How the Agent2Agent (A2A) protocol enables seamless AI agent collaboration - Wandb, https://wandb.ai/byyoung3/Generative-AI/reports/How-the-Agent2Agent-A2A-protocol-enables-seamless-AI-agent-collaboration--VmlldzoxMjQwMjkwNg
  11. Model Context Protocol - Cursor, https://docs.cursor.com/context/model-context-protocol
  12. Types of Agent Communication Languages - SmythOS, https://smythos.com/ai-agents/ai-agent-development/types-of-agent-communication-languages/
  13. Comparing Agent Communication Languages and Protocols: Choosing the Right Framework for Multi-Agent Systems - SmythOS, https://smythos.com/ai-agents/ai-agent-development/agent-communication-languages-and-protocols-comparison/
  14. Agent Communications Language - Wikipedia, https://en.wikipedia.org/wiki/AgentCommunicationsLanguage
  15. Standards and Interoperability – IEEE Power & Energy Society, https://site.ieee.org/pes-mas/agent-technology/standards-and-interoperability/
  16. Communication Protocols - Martin Pilát http://ktiml.mff.cuni.cz/~pilat/en/multiagent-systems/communication-protocols/
  17. Agent2Agent (A2A): Definition, Examples, MCP Comparison, https://www.datacamp.com/blog/a2a-agent2agent
  18. What Is Google's Agent2Agent (A2A) Protocol? A Complete Guide to AI Interoperability, https://www.byteplus.com/en/blog/what-is-google-agent-2-agent-protocol
  19. Agent2Agent (A2A): A guide for AI integration | Generative-AI – Weights & Biases - Wandb, https://wandb.ai/byyoung3/Generative-AI/reports/Agent2Agent-A2A-A-guide-for-AI-integration--VmlldzoxMjQwMjkwNg
  20. How Google's Agent2Agent can boost AI productivity through inter-agent communication, https://bdtechtalks.com/2025/04/14/google-agent2agent-a2a/
  21. Community - Agent2Agent Protocol (A2A) - Google, https://google.github.io/A2A/community/
  22. Agent2Agent: A new protocol lets digital assistants to talk to each other - Teiva Systems, https://teivasystems.com/blog/agent2agent-a-new-protocol-lets-digital-assistants-to-talk-to-each-other/
  23. Using Google's Agent Development Kit and Agent2Agent - Wandb, https://wandb.ai/gladiator/Google-Agent2Agent/reports/Tutorial-Using-Google-s-Agent2Agent-A2A-protocol--VmlldzoxMjIyODEwOA
  24. Why Google's Agent2Agent Protocol Needs Apache Kafka - Confluent, https://www.confluent.io/blog/google-agent2agent-protocol-needs-kafka/
  25. Building an Agentic AI System with Agent2Agent (A2A) and MCP Tools on SAP BTP, https://community.sap.com/t5/technology-blogs-by-sap/building-an-agentic-ai-system-with-agent2agent-a2a-and-mcp-tools-on-sap-btp/ba-p/14093412
  26. Why Google's Agent2Agent Needs an Event Mesh | Solace, https://solace.com/blog/why-googles-agent2agent-needs-an-event-mesh/
  27. Four Design Patterns for Event-Driven, Multi-Agent Systems - Confluent, https://www.confluent.io/blog/event-driven-multi-agent-systems/
  28. Multi-Agent Communication Protocols in Generative AI and Agentic AI: MCP and A2A Protocols - Architecture & Governance Magazine, https://www.architectureandgovernance.com/uncategorized/multi-agent-communication-protocols-in-generative-ai-and-agentic-ai-mcp-and-a2a-protocols/
  29. Model Context Protocol (MCP), https://stytch.com/blog/model-context-protocol-introduction/
  30. What you need to know about the Model Context Protocol (MCP) - Merge.dev, https://www.merge.dev/blog/model-context-protocol

Related Posts

Back to all posts