Skip to content
Agentic Control Plane

The dsh control model, explained

dsh, the DeepSeek Harness, sends every tool call through one pipeline where plugins can allow, ask or deny it, and an approval service prompts you on asks. With no approval service mounted, an ask denies itself. Its native sandbox defaults to read-only, with workspace-write and danger-full-access as the other modes.

DeepSeek Harness shipped in developer preview in mid-August 2026. Its control design is worth studying even if you never run it, because dsh made choices that older harnesses are still retrofitting. This page covers what dsh ships natively for controlling tool execution, how each mechanism behaves, and where it stops.

This page covers dsh’s own controls. To wire ACP into dsh, see the install guide. For what our plugin intercepts, see the coverage matrix. (dsh also ships an unrelated acp, Zed’s Agent Client Protocol for editors; which ACP is which.)

The one-pipeline architecture

The key fact about dsh: everything dispatches through one pipeline. dsh is built on Cordis, so its built-in tools are plugins on typed extension points, and so is anything you add. bash, pwsh, read/write/edit, glob/grep, web_fetch/web_search, subagent spawns, and the serialized sub-calls inside Code Mode all take the same path.

That sounds like plumbing, but every control question comes back to it. In harnesses that added hooks later, coverage is a per-tool negotiation: shell fires the hook, file edits maybe, MCP calls it depends. In dsh, if you stand on the pipeline, you see every call. There is no second door.

The full dispatch is a Cordis waterfall: tool/call, then tools/pre-execute, tools/execute, tools/post-execute, and tool/result, with each listener calling next() to pass along. MCP tools use the same pipeline, exposed as mcp__<server>__<name>. Two points matter for control:

Extension point Fires Can
tools/pre-execute before every tool call return allow / ask / deny; a deny skips the call with the reason recorded in the session log
tools/post-execute after every tool call inspect the result and replace its content before the model reads it

Both are ordinary Cordis plugin registrations, the same mechanism dsh’s own tools use. They run in-process, with no subprocess or JSON-over-stdin dialect. An ask feeds dsh’s native approval flow (ctx.approval) instead of a parallel one.

The post-execute point can rewrite what the model sees, not just watch it. Most harnesses’ post-hooks only observe, so by the time you spot a leaked credential in a tool result, the model has already read it. dsh is one of two harnesses we’ve integrated where inline rewrite works (the coverage matrix compares them).

The approval service

Approvals in dsh are a composition decision, not a setting. A profile that mounts an approval service gets interactive prompts: an ask, from dsh’s own logic or from any plugin, goes to the human, and the answer resolves the call.

When no approval service is mounted, this happens:

Asks deny themselves. In a headless composition, dsh resolves ask to deny by design. An unattended agent cannot approve its own call.

This is the best native control decision we’ve seen a harness ship in 2026. Every harness has some answer to “what happens to an approval prompt when nobody’s there.” Usually it’s an undocumented timeout, and sometimes a silent auto-approve. dsh made it explicit and structural: the deny doesn’t come from a rule you remembered to write. It comes from nobody being there to say yes. Delegation works the same way: the subagent bridge answers child prompts with reject by default. We explain why this is the only sound resolution in the empty-chair test.

The sandbox and the presets

dsh ships a native sandbox, and its default is the strictest mode. ctx.sandbox wraps the command line before it spawns, and @deepseek-ai/dsh-sandbox-policy resolves the mode per session:

  • read-only: the default, documented as the fail-safe.
  • workspace-write: writes confined to workspaceRoot (default: the cwd).
  • danger-full-access: the name says it.

The local backend runs commands through a bwrap-compatible runner, and a remote E2B backend exists for disposable execution. The ecosystem’s own advice applies: treat the sandbox as filesystem scoping, not a general security boundary.

The official dsh-permission-presets plugin pairs sandbox mode with approval policy as named presets: workspace-write (sandbox workspace-write plus approval ask) and danger-full-access (sandbox open plus approval never). The second is dsh’s yolo flag. It’s named like a warning, and choosing it is a visible profile decision instead of a forgotten CLI flag.

Core ships no rule language. That’s left to plugins, and they’re forming. Community dsh-tool-policy does deny-by-default ordered rules (first match wins, anchored tool patterns, JSON-Pointer argument matchers, ask routed into ctx.approval). dsh-auto-review puts an LLM reviewer on the approval answerer chain, and it denies when it fails. Three days after launch there were 300+ plugins under the dsh-plugin topic, and policy plugins were among the first built.

Configuration and profiles

dsh’s unit of configuration is the profile: a set of plugins declared in package.json ("dsh.profile.bundles") and adjusted with cordis.patch.yml overlays. Controls follow the same shape:

  • Adding or removing an interception plugin is a profile edit, and dsh --profile <name> --dump-config shows the result.
  • --patch overlays adjust a plugin row’s config by file path, which helps with per-machine overrides. They cannot change a row’s name, which limits what a stray patch file can substitute.
  • There is no global rules file, no allowlist syntax, and no per-command patterns as shipped. Policy is expected to arrive as a plugin on the pipeline.

We hit two sharp edges in the preview, and both affect control coverage. Profile-installed plugins don’t resolve under a bare npx launch (ESM resolves from the npx cache), so launch from an installed profile. And dsh needs Node 22; Node 20 fails at boot with a cryptic error. Preview means breaking changes are promised, so after any dsh upgrade check that your interception plugin mounted (--dump-config).

The session log

dsh’s native record is an append-only SessionEvent log with a rule the runtime enforces and the docs state in four words: model-visible means logged. Every turn, step, and tool event, including deny reasons, lands in the durable log. No code path lets the model see something the log missed. That’s the strongest native audit story of any harness we’ve surveyed. Most ship a transcript and hope.

