Preface¶

DeepSeek Harness (dsh) splits the agent runtime into plugins: models, tools, skills, sessions, sandboxes, storage, and UI can all be swapped out. The daily entry point is mostly the Web UI, such as npx @deepseek-ai/dsh web. However, when writing code, developers stay in their editors, leading to a specific pain point: sessions, tool calls, permission prompts, and diff reviews happen in the browser, requiring a separate workflow in the editor.

The Agent Client Protocol (ACP) was built for this exact scenario. Initiated by Zed and now co-maintained with JetBrains, its positioning is close to an “agent version of LSP”: the editor acts as the client, the agent runs as a child process, and the two sides communicate via JSON-RPC over standard input/output. Gemini CLI, Claude Agent, and Codex CLI have already integrated with editors using this protocol. DeepSeek Harness itself has an official package @deepseek-ai/dsh-acp, but the source code comments make it clear: this is an automated channel for trusted program clients, with the presentation layer and human-computer interaction still remaining in the Harness’s own UI.

The community plugin deepseek-harness-acp takes a different approach: it spins up a full Harness composite process internally, then maps session events into an ACP vocabulary that editors can render. Below is a collation verified against the plugin directory page, GitHub README, package.json, LICENSE, and npm registry information: what it is, how it differs from the official ACP package, how to install it, and how to connect it to Zed.

What It Is¶

deepseek-harness-acp is a “development and runtime” plugin for DeepSeek Harness, maintained by the GitHub organization openma-ai. Its npm package name is @openma/deepseek-harness-acp, with the CLI entry point dsh-acp. The directory page’s one-sentence description is: “An ACP (Agent Client Protocol) server implementation for DeepSeek Harness.” The repository README goes into more detail: use DeepSeek Harness from ACP clients like Zed and Backchat.

It does not aim to “build another chat window”: instead, it connects the same runtime you have already configured in dsh web directly to your editor:
- The adapter assembles Harness within the same process, rather than wrapping it with an HTTP proxy externally.
- Credentials never enter the editor configuration. It reuses the keys saved by the Web UI in $DSH_HOME, or uses dsh-acp login to write credentials to the same storage location.
- Sessions, settings, presets, and logs are shared with dsh web via $DSH_HOME. Conversations you have started in the Web UI can be listed and loaded in the editor.

The license is based on the repository: LICENSE, package.json, and the npm registry all use Apache-2.0. The directory page lists the license as NOASSERTION, which means GitHub’s license detector failed to recognize it, not that there is an unstated additional license. The primary language is TypeScript, and the engines field requires Node.js >=22.15. As of the day of verification, the GitHub repository shows 9 stars, while the directory page shows 7 stars; the repository is still under rapid iteration, so star counts are for reference only.

You need to distinguish between two sets of similarly named tools:
1. Official @deepseek-ai/dsh-acp: An automated ACP service in the DeepSeek Harness source tree, targeted at program clients with intentionally restricted capabilities.
2. Community @openma/deepseek-harness-acp: A full editor adapter that projects streaming text, inference, tool diffs, permission requests, session modes, slash commands, skills, and MCPs into the ACP vocabulary.

There is also an overlapping acronym to avoid confusion: Agentic Control Plane is also abbreviated as ACP, which is unrelated to Agent Client Protocol. This article only discusses the latter.

The community plugin directory deepseek-harness-plugin.com is an independent site with no official affiliation to DeepSeek / HyperMind, do not treat it as an official app store. DeepSeek Harness itself is still in developer preview, and the official repository explicitly notes that breaking changes will occur.

Core Features¶

The repository README describes its capabilities as “mapping the harness’s session-event logs to a complete ACP vocabulary”. Below is a breakdown of only the features explicitly documented in the README and cordis.patch.yml.

Streaming Output and Tool Calling¶

Assistant text and inference deltas will be pushed to the client via ACP; if the client does not support deltas, the adapter will fall back to sending the full assembled message. Tool calls include the ACP kind, human-readable title, file location, and the actual diff obtained from the fs-tool hunk. When the client supports a display terminal, command output will go to the terminal panel; otherwise, it will use fenced code blocks.

session/cancel will pass through Harness’s agent to interrupt the current turn, rather than just dropping a flag at the protocol layer.

Permission Presets as Session Modes¶

Sessions start with the workspace-write preset by default: Bash and file changes are restricted to the session’s cwd (plus a shared temporary directory). Three named presets match those in the Web UI, each being a fixed {sandbox, approval} combination:
- read-only
- workspace-write
- danger-full-access

