28+ Agents, One Interface: Understanding the ACP Registry

The AI coding agent market in 2026 is thriving -- and fragmented. Anthropic has Claude Code. Google has Gemini CLI. OpenAI has Codex CLI. Then there is GitHub Copilot, Cursor, Cline, goose from Block, Amp, Auggie CLI from Augment Code, Junie from JetBrains, Kilo, Qwen Code from Alibaba, and more than a dozen others. Each agent has different strengths, different interfaces, and different ecosystems. For developers, this abundance of choice creates a problem: how do you use the best agent for each task without drowning in tool sprawl?

The answer is the Agent Client Protocol (ACP) and its registry. The ACP is an open standard -- think of it as the USB-C of AI coding agents. It defines a universal interface that any agent can implement and any client can connect to. The ACP Registry is the catalog of all agents that support this protocol. And OpenACP is the runtime that brings it all together, letting you switch between 28+ agents through a single interface on Telegram, Discord, or Slack.

In this article, we will take a deep dive into how the ACP protocol works, explore the registry of supported agents, understand the different distribution types, and show you how to make the most of a multi-agent workflow.

What is the Agent Client Protocol?

The Agent Client Protocol (ACP) is an open standard that defines how clients (like OpenACP) communicate with AI coding agents. It specifies the message formats, lifecycle management, permission models, and streaming behavior that both sides of the connection must implement. Any agent that implements ACP can work with any client that speaks ACP, automatically and without custom integration code.

The protocol covers several key areas:

• Session lifecycle -- how sessions are created, maintained, paused, resumed, and terminated. A session represents an ongoing conversation with an agent, including all the context that has been accumulated.
• Message exchange -- how prompts are sent to the agent and how responses are streamed back. ACP uses a streaming protocol that allows responses to appear in real time, character by character.
• Permission model -- how agents request permission to perform actions. The protocol defines a standardized way for agents to describe what they want to do and for clients to approve or deny the request.
• File operations -- how file reads, writes, and modifications are communicated. This includes diff formats for showing changes and tree structures for navigating directories.
• Status reporting -- how agents communicate their current state (idle, thinking, executing, waiting for permission, error).
• Usage metrics -- how agents report token consumption, estimated costs, and other usage data.

The LSP Analogy: Why Protocols Matter

If you are a developer, you are almost certainly familiar with the Language Server Protocol (LSP). Before LSP, every code editor had to build custom integrations for every programming language. VS Code needed its own Go support, its own Python support, its own Rust support, and so on. Sublime Text needed the same. Vim needed the same. Every M editors times N languages combination required custom code. This was unsustainable.

LSP solved this by defining a standard protocol. Now, a Go language server works with any editor that speaks LSP. A Python language server works with any LSP-compatible editor. The problem went from M times N to M plus N. One protocol, universal compatibility.

ACP does the same thing for AI coding agents. Before ACP, connecting Telegram to Claude Code required custom code. Connecting Telegram to Gemini CLI required different custom code. Connecting Discord to Claude Code required yet more custom code. Every M clients times N agents combination was a separate integration effort.

With ACP, the problem becomes M plus N. OpenACP implements ACP on the client side. Each agent implements ACP on the agent side. And they all work together automatically. This is why OpenACP can support 28+ agents without the codebase becoming a tangled mess of custom integrations. The protocol does the heavy lifting.

The impact of this architectural decision cannot be overstated. When a new AI coding agent launches, it does not require any changes to OpenACP to be supported. As long as the new agent implements ACP, it works out of the box. This future-proofs OpenACP against the rapidly evolving AI agent landscape.

The ACP Registry: A Catalog of Agents

The ACP Registry is the central catalog of all agents that are compatible with the Agent Client Protocol. Think of it as npm for AI agents -- a searchable directory where you can discover agents, read about their capabilities, and find installation instructions. The registry is maintained as part of the OpenACP project and is updated regularly as new agents are added or existing agents are updated.

As of March 2026, the registry contains 28+ agents. Each entry in the registry includes:

• Agent name and vendor -- who makes the agent and what it is called.
• Distribution type -- how the agent is installed and run (npx, binary, or uvx).
• Installation command -- the exact command to install the agent.
• Configuration requirements -- what API keys or environment variables the agent needs.
• Capabilities -- what the agent can do (code generation, debugging, refactoring, testing, etc.).
• Version information -- the latest version and compatibility notes.

Agent Distribution Types

Agents in the ACP Registry are distributed in three ways. Understanding these distribution types helps you install and manage agents correctly.

npx (Node Package Manager)

Agents distributed via npx are Node.js packages that can be installed globally with npm or run directly with npx. This is the most common distribution type and the easiest to work with. Examples include Claude Code (@anthropic-ai/claude-code), Gemini CLI, and many others.

# Install globally
npm install -g @anthropic-ai/claude-code

# Or run directly with npx (no install needed)
npx @anthropic-ai/claude-code

npx-distributed agents are easy to update (npm update -g package-name), work cross-platform, and integrate smoothly with OpenACP's Node.js runtime.

