DeepSeek Super-agent: Why the Harness, Not the Model, Is the Story

DeepSeek’s Super-agent is a research prototype that turns its open-source DeepSeek Harness into an always-on teammate that watches a GitHub repo, takes requests from issues and chat, and answers with pull requests, all built from plugins without touching the harness core. In this 17-minute video, Sam Witteveen walks through how it works and why he thinks the harness layer now matters as much as the model. This post also draws on the design article the DeepSeek Harness team published on X on November 1, 2026 (a machine translation from Chinese), the prototype repo, and the benchmark and paper the video cites.

https://twitter.com/DeepSeekHarness/status/2116857257245987236

TLDW

Super-agent splits an agent into one long-lived Router that talks to people and many isolated Workers that do the jobs, driven by events like new issues, review comments and chat messages instead of typed prompts. Witteveen argues the bigger story is the harness: the same model scores and costs very differently depending on what wraps it, and DeepSeek Harness is built so that everything, even the agent loop, is a removable plugin. DeepSeek’s own tests suggest the Router gets cheaper per decision as load rises and can run on a lighter model. The code is a one-commit prototype tested on synthetic workloads, and security is openly unsolved.

Thoughts

The most counterintuitive idea here is that the orchestrator should be the cheap model. Most multi-agent setups assume the opposite: put the smartest model in charge and let cheaper sub-agents do the grunt work. DeepSeek argues that once the Router only talks to people and hands out tickets, never breaking tasks down or running code, its job is long input and short output, and a lighter model handles it fine. Their stress test backs the point. When decision-worthy events rose from about 1 to about 40 a minute, events that piled up mid-inference were merged into the next call, the average batch grew from 1.0 to 2.8, each request slowed only from 2.5 to 3.9 seconds, and the time per decision fell from 6.4 to 1.6 seconds. A single central session got more efficient under load, not less. If that holds outside the lab, the place to spend on a frontier model is the Workers, where the code actually gets written.

The ablation in DeepSeek’s article is a quiet indictment of prompt engineering as architecture. They gave one session a subagent tool and a neutral prompt (“Use a subagent for a piece of work when appropriate”), and in five runs it never delegated once. Every task ran in the main session, every new chat message interrupted it, and p95 completion time hit 29.5 minutes. A delegation-first prompt helped in four of five runs, but in the fifth the model decided the work was “small” and did it itself, producing a long tail (p95 of 29.0 minutes). Super-agent landed at 12.4 minutes p50 and 15.7 minutes p95 because delegation is enforced by structure, not by hoping the model makes the right call. The honest catch is cost: Super-agent used 23.2 million cache-read tokens per run against 6.1 million for the lazy single session. You are buying predictable latency with tokens, and the tests used synthetic chat with simulated coding work, scaled to a quarter of real time.

Witteveen’s harness-matters argument is right, but the headline number deserves a footnote. On FrontierHarness Eval, the same Kimi K3 model ran through 12 harness configurations on 30 tasks. Codex passed 66.7%, while DeepSeek Harness in Creator mode and Claude Code tied at 63.3%, at a median $3.28 versus $18.34 per successful task. That is about 5.6 times cheaper. The 17.5x figure in the video is the spread across the whole table, from Exo Harness at $1.05 to Claude Code, and both Exo and Pi beat DeepSeek Harness on cost. The benchmark is run by Runta, which sells token-efficiency tooling and routed every harness through its own gateway, and each cell is a single attempt. Witteveen’s practical advice still stands: test a model in two or three harnesses before you judge it, or you may blame the model for the wrapper’s choices.

The real product is the proof that a very different agent can be assembled without forking anything. The Super-agent integration is essentially one cordis.patch.yml file that inserts a core plugin, a GitHub watcher, a Feishu watcher (off by default) and two presets for the Router and Workers. That works because DeepSeek Harness has “no privileged core to patch”: the model adapter, tool registry, session log and agent loop are all plugins on Cordis, a framework whose paper defines temporal composability (unloading a component fully reverts its side effects) and spatial composability (components declare dependencies and are managed as those come and go). Two of that paper’s three authors, Yifan Shi and Tianyi Cui, also appear among the Super-agent article’s reviewers. It also explains why the core repo refuses outside pull requests. When the core is just plugins too, contributions are plugins.

Security is the part that should slow adoption. The design lets public group chats and repo comments drive an agent, and the prototype’s docs say Executor Sessions “run commands without approval as the operator’s OS user.” DeepSeek’s article admits that if the cloud agent loop is compromised by intrusion or prompt injection, every connected device could be taken over, and that credentials can leak simply by entering the model’s context. The prototype adds sensible guardrails: a deterministic gate checks who is allowed before any model sees an event, a Mandate fixes how far each ticket can go, unrequested work defaults to an “observe” mode that only records what it would have done, and setup strips variables named like keys, passwords, secrets and tokens. Those are good habits, not a solution. Witteveen’s advice to run it with local models in a locked-down environment is the right starting point.

