fullauto.online

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 completionp95 completionNote
Super-agent (router and workers)12.4 min15.7 min23.23M cached-read tokens
Super-agent, no direct event pass-throughAbout the sameAbout the sameAbout 30% more router decisions, 31.77M cached-read tokens
Single session, neutral promptNot given in the text29.5 minNever delegated
Single session, delegation promptNot given in the textNot given in the textSlower 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. off drops inferred work, observe is the default and records what the agent would have accepted, and auto acts 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-philosophy and 002-authorization repay 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