# ACP vs ACP: Agent Client Protocol or Agentic Control Plane?

Two unrelated projects share the acronym ACP, and DeepSeek Harness ships both. Agent Client Protocol connects editors to agents; the Agentic Control Plane decides whether each tool call runs. Here's which one you're looking for — with links either way.

# ACP vs ACP

Two unrelated projects share this acronym, both are involved with [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness), and search results mix them freely. This page routes you to the right one — no scrolling required.

| You're trying to… | You want | Go to |
|---|---|---|
| Use dsh from **Zed** or another editor | **Agent Client Protocol** | [`@deepseek-ai/dsh-acp`](https://www.npmjs.com/package/@deepseek-ai/dsh-acp) (official) or [`deepseek-harness-acp`](https://github.com/openma-ai/deepseek-harness-acp) (community, full ACP vocabulary) |
| Drive dsh **programmatically** from your app | **Agent Client Protocol** | [`@ai-sdk/harness-acp`](https://ai-sdk.dev/providers/community-providers/acp) (Vercel AI SDK harness layer) |
| Read the protocol spec | **Agent Client Protocol** | [agentclientprotocol.com](https://agentclientprotocol.com) |
| Run Vercel's **fx** under an editor or client | **Agent Client Protocol** | `fx acp` — fx's built-in protocol server ([fx control model](/controls/fx)) |
| **See and control what dsh does** — allow / ask / deny each tool call, with an audit log | **Agentic Control Plane** | [`@agenticcontrolplane/dsh`](https://github.com/agentic-control-plane/dsh-acp-plugin) — [launch post](/blog/deepseek-harness-acp-integration), [dsh control model](/controls/dsh) |
| Agent-to-agent messaging between frameworks | Neither — see [the third ACP](#the-third-acp) below | [A2A](https://a2a-protocol.org) is where that layer settled |

## The Agent Client Protocol (the one in dsh core)

[Agent Client Protocol](https://agentclientprotocol.com) is a JSON-RPC standard for connecting code editors and automation clients to coding agents — the LSP move, applied to agents. Zed introduced it in 2025, JetBrains followed, and a registry now lists compatible agents. One protocol instead of a bespoke integration per editor-agent pair.

dsh supports it in core: the `packages/acp` directory in the dsh repo is this protocol, and [`@deepseek-ai/dsh-acp`](https://www.npmjs.com/package/@deepseek-ai/dsh-acp) is the official ACP server for driving harness agents over stdio. The community [`deepseek-harness-acp`](https://github.com/openma-ai/deepseek-harness-acp) goes further for editor use, mapping dsh's session-event log onto the full protocol vocabulary — streamed text and reasoning, tool calls with diffs, plans, permission requests. If that's what you came for, those links are your answer.

## The Agentic Control Plane (this site)

The [Agentic Control Plane](/what-is-an-agentic-control-plane) doesn't connect anything to anything. It sits on dsh's `tools/pre-execute` pipeline and decides, before each tool call runs, whether it should: allow, ask a human, or deny — against policies you set, with every decision logged with its reason. [`@agenticcontrolplane/dsh`](https://github.com/agentic-control-plane/dsh-acp-plugin) is a ~190-line native plugin on dsh's typed interception points; the [launch post](/blog/deepseek-harness-acp-integration) covers what it intercepts and what it caught on day one.

## Different layers — they compose

The clean way to hold the two apart: the protocol is **transport**, the control plane is **judgment**. A single dsh session can use both at once — the editor talks to the agent over the Agent Client Protocol; every tool call the agent then makes passes through the control plane before it executes.

They even meet at one specific point. The protocol defines [`session/request_permission`](https://agentclientprotocol.com/protocol/tool-calls) — the agent asks the client to approve a tool call, with options like `allow_once`, `allow_always`, `reject_once`, `reject_always` — and the spec notes clients may auto-answer "based on user settings." Settings that answer permission questions, consistently, with an audit trail, is precisely what a control plane is. The protocol carries the question; the control plane is a principled way to answer it.

## The third ACP

There's also an **Agent Communication Protocol** (IBM Research / BeeAI, 2025) for agent-to-agent messaging. In that layer, [A2A](https://a2a-protocol.org) — donated by Google to the Linux Foundation, with broad platform support — is where the ecosystem consolidated. If you searched "ACP" meaning agent-to-agent interop, A2A is likely the current answer to your actual question.

## Name-to-package map

| Name | Which ACP | What it is |
|---|---|---|
| `packages/acp` (dsh repo) | Agent Client Protocol | Protocol implementation in dsh core |
| `@deepseek-ai/dsh-acp` | Agent Client Protocol | Official ACP server for dsh, JSON-RPC over stdio |
| `deepseek-harness-acp` (openma-ai) | Agent Client Protocol | Community ACP server with the full editor vocabulary |
| `@ai-sdk/harness-acp` | Agent Client Protocol | Vercel AI SDK adapter for any ACP-compatible harness |
| `fx acp` (Vercel Labs fx) | Agent Client Protocol | fx's built-in protocol server; routes each approval-gated call to the client as `session/request_permission`, fail-closed ([details](/controls/fx)) |
| `@agenticcontrolplane/dsh` (launch name `dsh-plugin-acp`) | Agentic Control Plane | Policy check on every dsh tool call, decisions logged |

## Common questions



---

*Running dsh and want the control side? One command: `curl -sf https://agenticcontrolplane.com/install.sh | bash` — free up to 5 agents. The living reference for what can be seen and controlled in dsh is at [/controls/dsh](/controls/dsh).*