DeepSeek Harness (dsh): The Open Agent Runtime That Rewrites Its Own Config
What DeepSeek Harness is, why its self-editing agent stands out, how the community reacted, and what to prepare for before running it with local models.
This article is published in English.
Sources: DeepSeek Harness: The Agent That Edited Its Own Config While I Watched
How much of what feels like a model being smart is really scaffolding nobody sees? Anyone who has built their own agent harness learns the answer quickly: a lot. That makes DeepSeek Harness, whose command is dsh, interesting enough to pull apart: what it is, what's distinctive, what isn't great and what to prepare for if you plan to live with it.
What it is and why a model lab built it
DeepSeek Harness is an open-source agent runtime, meaning the machinery that surrounds a model and lets it act: the loop, tools, sandbox, session storage and UI. It's neither a model nor a chatbot. The project's slogan is AGENT = MODEL + HARNESS. A developer preview landed on August 13, 2026 under an MIT license, and GitHub reacted with roughly 95,000 stars in two days and about 165,000 within a week.
Why would a model lab bother? Two numbers make the case. Vercel took a working agent and removed 80 percent of its tools. With the same model, success went from 80 to 100 percent, using half the tokens and a fifth of the latency. And on a coding benchmark, Letta Code scored 59 percent with Claude Opus while Claude Code scored 41 percent on the same Anthropic model. Models have converged, and the contest has moved to the harness. DeepSeek built one to own that layer, and as the frontier lab that exposes the model's full reasoning trace, it did so where American labs deliberately encrypt theirs.
The real difference
There's a fancy plugin system called Cordis in which tools, sessions and even the agent loop are replaceable plugins, and sessions are append-only event logs you can replay, fork and audit. After running it, though, the plainer difference stands out: the agent can edit itself while running, with no restart, rebuild or ceremony.
A telling first test is to open the web UI and give it the task of switching its own LLM provider from the DeepSeek API to a local llama.cpp server. The agent finds its own configuration, rewrites it and answers the next question through the local model. A cloud agent became a local one in about a minute and a half. Most agents treat their configuration as scripture, read-only commandments you edit by hand. This one treats it as just another file it happens to live in. That's less a feature than a posture. A tool that can change itself starts to behave like a coworker, and the whole design assumes the thing keeps changing after installation.
Community reaction
The praise is loud and the star curve is historic. Engineers like the tool-call validation, which uses strict JSON schemas and is visibly stricter than Codex. The trajectory view, which attributes every context injection to the plugin that caused it, has been called a killer feature US models won't allow. The event-sourced sessions made people genuinely emotional.
The criticism has merit too. The top Reddit thread contends that the everything-is-a-plugin idea reads well until you actually try it. Its author notes that DeepSeek's own flagship demos are a flying-whale animation and a snake game, and that efforts to get three different models to vibe-code a useful plugin all failed. Others fear plugin fatigue, with decaying VSCode extensions, abandoned Eclipse plugins and a graveyard of incompatible add-ons. Fans and critics share one caution: it's an unaudited developer preview, with breaking changes between versions. The docs say so in capital letters, an unusually honest release note.
Complaints about demo quality are accurate yet beside the point. The snake game isn't what's on offer. The substrate is, and in a few weeks the community built hundreds of plugins on it, at least ten of them independent versions of things the official demos haven't reached.
What works well
A real web UI is the first. For two years the industry shipped coding agents as terminals, which are where processes live, not where people do. dsh offers a quick, clean web UI that stays open, with tasks you can click and expand, steps, tool calls and context visible inside the running system and not buried in a log file.
It's also fast. With an online API, responses arrive quickly enough that the UI interactions feel worthwhile, and it's smoother than OpenClaw's jagged interface. And it runs multiple sub-agents by default. Standard mode doesn't ask first: it spawns sub-agents and splits the work, which is pleasant to watch against a cloud API with generous concurrency. That pleasantness turns into a planning problem with local models.
Preparing to move in
First, it's a developer preview and acts like one. APIs get renamed between versions, storage backends disappear and config formats shift. Pin the version you install. Use it to learn how harnesses work, which costs nothing, and don't rebuild your morning routine around it yet, because the ground can shift under you between releases and a script that ran yesterday may not run today.
Second, local models need slots, and real ones. Standard mode spawns sub-agents eagerly, and every one sends its own requests to whatever LLM endpoint you configured. With a single-slot local llama.cpp server, the default, things jam slowly. A sub-agent takes the main agent's slot, so when the main agent resumes its context is gone and the whole prompt is prefilled again from scratch, every round trip. A fan-out that is an asset against a cloud API turns into an endless reprocessing of prompts on a machine with one slot.
The remedy lies in architecture: give the local model several slots. llama.cpp's --parallel N handles modest fan-out. For everyday use with sub-agent harnesses, though, pick an engine built around concurrency, such as vLLM or SGLang, whose continuous batching was designed for exactly this traffic. One human with one chat is yesterday's pattern, and harnesses need a proper server.
Where it fits
DeepSeek Harness isn't trying to beat Claude Code at being Claude Code, and it isn't trying to win today. It's an open, MIT-licensed substrate waiting for people to write their own tools, plugins and, if they're brave, their own agent loop. Its signature trick of an agent editing itself while running doubles as its thesis: agents are no longer finished products but living software, with the harness as the body they keep remodeling.
A sensible path is to try it first with a cloud key and feel what the web UI and trajectory view offer. If you're local-only, bring a multi-slot server or plenty of patience. Then write a first plugin, since the ecosystem is a frontier town right now and frontier towns remember their early settlers.
Quick setup
To get one running on a laptop, ask any agent to set it up or run a script like this one, which checks for Node 24 (the repo needs 22.19 or newer):
#!/usr/bin/env bash
# DeepSeek Harness — quick setup (macOS / Linux)
set -e
# 1) Node 24 (repo requires 22.19+ or 24+)
if command -v nvm >/dev/null 2>&1; then
nvm install 24 && nvm use 24
else
echo "Install Node 24 first (https://nodejs.org)"; exit 1
fi
# 2) Fastest path - no clone needed
npx @deepseek-ai/dsh web
# opens http://127.0.0.1:3080 - set your API key under Settings → Models
# 3) From source (what I did - recommended if you want to read the code)
git clone https://github.com/deepseek-ai/deepseek-harness.git
cd deepseek-harness
corepack enable
pnpm install
pnpm run build
pnpm dsh web
# 4) Local model users: serve with multiple slots first!
# vllm serve <model> --max-num-seqs 4 (or SGLang / llama.cpp --parallel N)
# Then in the dsh UI: Settings → Models → Add custom provider
# base URL http://127.0.0.1:8000/v1, protocol openai-completions