If the model requests broader permissions, an ACP permission prompt will pop up. Selecting “Always allow (this session)” will change the approval policy for that session to never. The danger-full-access preset will turn off both the sandbox and approval prompts, and the README explicitly notes that it is only suitable for one-time checkouts or containers.

Composites, Model Catalog, and Slash Commands¶

When a profile has agentPresets configured, an uncategorized config entry id: "agent" will appear, with a list including standard / code / minimal / cordis and your own custom copies. Switching presets will rebuild the agent on the fly, while preserving history. Copying and deleting presets still needs to be done in the Web Settings page, and there is no /preset slash command.

The model list comes from the running composite: third-party vendors you add in the Web UI will appear immediately. Inference effort follows the product’s default values. The adapter includes built-in /status and /model commands, and also executes commands from the Harness command registry such as /compact, /goal, /permission, /plan, as well as skill calls (/skill-name). These commands do not go through the model’s turn. Login and logout are ACP methods, not chat commands.

Sessions, Plans, Usage, and MCP¶

todo_write snapshots will be converted into ACP plans; token accounting uses usage_update and per-turn usage. session/load will replay the full history, and session/list can list sessions; if the client sends a prompt for an old session after the agent restarts, the adapter will silently restore it. Titles are synchronized via session_info_update.

Each session’s mcpServers will attach a @deepseek-ai/dsh-mcp-client instance (stdio and streamable HTTP), with tool names in the format mcp__<server>__<tool>. A single MCP server failure will not crash the entire session.

Images and Credentials¶

When the composite has ctx.attachments enabled (which is included in dsh-base), the adapter will declare promptCapabilities.image. ACP image blocks will be validated, saved via saveImage, and maintain their online order relative to surrounding text. resource_link is only treated as a text file pointer.

Credentials have two layers, and no keys are stored in the editor configuration:
1. Harness credential store: $DSH_HOME/.credentials.yaml (mode 600), the same file used by the Web UI, supports hot reloading.
2. Process environment: DEEPSEEK_API_KEY / DEEPSEEK_BASE_URL, as well as ANTHROPIC_API_KEY / OPENAI_API_KEY for their respective routes.

Credential access is controlled by the current vendor route. If you only have an Anthropic key, you cannot start a DeepSeek session, and vice versa. When credentials are missing, session/new and session/prompt will fail with auth_required (-32000).

ACP initialize will declare three types of Agent Auth:
1. API key: Method name api-key; when multiple routes exist, write it as api-key: <route>. Clients can pass _meta["api-key"].apiKey.
2. Browser: Opens the local login page, and keys never travel over ACP. Hidden when NO_BROWSER is set.
3. Custom gateway: Only appears when the client declares clientCapabilities.auth._meta.gateway === true, and the client sends { baseUrl, headers, providerName? }.

Installation and Activation¶

First confirm that you have Node.js 22.15 or later installed on your machine, and that you can run DeepSeek Harness. The official quick start command is:

npx @deepseek-ai/dsh web

The Web UI will run by default at http://127.0.0.1:3080. You can also install it globally first:

npm install -g @deepseek-ai/dsh
dsh web

DeepSeek Harness is still in developer preview, and core plugins and APIs are subject to change.

Installation Command from the Community Directory Page¶

The original command from the community directory page, run in the DeepSeek Harness terminal:

dsh plugin add github:openma-ai/deepseek-harness-acp

For reproducible installs, pin the commit hash as instructed on the directory page:

dsh plugin add github:openma-ai/deepseek-harness-acp#<commit>

Replace <commit> with the actual commit hash from the repository. The directory page also warns: the plugin runs with the permissions of the current dsh process, and may execute code during installation; you should inspect the source repository and license before installing.

Two Usage Methods from the Repository README¶

The command from the directory page handles “adding the plugin to your current configuration”. To actually connect it to your editor, the README provides two paths.

A. Standalone Server, good for testing first:

npm install -g @openma/deepseek-harness-acp
dsh-acp login

dsh-acp login is interactive, and input will not be echoed; you can also just save your keys once in the Web UI’s Settings → Models. As of the day of verification, the GitHub package.json version is 0.4.10-beta.2, while the npm latest tag is 0.4.9. Use the actual version from the registry when installing via npm, do not hardcode unreleased beta versions in scripts.

The standalone process will look for Harness via --dsh-path / DSH_PATH, its own directory, ./node_modules, dsh on PATH, npm root -g, and finally fall back to the peer dependency installed via npm. If $DSH_HOME/profiles/acp already exists, that profile will be used for the composite.

