Source-linked AI summary
A survey of agent interoperability protocols: Model Context Protocol (MCP), Agent Communication Protocol (ACP), Agent-to-Agent Protocol (A2A), and Agent Network Protocol (ANP)
Abul Ehtesham, Aditi Singh, Gaurav Kumar Gupta, Saket Kumar
TL;DR
LLM agents need standardized protocols because ad-hoc integrations hinder interoperability, security, and scalability across heterogeneous systems. This survey analyzes MCP, ACP, A2A, and ANP across architectural and security dimensions, finding that no single protocol fits every context and proposing phased complementary adoption from MCP through ANP.
Problem
Ad-hoc integrations make it difficult to integrate, secure, and scale communication among LLM-driven agents.
Method
The survey reviews four protocols, their architectures and integration approaches, and compares their interaction modes, discovery mechanisms, communication models, and security frameworks.
Results
The comparative evaluation finds that no single protocol suffices across all contexts.
Takeaways & Limitations
A phased, complementary adoption strategy beginning with MCP and progressing through ACP and A2A to ANP offers a practical pathway for deploying agent ecosystems.
Abstract
from arXiv · showhide
Large language model powered autonomous agents demand robust, standardized protocols to integrate tools, share contextual data, and coordinate tasks across heterogeneous systems. Ad-hoc integrations are difficult to scale, secure, and generalize across domains. This survey examines four emerging agent communication protocols: Model Context Protocol (MCP), Agent Communication Protocol (ACP), Agent-to-Agent Protocol (A2A), and Agent Network Protocol (ANP), each addressing interoperability in deployment contexts. MCP provides a JSON-RPC client-server interface for secure tool invocation and typed data exchange. ACP defines a general-purpose communication protocol over RESTful HTTP, supporting MIME-typed multipart messages and synchronous and asynchronous interactions. Its lightweight and runtime-independent design enables scalable agent invocation, while features like session management, message routing, and integration with role-based and decentralized identifiers (DIDs). A2A enables peer-to-peer task delegation using capability-based Agent Cards, supporting secure and scalable collaboration across enterprise agent workflows. ANP supports open network agent discovery and secure collaboration using W3C decentralized identifiers DIDs and JSON-LD graphs. The protocols are compared across multiple dimensions, including interaction modes, discovery mechanisms, communication patterns, and security models. Based on the comparative analysis, a phased adoption roadmap is proposed: beginning with MCP for tool access, followed by ACP for structured, multimodal messaging session-aware interaction and both online and offline agent discovery across scalable, HTTP-based deployments A2A for collaborative task execution, and extending to ANP for decentralized agent marketplaces. This work provides a comprehensive foundation for designing secure, interoperable, and scalable ecosystems of LLM-powered agents.
1 Introduction
LLM-powered autonomous agents operate across varied environments, but fragmented interoperability practices hinder secure, scalable integration and collaboration. The survey examines MCP, ACP, A2A, and ANP and compares their architectures, communication patterns, discovery mechanisms, and security considerations.
- LLM-powered autonomous agents ingest context, execute tasks, and interact with external services across cloud, edge, and desktop environments.
- Fragmented interoperability practices make communication among LLM-driven agents difficult to integrate, secure, and scale.
- Interoperability enables agents and systems to discover capabilities, exchange context, and coordinate actions in modular, reusable, and resilient workflows.The passage also states that standardized protocols reduce development overhead, improve security, and enable cross-platform collaboration.
- The survey examines four emerging protocols, each targeting a different interoperability tier: MCP, ACP, A2A, and ANP.
- The comparison covers interaction modes, discovery mechanisms, communication models, and security frameworks, followed by a phased adoption roadmap.
- The paper is organized around interoperability challenges, protocol architectures, comparative evaluation, adoption sequencing, and future research directions.
2 Challenges and Solutions in Agent Protocol Interoperability
The survey frames agent interoperability as a set of distinct challenges involving context standardization, heterogeneous-agent communication, collaboration, and open-internet connectivity. MCP, ACP, A2A, and ANP provide purpose-built solutions spanning tool access, messaging, coordination, and decentralized discovery.
- Real-world agent interoperability remains non-trivial despite open protocols such as MCP, ACP, A2A, and ANP.
- Context standardization: MCP standardizes delivery of tools, datasets, and sampling instructions to LLMs, supporting plug-and-play tools and compatibility across vendors.
- Heterogeneous-agent communication: ACP uses a RESTful, SDK-optional interface with open governance to address communication barriers among agents built with different stacks and frameworks.
- Heterogeneous-agent communication: ACP enables asynchronous-first interactions, offline discovery, and vendor-neutral execution for interoperability at scale.
- Agent collaboration: A2A introduces multimodal communication for dynamic interaction among opaque autonomous agents and supports shared task management and user-experience negotiation.
- Open-internet communication: ANP combines W3C decentralized identity, semantic-web principles, and encrypted communication for cross-platform collaboration over the open internet.
- Overall solution: Together, the protocols aim to form secure, interoperable agent networks that scale across organizational and vendor boundaries.
3 Background and Related Work
Prior agent systems and frameworks advanced messaging, service integration, retrieval, and tool use, but often retained static registries and bespoke communication layers. The survey situates MCP, ACP, A2A, and ANP as protocol-oriented responses enabling dynamic discovery, secure communication, and decentralized collaboration.
- Research gap: Earlier surveys of LLM-based multi-agent systems emphasize workflows, memory, and orchestration while largely neglecting protocols for discovery, capability negotiation, and security.
- Research gap: Interoperability requires agents to discover capabilities, share context, and coordinate actions, while evolving APIs make compatibility difficult to maintain.
- Protocol-oriented responses: MCP, ACP, A2A, and ANP propose lightweight formal interfaces for context ingestion, performative messaging, and peer discovery.
- AI-agent foundations: An AI agent is an autonomous software entity that perceives its environment through inputs and acts through outputs to achieve designated goals.
- AI-agent foundations: Agent architectures range from rule-based reactive models to deliberative BDI systems, with multi-agent coordination relying on communication, negotiation, and organizational structures.
- Communication-protocol history: KQML introduced speech-act performatives and a flexible message envelope for machine-interpretable propositions in early agent communication.
- Communication-protocol history: FIPA-ACL refined communicative acts with precondition and postcondition semantics, richer performatives, standardized content languages, and interaction protocols.
- Service integration: SOA exposed enterprise functionality through web services and used middleware for protocol bridging, routing, and payload transformation.
4 MCP
MCP structures LLM interactions with external resources through a client–server protocol organized around typed capabilities, negotiated sessions, and lifecycle controls. Its design supports tool use and context exchange while introducing security concerns across deployment phases.
- Architecture: MCP uses a JSON-RPC 2.0 client–server architecture for structured communication between applications and servers.The protocol layer links requests to corresponding responses, while the client initiates and orchestrates interactions.
- Core capabilities: MCP servers expose four core capabilities: Tools, Resources, Prompts, and Sampling, each governed by a distinct control model.Tools invoke external services, Resources provide application-selected context, Prompts supply reusable user-selected templates, and Sampling delegates completion generation to the client.
- Lifecycle: MCP interactions follow Initialization, Operation, and Shutdown phases for compatibility negotiation, capability use, and clean termination.Initialization exchanges protocol versions and optional features; Operation carries calls and notifications; Shutdown closes transport and releases resources.
- Security: MCP deployments face lifecycle-spanning risks including tool poisoning, privilege persistence, and command injection.The survey summarizes corresponding mitigations using current attack disclosures, audits, and protocol reviews.
5 A2A Architecture
A2A enables a User, Client Agent, and Remote Agent to coordinate delegated tasks through capability discovery, structured execution, and result delivery. The Client Agent mediates the workflow while the Remote Agent provides authenticated, schema-defined skills.
- Actors: A2A organizes interactions among a User, Client Agent, and Remote Agent to support secure, interoperable task execution.The User supplies intent, the Client Agent coordinates the workflow, and the Remote Agent executes delegated work.
- Client Agent: The Client Agent discovers suitable Remote Agents by evaluating Agent Cards that specify skills, interfaces, and authentication requirements.It then constructs structured Tasks, manages bidirectional Messages and Artifacts, and preserves session context for long-running workflows.
- Execution management: The Client Agent handles failures through retries, fallback agent selection, or User notifications before presenting Artifacts in a user-consumable format.It may also receive asynchronous updates through Server-Sent Events or push notifications.
- Remote Agent: Remote Agents expose schema-defined Skills, execute delegated operations, and enforce authentication, message-integrity, and authorization controls.Their capabilities are published through Agent Cards that function as advertisements and interface contracts.
5.2 A2A Main Components
A2A represents agent collaboration through discoverable capabilities, standardized task delegation, typed messaging, and returned Artifacts. Its transport options support both synchronous and asynchronous workflows.
- Agent discovery: An Agent Card is a JSON self-description that advertises an agent’s metadata, skills, and authentication requirements for discovery.Client Agents use it to evaluate whether a Remote Agent can satisfy task criteria.
- Capabilities: Skills define the operations an agent offers, including their purposes, expected inputs, and output formats.They are invoked through standardized Tasks, linking published capabilities to executable work.
- Task delegation: Tasks are A2A’s atomic work-delegation units, specifying the skill, input parameters, and contextual metadata.They support synchronous or asynchronous collaboration across diverse systems.
- Communication: Messages carry task submissions, status updates, and artifact delivery through typed parts such as text, structured data, or file references.Artifacts are the materialized outputs returned by completed tasks for rendering or downstream processing.
- Transport: A2A combines JSON-RPC 2.0 task communication with HTTP Agent Card retrieval and supports SSE or push notifications for asynchronous workflows.SSE streams live updates over persistent connections, while push notifications deliver progress or completion out of band.
5.4 A2A Remote Agent (Server) Lifecycle
The A2A Remote Agent lifecycle moves through Creation, Operation, Update, and Termination. These phases establish discoverability and authentication, execute and update services, and end with orderly cleanup, while each phase carries security concerns.
- Lifecycle phases: The Remote Agent lifecycle comprises Creation, Operation, Update, and Termination, each with distinct reliability and security responsibilities.The progression governs deployment, task handling, capability changes, and shutdown.
- Creation: Creation publishes an Agent Card at /.well-known/agent.json, deploys the service endpoint, and configures JSON-RPC 2.0 authentication.The card declares metadata, skills, and authentication schemes for prospective clients.
- Operation: During Operation, the Remote Agent processes structured Tasks, executes associated skills, and delivers status messages and Artifacts.Supported deployments may stream updates through SSE or deliver them via PushNotificationService.
- Update: Update refreshes the Agent Card and configuration by adding, deprecating, or patching capabilities while incrementing the version field.Documentation or lifecycle status fields can signal changes to clients.
- Termination: Termination completes or finalizes in-flight Tasks, closes SSE streams, deregisters the Agent Card, and releases system resources.This removes stale endpoints and residual exposure during shutdown.
- Security: Secure A2A deployment requires threats and mitigations to be addressed across creation, operation, update, and termination.The survey consolidates these challenges from official protocol references and recent security analyses.
6 ACP Architecture
ACP is a modular, HTTP-based framework in which clients, servers, and agents exchange structured messages for synchronous, streaming, and session-aware task execution. Agent Details and discovery mechanisms support capability-based selection, while lifecycle phases govern deployment, updates, and shutdown.
- Architecture: ACP comprises a client, server, and one or more agents that communicate through standardized REST APIs and structured multimodal messages.The server translates external HTTP requests into agent executions, while agents process ACP-formatted requests and responses.
- Communication: Clients can compose ordered message parts and use session-based, synchronous, or streaming interactions with unified errors and standard HTTP authentication.Supported authentication methods include Bearer tokens, Basic Auth, and JWTs.
- Discovery: Agent Details provide self-descriptive identity and capability metadata, including operations, content types, authentication schemes, and runtime diagnostics required for invocation.Clients use Agent Detail as a precondition for trust and agent selection without bespoke integration.
- Discovery: ACP discovery can use registries, well-known manifest URLs, or deployment metadata, decoupling client logic from fixed configurations and supporting scalable networks.Task Requests carry ordered textual, binary, or externally hosted inputs and support synchronous or long-running asynchronous work.
- Message model: ACP Message Structures annotate ordered parts with MIME types and embedded or dereferenceable content, while Artifacts package outputs for rendering, storage, or workflow chaining.Artifacts may contain JSON, text, binary files, or nested message references.
- Lifecycle: ACP agents progress through Creation, Operation, Update, and Termination, with lifecycle management covering deployment, execution, manifest refresh, task completion, and decommissioning.ACP security challenges span the lifecycle from registration to shutdown and are summarized with mitigation strategies in Table 5.
7 ANP Architecture
ANP is a decentralized, peer-to-peer protocol for cross-platform interoperability on the open internet. It combines DID-based identity, JSON-LD agent descriptions, directory discovery, flexible interfaces, and runtime protocol negotiation across the agent lifecycle.
- Architecture: ANP supports decentralized peer-to-peer interoperability on the open internet, enabling agents to discover, authenticate, and interact through structured metadata and AI-native data exchange.Its architecture is organized around a standardized lifecycle and modular framework.
- Core components: ANP identifies agents with did:wba decentralized identifiers linked to HTTPS-hosted DID documents, using existing Web infrastructure for identity resolution.This identity layer supports cross-platform identification of agents.
- Core components: JSON-LD Agent Description documents specify agent names, capabilities, protocols, authentication schemes, and endpoints for public semantic self-description.The documents facilitate interoperability and semantic understanding.
- Discovery and interfaces: The .well-known/agent-descriptions directory exposes available agents under a domain for human and automated retrieval, supporting scalable indexing and search.ANP also supports structured interfaces such as JSON-RPC and OpenAPI alongside YAML-based natural-language interfaces.
- Discovery and interfaces: The Meta-Protocol Negotiator lets heterogeneous agents exchange communication requirements and capabilities, then negotiate compatible interaction protocols at runtime.This provides adaptive interaction across differing agent ecosystems.
- Lifecycle: ANP follows Creation, Operation, Update, and Termination phases that maintain agent discoverability, verifiability, and interoperability in a distributed ecosystem.Lifecycle operations include publishing and revising DID and ADP metadata, secure interaction, and revoking credentials during shutdown.
8 Comparison of Agent Protocols
The survey compares MCP, ACP, A2A, and ANP side by side to clarify how their architectural and interoperability choices differ. The comparison covers messaging, discovery, sessions, and intended use cases.
- Comparison dimensions: Table 7 compares MCP, ACP, A2A, and ANP across architectural choices, messaging formats, discovery methods, session models, and intended use cases.The structured comparison is intended to clarify protocol suitability across diverse deployment contexts.
- Comparison dimensions: The comparison provides a basis for assessing trade-offs among the four frameworks across their interoperability designs.The passage frames the table as a side-by-side analysis rather than reporting a single performance outcome.
- Use-case alignment: Protocol suitability is evaluated in relation to differing deployment contexts and use-case requirements.The comparison emphasizes architectural and operational dimensions rather than a universal ranking.
9 Phased Adoption Roadmap for Agent Interoperability
The roadmap proposes progressive adoption of interoperability protocols according to maturity, integration complexity, and use-case alignment. It starts with MCP for tool access, adds ACP for agent messaging, uses A2A for enterprise workflows, and extends to ANP for open-internet collaboration.
- Roadmap rationale: The roadmap is a multi-stage deployment strategy designed to support scalability, composability, and security while aligning protocols with organizational use cases.Its sequencing is based on protocol maturity, integration complexity, and use-case alignment.
- Stage 1 — MCP: MCP is the initial stage for structured, secure LLM interaction with external tools or resources through JSON-RPC client-server exchanges.It suits tool invocation, deterministic execution, and typed input/output in single-model systems.
- Stage 2 — ACP: ACP is introduced next for synchronous and asynchronous communication among independent agents using MIME-typed multipart messages, ordered parts, and streaming.This supports standardized messaging across agents built with different frameworks.
- Stage 3 — A2A: A2A targets enterprise multi-agent workflows through Agent Cards, artifact exchanges, dynamic discovery, and structured messaging among stateless or stateful agents.The passage positions A2A within trusted organizational contexts.
- Stage 4 — ANP: ANP is the final stage for open-internet interoperability, combining decentralized discovery, DID-based identity verification, peer-to-peer communication, and JSON-LD graphs.The roadmap associates this stage with scalable, cross-platform agent marketplaces and progressive adoption that limits integration complexity.
10 Conclusion
The survey concludes that MCP, ACP, A2A, and ANP address complementary layers of agent interoperability, so no single protocol fits every context. It recommends phased adoption from MCP through ACP and A2A to ANP, alongside research on interoperability bridges, trust, and evaluation.
- The four protocols collectively unify tool invocation, multimodal messaging, task coordination, and decentralized discovery for scalable multi-agent systems.
- No single protocol suffices across all deployment contexts, motivating a complementary rather than one-size-fits-all strategy.
- The proposed adoption roadmap begins with MCP, progresses through ACP and A2A, and extends to ANP for agent ecosystems.
- Future work should develop interoperability bridges, trust frameworks, and standardized evaluation benchmarks for resilient real-world deployments.