Binary

Some agents are distributed as standalone binary executables. These are compiled programs that you download and place in your PATH. Binary distribution is common for agents written in Go, Rust, or C++. The advantage is that they have no runtime dependencies -- no Node.js, no Python, just a single executable file.

# Example: download a binary agent
curl -fsSL https://example.com/agent/install.sh | sh

# Or download directly
wget https://example.com/agent/v1.0.0/agent-linux-amd64
chmod +x agent-linux-amd64
mv agent-linux-amd64 /usr/local/bin/agent

Binary agents typically start faster and use less memory than interpreted agents, but they need to be downloaded separately for each operating system and architecture.

uvx (Python/UV)

Agents distributed via uvx are Python packages that use the UV package manager. UV is a modern Python package manager that is significantly faster than pip. Some AI coding agents, particularly those built on Python-based AI frameworks, use this distribution method.

# Install with UV
uvx install agent-name

# Or run directly
uvx agent-name

uvx-distributed agents require Python and UV to be installed on your system. They are common in the machine learning and AI research community, where Python is the dominant language.

Major Agents in the Registry

Let us take a closer look at the major agents available in the ACP Registry. Each agent has different strengths, and understanding these differences helps you choose the right agent for each task.

Claude Code (Anthropic)

Claude Code is Anthropic's AI coding agent, powered by the Claude model family. It excels at understanding complex codebases, reasoning about architecture, and generating well-structured code. Claude Code is particularly strong at tasks that require understanding the big picture -- refactoring large modules, designing new systems, and explaining complex code. Its large context window means it can digest entire files or even multiple files at once, maintaining coherent understanding across a project.

Installation: npm install -g @anthropic-ai/claude-code

Requires: Anthropic API key

Gemini CLI (Google)

Gemini CLI is Google's AI coding agent, powered by the Gemini model family. It is known for its enormous context window and strong multi-modal capabilities. Gemini CLI shines when dealing with very large codebases where you need the agent to understand many files simultaneously. It is also strong at tasks that involve diagrams, screenshots, or other visual elements alongside code.

Installation: npm install -g @google/gemini-cli

Requires: Google AI API key

Codex CLI (OpenAI)

Codex CLI is OpenAI's AI coding agent. It is fast, efficient, and excels at quick code generation tasks. If you need a function written, a script created, or a bug fixed quickly, Codex CLI is often the fastest option. It is particularly strong with Python, JavaScript, and TypeScript, and its quick response times make it ideal for interactive, rapid-fire coding sessions.

Installation: npm install -g @openai/codex

Requires: OpenAI API key

GitHub Copilot

GitHub Copilot is one of the most widely used AI coding tools in the world, and through the ACP Registry it can be used with OpenACP as a standalone agent. Copilot's integration with the GitHub ecosystem is unmatched -- it understands pull requests, issues, and repository context natively. If your workflow is centered around GitHub, Copilot as an ACP agent brings that context into your messaging platform.

Cursor

Cursor is an AI-powered code editor that has its own agent mode. Through ACP, Cursor's agent capabilities can be accessed remotely via OpenACP. Cursor excels at editor-level tasks like intelligent code completion, symbol renaming across files, and context-aware search. Using it through OpenACP lets you leverage these capabilities without having the Cursor editor open.

Cline

Cline is an open-source AI coding agent that runs in VS Code. It is known for its careful, safety-first approach -- it asks for permission before every action and provides detailed explanations of what it is doing and why. Through ACP, Cline's cautious approach translates well to remote use, where you want to be extra sure about what the agent is doing to your code.

goose (Block)

goose is Block's (formerly Square) AI coding agent. It is designed for enterprise development workflows and has strong support for Java, Kotlin, and other JVM languages that are common in enterprise environments. goose's enterprise focus means it handles large, complex codebases well and understands patterns like dependency injection, ORM frameworks, and microservice architectures.

Amp

Amp is a newer entrant to the AI coding agent space that focuses on speed and efficiency. It is designed to give quick, focused responses rather than lengthy explanations. This makes it ideal for experienced developers who know what they want and just need the agent to execute quickly. Through OpenACP, Amp's fast response times are especially appreciated on mobile, where you do not want to wait for long responses to stream in.

Auggie CLI (Augment Code)

Auggie CLI is Augment Code's AI coding agent. It specializes in understanding large codebases by building and maintaining a persistent knowledge graph of your project's architecture, dependencies, and patterns. This means it gets better over time as it learns your codebase. Through ACP, this deep understanding is available remotely via OpenACP.

Junie (JetBrains)

Junie is JetBrains' AI coding agent, designed to work seamlessly with JetBrains IDEs (IntelliJ, WebStorm, PyCharm, etc.). Through ACP and OpenACP, you can leverage Junie's IDE-grade code intelligence from your messaging app. Junie is particularly strong at refactoring, which is one of JetBrains' core strengths.

Kilo

