Harnesses
DeepSeek's Super-agent: one router, disposable workers, and an agent that stays quiet
On 31 October 2026 DeepSeek's Harness team published a design essay and an MIT-licensed research prototype for a proactive coding agent built around one claim: human attention is the bottleneck. What the router-and-worker design does, why a neutral prompt never delegated in five runs, what the synthetic numbers cannot show, and why its permissions model is worth copying even if you never run the code.
- Published
- 04 Nov 2026
- Reading
- 8 min
- Class
- harnesses
half-life 90dfrom 4 Nov 2026
Most agent demos assume the same thing: a person sits in front of one session, types a request and waits. DeepSeek's Harness team thinks that person is now the slowest part of the system. In the essay it published on 31 October 2026, it puts the limit at three to five active sessions, which is roughly where anyone trying to supervise parallel agents starts losing the thread. Its answer is an agent that sits in your GitHub repository and chat, works out for itself what is worth doing, and otherwise keeps quiet.
The code is public as dsh-superagent-prototype, MIT licensed, with 18,418 stars by the morning of 4 November and a single public commit. Bloomberg framed the release as a challenge to Claude Code. That is the least useful way to read it. DeepSeek calls this a research prototype and not an official product, and warns that its coding style may be inconsistent because agents did much of the engineering. What is worth your time is the architecture, and the documents are more candid about it than launch coverage has been.
The shape: one router, many disposable workers
There are two layers. A long-lived main session, the Router, receives events and
decides what to do with them. It has a smaller tool set and does not do the coding.
Each accepted piece of work becomes a Ticket, and each Ticket gets its own
executor session (worker-<ticket id>) and its own directory, usually
a git worktree. Workers report to the Router rather than chatting with
people, although they do reply on their own threads.
The problem this solves is the one every long-running agent hits. One shared session has full context but handles events one at a time, so a CI failure waits behind a refactor. A new session per event is fast and remembers nothing. Splitting the roles lets the Router stay responsive because it never holds a long task.
The detail we would copy first is small. Both router and worker presets push any foreground shell command to the background after five seconds (execution docs), so a worker running a 20-minute test suite can still read “actually, stop” at its next step. Most harnesses block on the command and find out what you said once it returns. DeepSeek's essay generalises this into an asynchronous ReAct loop, which it says exists in DeepSeek Harness but is off by default.
Why a prompt was not enough
The most useful result in the essay has nothing to do with speed. DeepSeek ran a single session with subagents available and a neutral prompt. Across five runs, the model never delegated once. With a prompt that actively pushed delegation, it delegated in four runs out of five, and in the fifth it decided the work was small and did it itself, which produced a long tail of slow completions (English reprint of the essay, section 7.1).
If you have written “use subagents when appropriate” into a system prompt and assumed it was doing something, that is worth sitting with. Five runs is a tiny sample, but it matches a sensible prior: a model sitting in a working context has little reason to hand work away. If you need delegation to happen reliably, make it structural. A router with no coding tools cannot quietly do the task itself.
What the numbers do and do not show
| Setup (5 runs each) | p50 completion | p95 completion | Note |
|---|---|---|---|
| Super-agent (router and workers) | 12.4 min | 15.7 min | 23.23M cached-read tokens |
| Super-agent, no direct event pass-through | About the same | About the same | About 30% more router decisions, 31.77M cached-read tokens |
| Single session, neutral prompt | Not given in the text | 29.5 min | Never delegated |
| Single session, delegation prompt | Not given in the text | Not given in the text | Slower than Super-agent overall, delegated in 4 of 5 runs |
Source: DeepSeek Harness team essay, section 7.1, as reprinted by ChainCatcher and reported by ifanr, both read 4 November 2026.
Now the caveat, which decides how much weight any of this can carry. The workload was about 300 synthetic messages per run, around 20 of them real work requests, and the coding was replaced by a tool that just consumed time. Message intervals and work durations were scaled down to a quarter. So these figures measure scheduling and nothing else. They say nothing about whether the code would have been any good. DeepSeek says as much and describes the results as preliminary. We found no independent benchmark of the prototype on real work as of 4 November.
The figure that survives best is the token one. Letting workers subscribe directly to their own threads, so follow-ups skip the Router, left completion time about where it was and cut cached reads by around a quarter, from 31.77 million to 23.23 million. Parallel agents multiply your context bill, and the Router is the expensive thing to keep waking. ifanr also reports router latency per request going from 2.5 to 3.9 seconds as events rose from about 1 to about 40 a minute, with batching absorbing the rest. That comes from a figure in the essay, so treat it as approximate.
Be wary of cost claims in the secondary coverage. One write-up quotes dollar figures for these runs. The essay, as reprinted, gives token counts only.
The part to steal: permissions the model cannot talk its way past
The authorization document is the best thing in the repository. Its opening rule is that the host enforces allowed lists, rules and mandates, and that messages, comments and quoted documents are inputs to a decision and cannot change permissions. From there:
- Code filters first. A gate checks the sender and the source's policy before a model sees anything. A listed person addressing the agent is an explicit request. A bot can only ever produce an inferred candidate, never an explicit request, and cannot stop a ticket.
- Proactive work starts as a log. The accept mode has three
settings.
offdrops inferred work,observeis the default and records what the agent would have accepted, andautoacts on it. Explicit requests work in all three. - Every ticket carries a mandate. It records the policy version it was accepted under and is re-checked before an ended ticket resumes. Take someone off the allowed list and work they started can lose its authority.
- Merging stays with people by default. The executor will not enable auto-merge as the agent account, because GitHub would attribute the merge to it. If you name another account, the default instructions still limit it to ready pull requests with approvals on the head commit and under 200 changed lines. The docs add that these instructions govern the agent, and only branch protection governs GitHub.
observe is the idea most teams could adopt tomorrow with any agent:
before anything acts on its own initiative, spend a fortnight reading a log of what
it would have done. It is cheap, and it gives you evidence before you widen access.
Where it is not safe, in its own words
The permission model covers who may start work. It does not contain a worker that
is already running. The
deployment
guide says both presets run with danger-full-access as the
operator's OS user, and that a worker can execute programs by path and read the
operator's home directory. Command blocklists and account wrappers, in the words of
the execution docs, “establish defaults, not a security boundary”. If you
want isolation, DeepSeek's advice is a dedicated OS account holding only the agent's
credentials.
Put that next to the subscription rule. Every message on a thread a ticket follows reaches its worker as context, including messages from bots and CI, without passing the gate. That delivery grants no new authority in the host's accounting, but by our reading a worker with full access is still reading text other people wrote. A hostile comment on a followed pull request cannot create a ticket. Nothing in the docs we read stops it from trying to steer a worker that is already live.
The essay is open about the wider problem: event-driven agents take in far more untrusted input, and without better defences they “can only operate within a very small and trusted scope”, in the reprint's translation. It also flags that credentials on a device can leak if they enter model context, and that a compromised cloud loop could reach every connected machine. For the containment options that exist today, see agent sandboxes go mainstream.
What to do with it
- Read before you run. The numbered docs are short and designed
to be read in order.
000-philosophyand002-authorizationrepay the time even if you never install it. - If you try it, use a throwaway repository and a dedicated OS account.
You need Node.js 22.19+ or 24+, pnpm, git 2.32+, Python 3.8+, tmux, GitHub CLI
2.48+ and DeepSeek Harness
itself. Setup is designed to be driven by a coding agent reading
SETUP.md, so read that file yourself first. - Expect drift between the essay and the code. The README says the published version differs from DeepSeek's internal one and that some ideas in the essay are future directions. Check the code before you quote a feature.
- Measure your own attention. Three to five sessions is presented as an observation, and the reprint we read shows no measurement behind it. Count how many you can follow before you buy an architecture built on that number.
- Move your delegation out of the prompt. If you run a multi-agent setup on any harness, check how often it delegates in practice. If the answer depends on the prompt's mood, remove the coding tools from the coordinator.
The open questions are the hard ones. DeepSeek lists long-term memory over months, how to scale the Router, and how people intervene once they have left the session, and none of them is answered here. Its authors also concede they propose no new theory, only scheduling, caching and event-driven design applied to agents. That is why it is worth reading. For the harness underneath, and how it differs from the minimalist camp, see Pi 1.0 vs DeepSeek Harness v0.2.
Sources
- deepseek-ai/dsh-superagent-prototype — created 31 October 2026, read 4 November 2026. README status notice, licence, star count and commit history.
- 000 Philosophy, 002 Authorization, 003 Execution and 006 Deployment — read 4 November 2026. The gate, accept modes, mandates, merge defaults, five-second background rule and isolation warnings.
- Super-agent Design Exploration (ChainCatcher reprint) — dated 31 October 2026, read 4 November 2026. Experiment setup and results, attention limit, security concerns and open questions. We could not retrieve DeepSeek's original, so quotations from the essay rest on this translation.
- ifanr's report on the essay — read 4 November 2026. Cross-check of the experiment figures, plus router latency under load.
- Bloomberg via Yahoo Finance — 1 November 2026. The WeChat announcement and competitive framing.
- Related on this site: DeepSeek Harness spec sheet, Pi vs DeepSeek Harness, anatomy of an agent harness.