Connect DeepSeek Harness to Zed with ACP
The Agent Client Protocol in three steps: pick your route, wire the server, and start a thread from Zed's agent panel.
Last updated: 2026-09-29
ACP — the Agent Client Protocol — is how editors talk to coding agents: one side spawns the agent process and sends prompts, the other streams messages, thoughts, tool cards and permission requests back over JSON-RPC. Zed's agent panel speaks it natively, and because the protocol is open, a dsh agent can sit on the other side of that panel.
There are two honest routes. The official `@deepseek-ai/dsh-acp` package is deliberately automation-only — built for scripts, test runners and out-of-process subagents — while the full interactive experience in an editor comes from community servers that project it into Zed. This guide walks both, then wires the interactive route into Zed for real.
TL;DR
- ▸ACP connects an editor to your agent; MCP connects your agent to tools. You will likely want both — see the ACP vs MCP section below.
- ▸The official dsh ACP server (`dsh --profile acp`) targets automation: no plans, no session titles, no terminal views — by design.
- ▸For Zed, install the community `deepseekharness-acp-interactive` npm package — the server this guide wires in.
- ▸Three steps: install globally, run `dsh-acp-interactive --setup` once, register it under `agent_servers` in Zed's settings.json.
Two routes, three steps each
Part 1 — pick a route
- 1
Decide what you want ACP for
If a program — a CI job, a test runner, another harness — should drive dsh end to end, the official server is the right tool: standard ACP v1, sessions that persist across restarts, several sessions per connection, and no authentication step. If a human wants to work with dsh from Zed's agent panel, you want the community's interactive servers instead — the official one intentionally leaves out plans, titles, todos and terminal views.
- 2
Route A: the official automation-only server
In a repository checkout, the ACP server lives in `packages/acp` as the `@deepseek-ai/dsh-acp` plugin. Give every session its provider and model through the composition, then start it with the acp profile — stdout carries JSON-RPC frames only. Clients create, list, resume and close sessions, attach stdio or HTTP MCP servers, select model and reasoning effort, and answer permission prompts. To spawn the same server from another harness as an out-of-process subagent, the official client is `@deepseek-ai/dsh-subagent-acp`.
$pnpm dsh --profile acp- name: '@deepseek-ai/dsh-acp' config: provider: deepseek-official model: deepseek-v4-pro - 3
Route B: install the interactive server
dsh-acp-interactive (community, MIT-licensed, not affiliated with DeepSeek or Zed) composes the published `@deepseek-ai/dsh-*` packages behind an editor-facing profile, so Zed gets messages, thoughts, tool cards, permission prompts, plans, session titles and usage. Install it globally, then run `--setup` once: it stores your `DEEPSEEK_API_KEY` through the harness credential store without echoing it. Skipping `--setup` is fine — a new thread without a stored key offers a Configure DeepSeek API key action that runs the same flow.
$npm install --global deepseekharness-acp-interactive$dsh-acp-interactive --setup
Part 2 — wire it into Zed
- 4
Register the agent in Zed's settings.json
Open the command palette (Ctrl+Shift+P / Cmd+Shift+P), run `zed: open settings`, and add the server under `agent_servers`. On Windows, point `command` at the absolute path printed by `where.exe dsh-acp-interactive` (forward slashes or double backslashes); on macOS and Linux, use the output of `which dsh-acp-interactive`. Save the file.
{ "agent_servers": { "dsh-acp-interactive": { "type": "custom", "command": "dsh-acp-interactive", "args": [] } } } - 5
Start a thread from the agent panel
Open Zed's agent panel with Ctrl+? / Cmd+?, pick dsh-acp-interactive from the dropdown, and send your first prompt. Tool calls run inside the dsh sandbox: under the read-only preset a write comes back as an ACP permission request with Allow once / Reject, and approved edits render as tool cards. The `/` palette lists the human commands the composed plugins register, and the composer exposes permission and reasoning-effort selectors as ACP session configuration options.
- 6
Beyond Zed: other clients and adapters
Any client that speaks ACP v1 can talk to these servers. The directory below covers Paseo and BitFun adapters, a plain ACP server implementation, and Martty — a TUI that is itself an ACP client. Sessions from dsh-acp-interactive land as JSONL under `acp-sessions` in your `.dsh` home, partitioned per working directory, so editor sessions stay auditable outside the editor. Streaming granularity still varies by client — the two known rough edges are in the FAQ.
ACP vs MCP: which protocol does what
The two acronyms sit on opposite sides of the agent, and dsh speaks both.
ACP — editor ⇄ agent
The Agent Client Protocol (agentclientprotocol.com) standardizes how a client hosts a coding agent: create and resume sessions, send prompts, stream messages, thoughts, tool calls and plans back, negotiate permissions, and expose model and reasoning-effort pickers. Zed's agent panel is the flagship client.
MCP — agent ⇄ tools
The Model Context Protocol standardizes how an agent reaches tools: an MCP server exposes tools, resources and prompts — maps, search, databases — for the model to call. dsh attaches MCP servers per session; the field mapping and the mcpServers block are covered in our MCP setup guide.
They compose rather than compete — an ACP session can attach MCP servers, so wiring Zed through ACP does not replace your MCP setup. Set up MCP servers in dsh
The dsh ACP adapter directory
Every server below was verified to exist on 2026-09-29; star counts are snapshots of that day. The first row is the one this guide installs.
| Project | Stars | Best for |
|---|---|---|
| ClickPM/dsh-acp-interactive | ★99 | The editor-facing server wired into Zed above — messages, thoughts, tool cards, plans, titles, usage; ACP v1 as its baseline |
| openma-ai/Martty | ★78 | A unified harness TUI that is itself an ACP client — terminal-native sessions without an editor |
| openma-ai/deepseek-harness-acp | ★36 | A plain ACP server implementation for dsh (dsh-acp) from the Martty team |
| Pheobe-Southwood/dsh-acp-paseo | ★11 | Paseo integration bundle — auto-discovered model catalog, plan/execute modes, native dsh slash commands |
| bobleer/dsh-acp-for-bitfun | ★10 | BitFun ⇄ dsh adapter for the BitFun editor side |
| grunmin/dsh-acp-enhanced | ★7 | A Zed bridge with block-level streaming, usage telemetry, model and reasoning-effort switching, and permission presets — installed as a plugin |
All community-maintained projects, none affiliated with or endorsed by DeepSeek; the official npm packages remain automation-only. Verify install commands against each repository's README before running them.
ACP setup FAQ
The questions that come up once the server is running.
What is the difference between ACP and MCP in dsh?
Direction. ACP (Agent Client Protocol) connects a client — Zed's agent panel, a TUI, a script — to the dsh agent: sessions, prompts, streaming replies and permission requests travel on this line. MCP (Model Context Protocol) connects the dsh agent outward to tools such as maps, search or databases. An ACP session can attach MCP servers, so the two protocols stack instead of competing.
Is there an official dsh ACP server?
Yes — `@deepseek-ai/dsh-acp` in the repository's `packages/acp`, started with `dsh --profile acp`. Its npm description says exactly what it is: an automation-only ACP server over JSON-RPC stdio. It handles sessions, model selection, MCP attachment, prompts and permission prompts, but intentionally omits dsh's presentation surfaces — plans, titles, todos, terminal views and elicitation.
Why doesn't Zed show plans or todo cards when I use the official server?
By design, not by accident: the official design note on record positions ACP as an automation-only protocol, and unsupported surfaces are omitted or rejected at the protocol layer. For the full editor experience — plan cards, session titles, usage — use a community interactive server such as dsh-acp-interactive, which projects those dsh updates into ACP content.
Why does the whole reply arrive in one chunk instead of streaming?
A known granularity gap, reported in discussion #8244 on 0.1.7-rc.2: the agent_message_chunk update can carry the full message at once, so Zed's typewriter effect has nothing to animate until the turn finishes. Interactive servers mitigate this by projecting finer-grained session events; do not assume your client streams — check the adapter's compatibility notes first.
Why does the model's reasoning text appear inside the reply?
That is discussion #8235: dsh-acp gives the reasoning (thought) and the reply (message) of one assistant turn the same messageId, so clients that group chunks by messageId merge the two. Reproduced through Paseo against @deepseek-ai/dsh-acp 0.2.0-rc.1 and 0.1.7-rc.2. Until it is fixed upstream, an interactive server that projects the two streams separately avoids it.
Does this work with editors other than Zed?
Anything that speaks ACP v1: the protocol is client-neutral, so Paseo and BitFun have their own adapters, Martty covers the terminal, and community gateways target VS Code's ACP support as well. What differs per client is the projection — how much of the streaming, plan and permission surface it renders — so verify against the adapter's compatibility matrix.
Related guides
The protocols and presets around this setup.
Set up MCP servers in dsh
The tools side of the house: field mapping, mcpServers blocks and a real session calling an MCP — the exact complement to ACP.
Read the guideMCP manager plugins collection
Panels that keep your MCP servers observable once ACP sessions start attaching them.
Read the guideBest MCP servers collection
The servers most worth attaching to your ACP or dsh sessions, picked by the community.
Read the guideSubagents: parallel agent teams
Delegation inside dsh — and where the official out-of-process ACP subagent backend fits.
Read the guideCustom agent presets
Presets decide which tools a session gets; ACP sessions run under them too.
Read the guide