Example Zed settings.json:

{
  "agent_servers": {
    "DeepSeek Harness": { "command": "dsh-acp" }
  }
}

B. dsh Profile Plugin, good for long-term use in your dsh configuration:

npm install -g @deepseek-ai/dsh
dsh web
dsh plugin --profile acp add -w @openma/deepseek-harness-acp

This will create $DSH_HOME/profiles/acp and register the dsh.bundle patch from the package. The bridge is attached to @deepseek-ai/dsh-base, with the same product baseline as dsh web, and module hot reload is disabled. You can then modify $DSH_HOME/profiles/acp/cordis.patch.yml like a normal profile.

Corresponding Zed configuration:

{
  "agent_servers": {
    "DeepSeek Harness": { "command": "dsh", "args": ["--profile", "acp"] }
  }
}

Both modes share $DSH_HOME: credentials, settings, presets, and session logs are all the same set of files.

Typical Usage¶

The commands and configurations below are taken directly from the repository README and can be reproduced as written.

Start a Session in Zed¶

1. Install the adapter using either method A or B above.
2. Save your vendor keys either in the Web UI or via dsh-acp login.
3. Add the corresponding agent_servers entry to your Zed settings.json.
4. Select “DeepSeek Harness” in Zed’s Agent panel and start a new session.

When the standalone server is running, stdout only carries ACP JSON-RPC traffic; do not attach regular logs to this process’s stdout. This is why cordis.patch.yml disables HMR watching.

Override Models, Permissions, and Inference Effort¶

Flags take precedence over environment variables, which take precedence over default values. If no flags are passed, the session will follow the product defaults (settings.yaml). Common options:

For permanent overrides, edit cordis.patch.yml in your profile (override by ID, later entries take effect), and do not put keys into your editor’s JSON configuration files.

Additional subcommands include dsh-acp login [api-key] and dsh-acp update (self-updating via npm).

In-Session Commands¶

Once logged in, you do not need to paste keys in chat. Available in-session commands:
- /status, /model: Built into the adapter
- /compact, /goal, /permission, /plan, etc.: From the Harness command registry
- /skill-name: Call an installed skill

To switch agent presets, use the client’s agent configuration option, do not look for a /preset command.

Dual Profiles for Local Plugin Development¶

The README recommends: keep using the published package for your editor, and create a separate profile using pnpm’s link: to point to your working tree (using file: will be treated as a copied install, and tarballs of the same version will use the cache):

dsh plugin --profile acp add -w @openma/deepseek-harness-acp
dsh plugin --profile acp-test add -w "link:$PWD"

The development cycle is npm run build followed by restarting the process. Zed can run both the stable and development versions simultaneously:

{
  "agent_servers": {
    "DeepSeek Harness": { "command": "dsh", "args": ["--profile", "acp"] },
    "DeepSeek Harness (dev)": { "command": "dsh", "args": ["--profile", "acp-test"] }
  }
}

Use Cases and Notes¶

It is a good fit for these groups:
- Users already using dsh web who want their same set of credentials and sessions available in Zed and other ACP clients.
- Developers who need to view tool diffs, permission requests, plans, and terminal output directly in their editor, rather than just getting a plain text response.
- Teams who want to bring DeepSeek Harness’s skills, slash commands, and MCPs to the editor side without configuring separate keys for the editor.

There are also scenarios where it is not a good fit, which should be made clear:
- If you only need to make a single programmatic call to prompt / cancel / request one-time permissions, the official @deepseek-ai/dsh-acp is the automated channel for that purpose; do not install or use both packages together.
- If you need to connect an agent to an editor that does not have an ACP client, this plugin will not help. See Zed’s ACP page and agentclientprotocol.com for supported editors.
- Both DeepSeek Harness and this plugin are still under rapid development. The npm 0.4.9 version does not match the repository’s 0.4.10-beta.2, so after installation, refer to the actual resolved version and commit.

Follow these security practices as stated on the directory page and README:
- The plugin runs with the permissions of the current dsh process, and may execute code during installation. Read the source code and Apache-2.0 license before installing.
- Do not paste API keys into settings.json.优先使用 Web UI 或 dsh-acp login 保存凭据。
- The default workspace-write preset already restricts changes to the session’s working directory; danger-full-access will turn off the sandbox and approval prompts, and should only be used for one-time directories or containers.
- Credential access is enforced per vendor route; missing credentials will cause sessions to fail with auth_required, which is expected behavior and not a client-side bug.