Kilo is a lightweight, fast AI coding agent optimized for small to medium tasks. It starts up quickly, responds fast, and uses minimal resources. It is the agent you reach for when you need a quick fix, a simple utility function, or a fast code review. Through OpenACP, Kilo's lightweight nature means sessions start almost instantly.

Qwen Code (Alibaba)

Qwen Code is Alibaba's AI coding agent, powered by the Qwen model family. It has strong support for Chinese language interactions and excels at web development, particularly with frameworks popular in the Chinese tech ecosystem like Vue.js, WeChat Mini Programs, and Ant Design. For developers working in or with Chinese tech companies, Qwen Code through OpenACP bridges the language and ecosystem gap.

Switching Agents Per Session

One of the most powerful aspects of using OpenACP with the ACP Registry is the ability to use different agents for different sessions. You are not locked into one agent -- you can choose the best tool for each job.

Here is a practical example of a multi-agent workflow:

1. Morning: Architecture review with Claude Code -- you start a session using Claude Code to review a major architectural change. Claude Code's strong reasoning abilities help you think through the implications of the change and identify potential issues.
2. Midday: Quick bug fixes with Codex CLI -- a few bug reports come in. You switch to Codex CLI for fast, focused fixes. Codex CLI's quick response time is perfect for small, well-defined tasks.
3. Afternoon: Large codebase analysis with Gemini CLI -- you need to understand a complex legacy module. You start a session with Gemini CLI, whose enormous context window can digest the entire module and its dependencies at once.
4. Evening: Quick mobile checks with Kilo -- from your phone on the way home, you use Kilo for quick checks and minor fixes. Kilo's lightweight nature means sessions start fast even over a mobile connection.

Each of these sessions runs independently. Each has its own forum topic in Telegram (or thread in Discord/Slack). Each maintains its own context. And each uses the agent best suited to the task at hand. This is the power of an open, multi-agent architecture.

To switch agents, you can either start a new session with a different agent selected (OpenACP uses the agent configured in your config by default, but you can override it per session), or you can update your default agent in the configuration and start a new session.

Agent Setup Requirements

Each agent has its own setup requirements beyond just installing it. Here is a summary of what the most popular agents need:

Agent	Distribution	API Key	Additional Requirements
Claude Code	npx	Anthropic API key	None
Gemini CLI	npx	Google AI API key	None
Codex CLI	npx	OpenAI API key	None
GitHub Copilot	npx	GitHub token	Copilot subscription
goose	binary	Varies	JVM for Java tasks
Cline	npx	Varies	None
Junie	binary	JetBrains key	JetBrains license
Qwen Code	npx	Alibaba Cloud key	None

API keys are stored as environment variables on your system. OpenACP does not manage API keys directly -- it defers to each agent's own configuration system. This means if you have already configured an agent to work in your terminal, it will work with OpenACP without any additional key setup.

Building Your Own ACP-Compatible Agent

One of the most exciting aspects of the ACP protocol being open is that anyone can build an agent that works with it. If you have a custom AI model, a specialized coding tool, or an internal development platform, you can make it ACP-compatible and immediately use it with OpenACP.

Building an ACP-compatible agent involves implementing the protocol's message formats and lifecycle events. At a minimum, your agent needs to:

1. Accept session creation requests -- handle the initial handshake when OpenACP starts a new session.
2. Accept text prompts -- receive user messages and process them.
3. Stream responses -- send responses back as a stream of text chunks, not a single block.
4. Request permissions -- when performing actions that require user approval, send properly formatted permission requests.
5. Report status -- communicate your agent's current state (thinking, executing, idle).

The ACP specification is available in the OpenACP GitHub repository, along with example implementations and test suites. Several community members have built ACP-compatible wrappers around existing tools -- for example, wrapping a custom script runner in ACP to make it controllable via Telegram. The possibilities are endless, and the open nature of the protocol encourages experimentation and innovation.

If you are interested in building a custom agent, start with the ACP specification document in the GitHub repository. There are also reference implementations in TypeScript and Python that you can use as starting points. The community is active in GitHub Discussions and happy to help new agent developers get started.

The Future of Multi-Agent Development

We are still in the early days of multi-agent development workflows. Today, most developers use one primary AI coding agent and occasionally switch to another. But the trend is clear: as agents become more specialized and the ACP ecosystem matures, developers will routinely use multiple agents in the same day, even on the same project.

Imagine a future where your OpenACP setup automatically selects the best agent for each task based on the type of work you are asking for. "Write me a new React component" gets routed to an agent that excels at frontend development. "Optimize this SQL query" gets routed to a database-specialized agent. "Review this code for security vulnerabilities" gets routed to a security-focused agent. The ACP protocol makes this kind of intelligent routing possible, and OpenACP is the platform where it will happen.

The ACP Registry will continue to grow as new agents are developed. If you are building an AI coding tool, consider implementing ACP. If you are a developer choosing tools, consider OpenACP as your agent management layer. And if you are just curious about the future of AI-assisted development, watch this space -- it is where the action is.

npm install -g @openacp/cli && openacp