DeepSeek DSH 사용 방법: DeepSeek의 오픈소스 에이전트 하네스 실전 가이드

DSH — Deep​Seek Harness — is the agent runtime Deep​Seek open-sourced on August 13, 2026, and it is not a model. It is the harness that sits between a model and your terminal, giving a language model file editing, a shell, retrieval, planning and tool calls, then recording every step so you can replay what it did. The how-to answer in one breath: install Node.js, run npx @deepseek-ai/dsh web, open http://127.0.0.1:3080, add an API key, pick a preset, and start a session. Below is the version of that answer you can actually work from — the four presets, driving it as a coding agent, reading a Trajectory, slotting in MCP, and the preview-version caveats the launch coverage skipped. The two models you will most likely plug into it — DeepSeek V4 Flash and DeepSeek V4 Pro — are named throughout.

This is a usage guide, not a launch recap. We already covered the leak trail and the release date in separate pieces; the subject here is the question a searcher actually has — how to use the thing once it is installed. The sourcing is labelled as it goes: Deep​Seek's own repository and documentation for what DSH claims, and dated Chinese tech press (GeekPark, The Paper) plus community repositories for what people report after running it.

What DSH is (and what it isn't)

Deep​Seek's internal formula is Model + Harness = Agent, and DSH is the harness half. The model reasons; the harness decides when to hand it a tool, reads files, runs shell commands, feeds error output back into the loop, and judges when a task is finished. DSH was open-sourced on August 13, 2026 at about 8:30 pm Beijing time under the MIT license, written in TypeScript, and shipped as a v0.1 developer preview. The star history is the part everyone quotes: roughly 7,300 stars at 9:05 pm, 15,500 by 9:51 pm, past 10,000 within about two hours of the announcement, 50,000 inside twelve hours, and 100,000 in about 42 hours — the fastest growth GitHub has recorded, per GeekPark and The Paper's same-day reporting. The repository sits at roughly 126,000 stars as of today.

The architecture slogan is "everything is a plugin," built on the Cordis framework: model adapters, tools, Skills, the session log, the approval policy, even the agent loop itself are plugins mounted into a shared context. A default install carries more than a hundred plugins, and the internal-testing phase produced roughly three hundred community plugins before the public release, per GeekPark. That is why it is called an agent runtime rather than an app — you assemble the behaviour you want out of swappable parts.

The thing DSH is not is a model. There is no "DSH model" to benchmark, and nobody hosts DSH for you to call — it runs locally, on your machine, and it charges you only for the model tokens it consumes. The model is plugged in separately, and Deep​Seek ships adapters for 20+ providers and protocols, including Deep​Seek's own API, Open​AI-compatible endpoints and Anthro​pic's. In practice the pairing everyone is running is DSH plus DeepSeek V4 Flash for cheap everyday coding, or DeepSeek V4 Pro when the task is hard enough to justify a bigger brain — more on that below.

Before you start: what you actually need

The prerequisites are lighter than the coverage implies. You need Node.js — the package declares ^22.19.0 or >=24.0.0, so the current LTS and anything newer work — and an API key for whichever model you plan to plug in. DSH itself is free and open source; the only bill is model tokens. You also need a directory you are willing to let the agent touch: DSH's workspace mechanism is the security boundary, and it restricts the agent to the directories you explicitly add.

On first run DSH creates a home directory — $DSH_HOME, which defaults to ~/.dsh — holding your profiles, sessions, storage and a settings.yaml. API keys live in a .credentials.yaml file there; the Web UI shows only a masked descriptor, never the key itself. That file is worth backing up, because re-entering keys by hand is the single most common setup complaint in the community.

Install and launch: four ways in

The zero-install path is one command. From a terminal with Node.js installed:

• npx @deepseek-ai/dsh web — downloads the package and starts the Web UI at http://127.0.0.1:3080. This is the fastest route and the one the documentation leads with.

• npm install -g @deepseek-ai/dsh, then dsh web — a global install if you will use it repeatedly.

• From source: git clone https://github.com/deepseek-ai/deepseek-harness, then pnpm install, pnpm run build, pnpm dsh web — the right route if you want to read or modify the code, and the one the plugin-development docs assume.

• Python SDK: pip install deepseek-harness-sdk — for CI scripts and batch automation, with examples under the repository's examples directory.

There is also a headless CLI for one-shot tasks in scripts: dsh --profile headless "fix the failing test in this repo" runs the agent once, prints the final answer and exits with code 0. The dsh launcher parses only its own flags — --profile, --patch and the like — and passes everything after them to the profile being launched, which is a common first-run confusion.

The Web UI binds to 127.0.0.1 by default, so nothing is exposed to your network — a deliberate default, and one to keep until you have a reason not to. Sessions, logs and credentials all stay on your machine; there is no cloud component to DSH itself.

First run: key, workspace, session

With the UI up, the first-run loop is three steps. In Settings, add your API key under Models and pick the provider. Then add a workspace — the project directory you want the agent to operate in. Finally, create a session, choose a runtime preset, and send a small first task such as "analyse this directory's structure and write a README for it." Starting small matters: it is the fastest way to confirm the key, the workspace boundary and the sandbox are all behaving before you hand the agent a real job.

DSH asks clarifying questions on its own when an instruction is ambiguous, even with planning mode off, presenting suggested options rather than guessing. The community reports this as one of the least expected and most useful default behaviours for a first-day user.

The four presets — and which to pick

The presets are not the same model in different moods. Each one is a different tool catalog plus a different system prompt, and switching presets changes what the agent can see and do, not which model answers. The four shipped presets are Standard, PTC, Minimal and Creation.

• Standard — the full coding-agent toolbox: file editing, a persistent shell, file and web retrieval, Skills, planning mode, goal tracking, sub-agents and workflows. This is the Claude Code / Open​AI Codex-shaped default, and it is where you should start.

• PTC (Code mode) — "Programmatic Tool Calling." It packages the tool catalog into a TypeScript SDK and lets the model write a TypeScript program that makes many tool calls in one run_code invocation, keeping intermediate data in a worker thread and returning only a summary to the model's context. Community reports put the token savings at around 20x on multi-step tasks, at the cost of making the model's first output a program you can read and audit.

• Minimal — exactly two tools, a persistent bash shell and str_replace_editor, with a bare persona prompt. It exists for benchmarking model ability with minimal harness scaffolding; Deep​Seek used it for the official DeepSeek V4 Pro 0813 agent evaluations. Use it when you are testing a model, not when you are trying to get work done.

• Creation — Standard plus runtime inspection and plugin experimentation: a dsh-tool-cordis tool that reads the live runtime (loaded plugins, services, events) and mounts or unmounts plugins in memory, aimed at people building presets and plugins. Treat it as having shell-level power — it can change the harness while it is running.

The opinionated version: start in Standard, graduate to PTC for the repetitive multi-step tasks where the round-trip reduction pays, and leave Minimal and Creation alone until you are benchmarking or building plugins. One community caveat worth keeping: the Minimal preset's tool schema is measurably better at anchoring DeepSeek V4 Pro into a terse "we need…" first response than the fuller Standard catalog is, which is why experimental presets such as dsh-anchored-standard expose a Minimal-aligned first request and then unlock Standard. That is a sign of how much the tool catalog itself shapes behaviour — worth knowing if a task keeps coming back from the agent in the wrong voice.

Using it as a coding agent: a concrete workflow

Here is the shape of a real DSH session on the Standard preset, from what practitioners report:

• Point DSH at a workspace that is a git checkout, and give it a task phrased as an outcome: "add pagination to the list endpoint and keep the existing query params."

• Let it plan (or not — the agent plans either way), then watch it read the relevant files, form a plan and state what it will change before it changes anything.

• The agent edits files, runs the test suite in its persistent shell, reads the failures and iterates. This loop — edit, run, read the error, edit again — is the core competency of the harness, and the persistent shell is what makes it fast: state survives between tool calls, so it is not re-booting its context on every command.

• For anything that needs external context, it uses file and web retrieval, and it can hand a large self-contained piece of work to a sub-agent so the main loop's context stays small.

• Built-in Skills cover the meta-work: dsh-code-review reviews a pull request, dsh-find-simplifications hunts for code that can be simplified, dsh-doc-standards checks documentation against house rules. Skills slot in as plugins, and the community has built hundreds more.

High-privilege actions — writes outside the workspace, or commands with full access — trigger an approval prompt in the Web UI before they run. That sandbox, with its read-only / workspace-writable / full-access tiers, is the main thing standing between a confused agent and your whole machine, so read the prompt before you click it.

When a task needs to run across several steps with decisions in between, workflows chain them and carry state from one step to the next. The combination — planning, persistent shell, retrieval, Skills, sub-agents, workflows — is the Standard preset's whole pitch, and it is the same surface area as the paid coding agents you are comparing against, running against whatever model you plugged in.

Trajectory replay: see exactly what the agent did

The feature reviewers keep coming back to is the Trajectory. DSH records the entire session as an append-only event log — the system prompt, the model's chain of thought, every tool call and result, sub-agent lifecycles and context injections. The Web UI's Trajectory view replays that stream step by step, so you can see precisely what the agent saw at each moment, which command it ran and what the model decided next.

That log is not just an audit trail. Because it is the source of truth, session recovery, forking, retrieval and replay all derive from it: you can fork a session from any point, resume one that was interrupted, and — the part teams find most valuable — attribute cost per step when a task runs long. When a coding agent silently does the wrong thing, the Trajectory is what shows you where it went off the rails instead of leaving you to guess from the final diff. No other component of the tool has this much debugging leverage.

Multi-agent orchestration and MCP

Two architecture notes matter for the "how do I build on this" crowd. First, DSH is multi-agent at the harness level, not just via one long loop: sub-agents run in their own context with their own tools, and the main agent coordinates them, which is how it keeps a large task from blowing up the primary context window. Second, MCP fits one layer down: Model Context Protocol is the open standard for connecting an AI application to external data and tools, while DSH is the runtime that decides when to offer a tool and whether to approve its call. An MCP server mounts into DSH as a plugin, so the community's hundreds of MCP servers slot in without special-casing — the same mechanism that mounts tools, Skills and presets. There is no separate "MCP mode" to enable; you add the server and it becomes another plugin in the catalog.

Where the models come from (and what it costs)

DSH is free, but it runs on tokens, and the bill is the model. The two engines most people will use are Deep​Seek's own: DeepSeek V4 Flash at about $0.15 per million input and $0.29 per million output tokens on OrcaRouter, with a 1M-token context and 384K max output — the cheap everyday driver — and DeepSeek V4 Pro at about $0.44/$0.88 for the hard tasks. Both are at provider list price on OrcaRouter, passed through at 0% markup, which means a Deep​Seek price change lands on our side the same day with no renegotiation. Independent reporting on DSH's actual consumption supports the cheap story: The Paper's day-one test ran multiple tasks through DSH for under ¥3 in total token spend.

One honest caveat from the same coverage: a day-two third-party comparison found the same DeepSeek V4 Flash completing the same tasks in a different open-source harness ("Pi") for about a third of DSH's token spend. Token efficiency is a function of the harness's prompt and context handling, not just the model, and a preview build is visibly not optimal at it yet. If cost is your deciding factor, benchmark your actual task in two harnesses before committing.

Where OrcaRouter genuinely fits here is as the model layer, not the harness. We do not host DSH — it is a local runtime, and nobody should sell you a hosted DSH. What we do host is the models you plug into it, behind one key with automatic failover across providers. That matters specifically because DSH is a 0.1 developer preview: you can evaluate it against real traffic while keeping the same models on a stable endpoint, and the day DSH changes in a breaking way, your model access does not change with it. Try the harness; keep the models on a router.

The honest limits of a 0.1 preview

Deep​Seek's own README says it plainly: DSH is in developer preview, iterating rapidly, and there will be compatibility-breaking changes. What that means in practice, from the community's first days with it:

• Upgrades will break things. Config files, plugin compatibility and preset formats have already shifted between release candidates; expect to re-verify your setup on each update.

• The documentation is incomplete. Some advanced areas — sub-agents, workflows, goal tracking — are thinly documented, and several first-week contributors report reading source or GitHub Discussions to get unstuck.

• It is a developer product, not a consumer one. The UI presumes you are comfortable with files, shells and API keys. GeekPark's summary headline — "it gets work done, but you have to watch it" — is accurate.

• Windows is a second-class citizen for now. The shell integration assumes a Unix-style environment in several places; Windows users report needing pwsh tweaks and hitting the odd path bug.

• There is no desktop app. The only interface is the browser Web UI and the CLI, which is fine in a terminal and less fine if you wanted a docked application.

• Token efficiency is unproven at scale. The Pi-harness comparison above is one data point, but it is a warning that the default prompt and context handling are not yet tuned the way a mature product's would be.

When DSH is the wrong choice

The honest flip side. Do not use DSH for production pipelines yet — the breaking-change promise is a hard stop for anything that cannot tolerate a harness update silently changing behaviour. Do not pick it for a team that is not comfortable debugging agent behaviour from a terminal; the Trajectory and the plugin system are powerful, but they presume technical literacy. And if what you actually need is a stable, maintained coding-agent experience with someone else responsible for the glue, the paid agents DSH competes with remain the lower-risk option. DSH's pitch is for the person who wants to own the harness — to swap models, mount MCP servers, write a preset and see every step the agent took.

결론

The practical answer to "how do I use Deep​Seek DSH" has not changed in the days since it shipped: install Node.js, run npx @deepseek-ai/dsh web, open port 3080, add an API key, pick Standard, and start with a small task. Learn the Trajectory view early, because it is your debugging instrument. Treat the presets as different tool catalogs, not different models, and treat the whole project as a preview: capable enough to be worth learning, unstable enough that you should keep the models it runs on behind an endpoint you already trust. That is the layer OrcaRouter sits in — DeepSeek V4 Flash and DeepSeek V4 Pro at provider list price with zero markup, one key, automatic failover — so the harness can change under you without the models changing too. DSH is the most interesting open-source agent runtime of the year so far. It is just not finished yet, and the honest way to use something unfinished is to make sure the part that can break does not take your model access down with it.