Beyond Context Sharing: A Unified Agent Communication Protocol (ACP) for Secure, Federated, and Autonomous Agent-to-Agent (A2A) Orchestration

📝 Paper Summary

Multi-agent collaboration Agent interoperability standards Decentralized AI

ACP is a layered, federated protocol that enables autonomous agents on different platforms to securely discover, negotiate, and collaborate via decentralized identities and standardized semantic intent.

Core Problem

Autonomous agents currently operate in silos within proprietary frameworks; while MCP handles local context sharing, there is no universal protocol for secure, cross-platform discovery and negotiation between heterogeneous agents.

Why it matters:

The lack of interoperability prevents the realization of a true 'Agentic Web' where agents from different vendors (e.g., Google, OpenAI, private enterprise) can collaborate.
Current A2A proposals rely on centralized registries, creating single points of failure and privacy risks.
Existing methods lack a robust framework for capability verification—how an agent knows what another is truly capable of doing.

Concrete Example: A 'Logistics Agent' on a private enterprise stack needs to coordinate with external 'Carrier Agents' to re-route a shipment. Without ACP, this requires manual human API integration or hours of coordination; with ACP, they autonomously negotiate and re-route in minutes.

Key Novelty

Agent Communication Protocol (ACP): The TCP/IP of the Agentic Web

Introduces 'Agent Cards,' standardized machine-readable metadata (like a business card) that allows agents to perform semantic discovery of peers' capabilities without human intervention.
Implements a federated orchestration model where agents dynamically form and dissolve coalitions (swarms) using a 4-stage negotiation lifecycle, replacing central master agents.
Enforces Zero-Trust security via Decentralized Identifiers (DIDs) and 'Proof-of-Intent,' ensuring agents cannot perform actions outside their negotiated user-authorized scope.

Evaluation Highlights

Reduces inter-agent communication latency by 40% compared to standard baselines (raw JSON-RPC over HTTPS/MCP).
Maintains sub-100 ms latency even as agent swarm size grows to 500+ participants.
Decentralized discovery (DHT) achieves logarithmic search time complexity (O(log N)), preventing bottlenecks in large-scale deployments.

Breakthrough Assessment

9/10

Proposes a foundational standard (TCP/IP analogy) for the Agentic Web. If adopted, it solves the critical fragmentation/silo problem of current multi-agent systems.

⚙️ Technical Details

Problem Definition

Setting: Cross-platform, decentralized Agent-to-Agent (A2A) interaction

Inputs: High-level agent goals and sub-tasks

Outputs: Negotiated collaborative workflows and executed task results

Pipeline Flow

Discovery (Local mDNS or Global DHT)
Transport (gRPC/WebSocket)
Semantic Alignment (JSON-LD)
Negotiation (Agent Cards/SLA)
Governance (DID/Proof-of-Intent)

System Modules

Transport Layer

Handles physical/logical connections, packet delivery, and TLS 1.3 encryption

Model or implementation: Defaults to gRPC; supports WebSockets/HTTPS

Semantic Layer

Translates high-level goals into standardized JSON-LD format; defines ontology of intent

Model or implementation: Universal schema (QUERY, EXECUTE, DELEGATE)

Negotiation Layer

Facilitates exchange of Agent Cards and formation of dynamic Service Level Agreements (SLAs)

Model or implementation: 4-stage lifecycle: Probe, Bid, Commit, Execution

Governance & Security Layer

Enforces Zero-Trust policy using DIDs and Verifiable Credentials

Model or implementation: Challenge-response authentication; Proof-of-Intent signing

Novel Architectural Elements

The Agent Card metadata structure as a mechanism for semantic discovery
Hybrid Discovery Model combining local broadcast (mDNS) and global decentralized lookup (DHT)
The 4-stage A2A Negotiation Lifecycle (Inquiry, Proposal, Agreement, Execution/Settlement)

Modeling

Base Model: Framework-agnostic (ACP-SDK provides wrappers for LangChain, AutoGen, CrewAI)

Comparison to Prior Work

vs. MCP: MCP solves context sharing within a trust boundary; ACP solves discovery and negotiation across trust boundaries.
vs. Google A2A/IBM ACP: ACP uses a federated, decentralized model (DHT/DIDs) rather than centralized registries or rigid APIs.
vs. HTTP/JSON-RPC: ACP provides semantic negotiation and stateful SLAs, not just stateless message transport.

Limitations

Ethical/legal implications of autonomous contractual failures between agents are unresolved
Semantic Layer must evolve to handle highly nuanced or ambiguous human intents
Privacy preservation mechanism (Zero-Knowledge Proofs) is listed as future work

Reproducibility

The paper mentions an 'ACP-SDK' open-source library and provides Python snippets (Listing 1), but does not provide a direct URL in the text. It references 'early adopters' and 'open-source community' in acknowledgements.

📊 Experiments & Results

Evaluation Setup

Multi-agent swarm simulation and supply chain case study

Benchmarks:

High-load swarm simulation (Communication latency and scalability testing) [New]
Supply Chain Pilot (Cross-enterprise logistics re-routing) [New]

Metrics:

Communication Latency
Header Overhead
Success Rate
Discovery Search Time
Statistical methodology: Not explicitly reported in the paper

Key Results

Benchmark	Metric	Baseline	This Paper	Δ
Swarm Simulation	Latency Reduction	Not reported in the paper	Not reported in the paper	Not reported in the paper
Swarm Simulation (500+ agents)	Latency	Not reported in the paper	100 ms	Not reported in the paper
Swarm Simulation	Discovery Search Time Complexity	Not reported in the paper	O(log N)	Not reported in the paper

Main Takeaways

ACP reduces communication latency by 40% compared to traditional JSON-RPC methods, largely due to efficient transport (gRPC) and protocol design.
The decentralized discovery mechanism scales logarithmically (O(log N)), making it suitable for large-scale global deployments where centralized registries would bottleneck.
The protocol enables 'agent swarms' to self-organize and heal; if one agent fails, the protocol renegotiates with alternatives automatically.

📚 Prerequisite Knowledge

Prerequisites

Understanding of Agentic AI architectures (planning, memory, tools)
Familiarity with network protocols (TCP/IP, gRPC, WebSockets)
Knowledge of decentralized identity concepts (DID, Verifiable Credentials)

Key Terms

ACP: Agent Communication Protocol—the proposed standardized framework for secure, federated agent interaction

MCP: Model Context Protocol—an existing standard for synchronizing context/state within a single multi-agent system (ACP builds on top of this)

DID: Decentralized Identifier—a user-controlled identity generated by the agent owner, not a central authority, used for authentication

VC: Verifiable Credential—cryptographic proof of an agent's authority or certification (e.g., authorized to access banking data)

Agent Card: A machine-readable metadata document describing an agent's functional profile, capabilities, and pricing

SLA: Service Level Agreement—a dynamic 'soft contract' negotiated between agents defining scope, cost, and error protocols

DHT: Decentralized Hash Table—a distributed storage system used for global agent discovery without a central registry

JSON-LD: JSON for Linked Data—a format used in the Semantic Layer to map proprietary internal agent representations to a shared global ontology

Proof-of-Intent: A cryptographic signature linking an agent's request to a specific user-authorized intent to prevent unauthorized actions

gRPC: High-performance RPC framework used as the default transport layer in ACP

mDNS: Multicast DNS—a protocol used for local network discovery of agents