Two limits:

  • It’s still the run’s own account, written by the harness on the machine the agent ran on. For attended use that’s plenty. For unattended use, that machine is the wrong place for the only copy of the evidence, because a compromised or wedged run takes its witness with it. (OTLP export exists via dsh-session-telemetry-otel, but it defaults to DISABLED.)
  • It’s an event log, not a decision ledger. It records that a call ran or was denied. It doesn’t record what was evaluated, against which policy version, on whose authority. “What did the agent do” has a native answer. “Why was that allowed” doesn’t.

Escape hatches and the bridge

  • dsh’s yolo equivalent is the danger-full-access preset: approval never, sandbox open. It’s a named, visible profile decision rather than a CLI flag someone forgets in a script. The discipline is the profile review (--dump-config), not a flag audit.
  • The hooks-claude-code bridge (@deepseek-ai/dsh-hooks-claude-code) runs an unmodified Claude Code hooks.json inside dsh. Deny and ask are honored; input rewriting is not. It helps with porting but is weaker than a native plugin, so if your control layer supports dsh natively, use that.
  • One naming collision to avoid in config reviews: dsh’s packages/acp is Zed’s Agent Client Protocol, unrelated to the Agentic Control Plane.

Where the native model ends

dsh gives you complete interception coverage, a real approval flow with the right headless behavior, a sandbox that defaults to read-only, inline output rewrite, and the best native event log in the ecosystem. It deliberately leaves out:

  • A policy engine in core. Presets pair sandbox with approval posture. Rules, patterns, and tiers are the plugin ecosystem’s job.
  • Anything across machines. Profiles, trajectories, and approvals are per-composition and per-machine. Two developers’ dsh setups share nothing unless you build the sharing.
  • An independent record. The trajectory is written by the same process it describes.

That’s a coherent design, not a flaw: dsh ships the architecture of control and leaves the content to the ecosystem. It is also the seam a control layer fills. Our plugin mounts policy on tools/pre-execute (it returns allow, ask or deny from workspace rules, with tier-aware resolution), scans output with inline rewrite on tools/post-execute, and writes every decision to a ledger off the machine. It uses dsh’s own mechanism and typed points.

One open item. In one production tenant, dsh ran some tools after our plugin reported a deny, and the cause is not found yet. Until it is, treat a deny on dsh as reported, not guaranteed, and keep the read-only sandbox default as your backstop. Check the coverage matrix for the current status.

Frequently asked questions

How do permissions work in DeepSeek Harness (dsh)?

dsh routes every tool dispatch (built-in tools, custom plugins, and the serialized sub-calls inside Code Mode) through one pipeline with typed interception points. An approval service, when mounted in the composition, receives asks and prompts the human. Plugins on tools/pre-execute can return allow, ask, or deny for any call; tools/post-execute plugins can inspect and replace tool output before the model reads it.

What happens to approval prompts when dsh runs headless?

They deny themselves. In a composition with no approval service mounted, dsh resolves ask to deny by design, so an unattended agent cannot approve its own call. That is the right unattended posture, and dsh is one of the few harnesses that ships it natively instead of leaving the timeout behavior undefined.

Does dsh have allowlist or denylist rules like Claude Code's settings.json?

Not in core. dsh ships the architecture (the pipeline, a native sandbox with a read-only default, permission presets pairing sandbox mode with approval policy) and leaves rule content to plugins. The official dsh-permission-presets plugin gives you workspace-write (sandbox workspace-write, approval ask) and danger-full-access (approval never). Community plugins like dsh-tool-policy add deny-by-default ordered rules with first-match-wins. The trade: fewer built-in knobs, but whatever policy you mount sees every call.

Does dsh sandbox tool execution?

Yes, natively, and the default is the strictest mode. ctx.sandbox wraps commands before spawn, with modes read-only (the documented fail-safe default), workspace-write, and danger-full-access. The local backend uses a bwrap-compatible runner; a remote E2B backend exists. Community guidance is to treat it as filesystem scoping rather than a general security boundary.

Is dsh's session log an audit trail?

It is the strongest native record in the ecosystem: an append-only SessionEvent log with a runtime-enforced rule that anything the model can see is logged. It is still not an independent decision ledger. It lives on the machine that ran the agent, is written by the process it describes, and records what happened rather than what was checked against which policy. OTLP telemetry export exists but is disabled by default.

What is the dsh harness?

dsh is DeepSeek Harness, released in developer preview in mid-August 2026. It is built on Cordis: tools and policy are plugins on typed extension points, composed per profile, and every tool dispatch, including Code Mode sub-calls, goes through one pipeline.

How do I change the dsh sandbox mode?

The sandbox resolves per session to read-only (the default), workspace-write or danger-full-access. The official dsh-permission-presets plugin pairs a sandbox mode with an approval policy: workspace-write uses approval ask, and danger-full-access opens the sandbox with approval never.

What does dsh --profile do?

It starts dsh with a named profile, the composition of plugins that makes up your harness. Plugins are declared in package.json under dsh.profile.bundles and adjusted with cordis.patch.yml overlays; dsh --profile <name> --dump-config shows what actually mounted.

Running dsh? One command adds a native plugin. Each tool call is checked and recorded. A block is reported to the agent but not enforced by the plugin yet.

macOS · Linux · WSL
curl -fsSL https://agenticcontrolplane.com/install.sh | bash
Windows · PowerShell
irm https://agenticcontrolplane.com/install.ps1 | iex

What the installer writes  ·  dsh guide  ·  free up to 5 agents