Key Takeaways

Super-agent is a research prototype from the DeepSeek Harness team, released October 31, 2026, and explicitly “not an official DeepSeek product.” The repo is a single commit with about 16,000 stars.
It watches one GitHub repo (and optionally Feishu, ByteDance’s workplace chat), turns allowed requests into tickets, does the work in an isolated session and directory, and usually replies with a pull request.
The design has two layers: one long-lived Router that handles all human interaction and dispatch, and context-isolated Workers that each own one task and never talk to people directly.
Every incoming event passes a deterministic code gate (allowlists, source rules, whether the agent was addressed) before any model looks at it, borrowing the fast path and slow path idea from computer systems.
Once a Worker owns a ticket it subscribes to that thread, so follow-up comments skip the Router. Turning this off raised Router decisions by about 30% and cache-read tokens by about 37%.
Under a burst of up to 40 events a minute, Router batching cut time per decision from 6.4 to 1.6 seconds, and DeepSeek says a lighter model usually handles the Router well.
A single session with a subagent tool and a neutral prompt never delegated in five runs. Super-agent finished tasks in 12.4 minutes at p50 versus 20.4 minutes for that design.
Workers run with a stripped preset: no questions to a person, no plan mode, no web fetch, no forked subagents, and any shell command longer than 5 seconds moves to the background so new comments still get noticed.
DeepSeek says a person can follow only 3 to 5 active agent sessions at once, so the next bottleneck is human attention, not model capability.
On FrontierHarness Eval with Kimi K3, DeepSeek Harness Creator and Claude Code both passed 63.3%, at $3.28 versus $18.34 per successful task. Codex led at 66.7%.
DeepSeek Harness is MIT licensed, has about 270,000 GitHub stars, starts with npx @deepseek-ai/dsh web, works with OpenAI-compatible endpoints, and does not accept outside pull requests.
The article’s watchdog session, cloud and device separation, and bring-your-own-machine daemons are design directions. The prototype’s docs do not describe them.
DeepSeek frames the whole design as old systems ideas applied to agents: batching, caching, speculative execution, compute-storage separation and external control loops.

Chapters

00:00 The Agent That Lives on Your GitHub Repo

Witteveen opens with the claim many people are making, that DeepSeek just shipped “the answer to Claude Code.” Super-agent sits on a GitHub repo, watches issues and pull requests, and when a teammate asks for something it goes off into its own session and comes back with a PR. He says the more interesting part is how it was built: entirely as a set of plugins dropped into the DeepSeek Harness.

00:39 A Catch-Up on DeepSeek Harness

Witteveen admits he never covered DeepSeek Harness when it launched in August because he was too busy building with it. It has since become one of the most starred projects on GitHub this year, now about 270,000 stars. For him the plugin architecture is the key feature, because it makes add-ons like Super-agent possible.

01:15 What Super-agent Is

Instead of opening a session and talking to an agent, the agent listens where the team already works, which in the launch version means GitHub and Feishu. When an allowed person asks for something, it opens a work item, spins up its own session in its own directory, does the work and replies in the original conversation, usually with a pull request. DeepSeek says an internal version runs continuously, reproducing and fixing bugs, answering code review comments and improving the harness itself, and that coding agents wrote much of the engineering.

02:49 Model or Harness: Which Matters More?

On VentureBeat’s Beyond the Pilot podcast, which Witteveen hosts with Matt Marshall, he asked the CTOs of Instacart and Box whether the model or the harness matters more now. Both picked the harness. His read is that much of the innovation has moved from the model to the harness, though it may swing back as models improve.

03:53 What the FrontierHarness Benchmark Shows

The benchmark ran one model, Kimi K3, through nine harnesses and 12 configurations on the same 30 tasks. Codex topped the table at 66.7%, and DeepSeek Harness Creator and Claude Code tied at 63.3%, with DeepSeek costing about $3.28 per successful task against $18.34. Witteveen cautions that one task is worth about 3.3 points, but says the harness changes cost, caching, speed and success rate even with the model held fixed.

05:52 Everything Is a Plugin

DeepSeek Harness is MIT licensed, starts with one npx command into a web UI, and works with other providers and OpenAI-compatible endpoints, not only DeepSeek’s models. In most frameworks plugins hang off a fixed core. In DSH the model adapter, tool registry, session log and even the agent loop are plugins.

06:49 Cordis and Clean Unplugging

