The Case for Agentic Interoperability

Currently, the AI agent ecosystem suffers from a fragmentation problem: most agent harnesses use bespoke, proprietary interfaces. This forces developers to build unique clients for every harness, mirroring a hypothetical web where every website required a custom browser.

Alex Hancock argues that while the Model Context Protocol (MCP) successfully standardized how agents reach out to tools and data, there is no equivalent standard for how client software (the "remote control") communicates with the agent harness. Establishing a standard here is critical to creating a healthy ecosystem where clients and agents can be swapped independently.

Introducing the Agent Client Protocol (ACP)

ACP is an open standard designed to allow any client to drive any agent harness. Originating from collaboration between the Zed and JetBrains teams, it is built on JSON-RPC and is designed to be transport-agnostic. Key capabilities include:

  • Session Management: Establishing persistent connections between clients and harnesses.
  • Bidirectional Communication: Handling user messages, tool call notifications, and streaming updates.
  • Permission Requests: Standardizing how agents request user approval for sensitive actions.
  • Extensibility: The protocol uses an underscore-prefixed custom method convention. This allows teams to experiment with new features in the wild; once a pattern proves useful across multiple projects, it can be moved onto the official standards track.

Decoupling the Agentic Stack

By implementing remote transports (HTTP and WebSockets) for ACP, the agentic stack becomes fully modular. Hancock identifies four distinct, movable components:

  1. Client: The UI or headless application driving the agent.
  2. Harness: The engine executing the tool-calling loop.
  3. Tools: The external systems (via MCP).
  4. Model: The LLM provider.

With standardized protocols for both tool calling (MCP) and client control (ACP), these four pieces can reside on different machines, containers, or cloud environments without changing the underlying application logic. This modularity allows developers to build specialized clients—ranging from terminal-based tools to domain-specific IDE plugins—that work seamlessly with any compliant agent harness, ultimately driving competition and higher-quality user experiences.