Underneath is Cordis, described in a paper by researchers at Peking University and DeepSeek as a paradigm for spatiotemporal composability. Temporal composability means removing a component undoes everything it registered, and spatial composability means components declare dependencies and switch on or off as those come and go. A running DSH is a tree of plugins assembled from bundles, a profile’s cordis.patch.yml, a home patch and command-line overlays, and a dump-config command prints the whole tree. The four UI modes (standard, PTC, minimal and Creator) are just different plugin sets, and Creator mode can write, install and verify a new plugin from a chat description, which Witteveen calls continual learning for the harness.

10:53 Agent Teams Versus Super-agent

DSH already had an experimental agent teams feature with a roster, task board and mailbox. Witteveen explains the difference: teams coordinate agents inside one job, while Super-agent handles many independent jobs that arrive from many people over a long time. Each trigger passes a plain-code gate, then the model decides whether it is real work, which becomes a ticket with a Mandate recording who asked, under which rules and how far it may go. Workers subscribe to their threads so follow-ups skip the Router, and Router batching makes the system more efficient under load.

15:30 The Limits: Prototype, GitHub Only, Synthetic Tests

Witteveen lists four caveats. The published code is not identical to DeepSeek’s internal version and some article designs, such as the watchdog, are future directions. It covers one GitHub repo, though a cookbook shows how to add new sources. The experiments ran on synthetic workloads in a simplified setting, and prompt injection, credential leaks and cross-device permissions remain unsolved.

17:23 Will Harnesses Become All Plugins?

He closes by calling Super-agent a proof of design: a quite different agent system built from a few patch files and plugins without touching the harness core. His question for viewers is whether harnesses become composable plugin systems where different people build different ideas, instead of everyone relying on the same few coding agent interfaces.

Inside DeepSeek’s Super-agent Design

Four traits no single loop can provide

The article argues a Super-agent should be continuous (it feels like one agent across chat and GitHub), productive (it runs several tasks at once and takes new instructions mid-task), proactive (it acts on events and stays quiet otherwise) and persistent (always online and self-recovering). No single ReAct loop delivers all four, so they have to come from the system around the model. The team expects personal assistants and team coding agents to converge on the same architecture for that reason.

Inline and Spill, and Chain of Recall

DeepSeek treats the context window as a cache. “Inline” puts what the model will probably need next directly in the context, starting with an object’s ID and a short summary and adding nearby messages or comments. “Spill” truncates the rest and leaves a pointer the model can follow with a tool call. Because every object carries the IDs of related objects, the Router can walk from a chat message to a Worker session to a linked code review, hop by hop, which DeepSeek calls Chain of Recall.

Acting ahead without being asked

Borrowing speculative execution from processors, the agent can start work before anyone asks. Internally, DeepSeek runs a “silently reproduce and fix” policy: when someone reports an issue in the team chat, the agent tries to reproduce it and find a simple fix in the background, and only speaks up if it succeeds. In the prototype, unrequested work starts in an observe mode that just records what it would have done.

Full-duplex conversation and channel manners

Long tool calls become asynchronous start and stop calls, so the agent can keep answering people while builds run. Replies are tuned to the channel: chat messages are short and interrupt people only for decisions, with a verified hard cap of 100 words, while GitHub pull requests get full background, change descriptions and verification results.

Cloud brain, local hands, and a watchdog

The article proposes running the stateless agent loop in cloud containers with state in a database, while lightweight daemons on people’s own machines execute commands where uncommitted code and credentials already live. It compares this to Anthropic’s “Decoupling the brain from the hands”, but targets personal machines that are only sometimes online. A separate Watchdog session checks both infrastructure health and whether each Worker is making real progress, and maintainers can ask it in plain language why something failed.

Notable Quotes

“If there’s no core to patch, then plugins are how you contribute.”
Sam Witteveen, on why DeepSeek Harness does not accept outside pull requests

“While everyone’s been focused on just continual learning for models, this is bringing continual learning into the harness.”
Sam Witteveen, on Creator mode writing its own plugins

“The harness isn’t just a wrapper. It changes the cost, the caching, the speed, and the success rate, even when the model is held constant.”
Sam Witteveen, on the FrontierHarness results

“If you’re evaluating a model, I’d try and do it in two or three harnesses before deciding whether the model is any good.”
Sam Witteveen, on judging models fairly

“Take as little human attention as possible, and give as much value as possible.”
dsh-superagent-prototype README, the project’s guiding principle

“An agent that can act for a whole team can also waste a whole team’s attention.”
dsh-superagent-prototype README, on why the agent stays quiet by default

“DeepSeek has built something which is quite a different agent system on top of their own harness with just a few patch files and plugins without touching the core of the harness at all.”
Sam Witteveen, closing the video

Watch the full video on YouTube, and read the code in the dsh-superagent-prototype repo.