DeepSeek has released dsh-superagent, an MIT-licensed research prototype designed to manage several coding tasks without asking a person to coordinate every step. The system works with one GitHub repository, listens for events, turns approved requests into parallel work, and sends results back to the conversation that started them.
The release arrived as version v0.1.0, with 1 commit under the MIT license, alongside a design post titled Exploring Super-agent Design: Towards a More Autonomous Agent System. DeepSeek Harness packages the project as a bundle for DeepSeek Harness, and the company describes it as a proactive coding agent rather than a tool that waits for a person to direct every action.
That difference matters because human attention is becoming the limit when several AI agents run at once. DeepSeek’s team argues that mainstream agents treat one session as the basic unit, but a person can actively follow only 3 to 5 sessions at once. Once more tasks enter the system, the person becomes the coordinator, monitor, and traffic controller.
A router for requests, workers for execution
The project splits those jobs across 2 layers. A long-running Router handles interaction and dispatch, while isolated Worker sessions perform the actual coding work. The main session uses the dsh-superagent-router preset with a smaller tool set, and each Worker runs dsh-superagent-worker.
The flow begins when GitHub or optional Feishu activity creates an event. An evaluation step decides whether a group of events contains new work, then creates a Ticket for each authorized task. Every Ticket carries an immutable Mandate that explains why the task may proceed, giving the Worker a fixed reason to act.
The system can also keep a Worker connected to later discussion. A Subscription sends later comments on a pull request to the right Worker without requiring a fresh mention, which lets the coding session continue through the same work thread.
Workers do not need to stop listening whenever a command takes time. Shell commands move into the background after 5 seconds, allowing Workers to keep receiving messages while those commands run. That detail supports the larger goal: several tasks can move forward without a person watching each terminal session.
Quiet by design, but not without limits
The project’s README states its core rule plainly: “take as little human attention as possible, and give as much value as possible.” The philosophy document turns that rule into a communication pattern: “The agent confirms once, stays quiet while working, and writes again only with a result, a question or a failure.”
Proactive work remains gated through 3 accept modes: off, observe, and auto. Observe is the default. In that mode, the agent records what it would have accepted but does not move ahead with the work, giving people a way to inspect the system before allowing more automation.
The design also lists ideas that go beyond the current prototype, including an external Watchdog, a separation between storage and compute, and an asynchronous ReAct loop. These ideas point toward a system that can monitor its own long-running work while keeping interaction and execution apart.
DeepSeek tested the prototype with simulated group chat and GitHub CI streams. Each run contained about 300 messages, including about 20 real work requests, and each scheme ran 5 times. The results showed a strong timing advantage for the super-agent design, but the test also had clear limits: it used synthetic messages and simulated tools, and it did not measure real coding quality.
Early results show speed, along with trade-offs
The super-agent recorded a p50 task completion time of 12.4 minutes and a p95 time of 15.7 minutes. A single session with subagents and a neutral prompt reached a p95 of 29.5 minutes, making the super-agent result about 1.9 times faster at that measurement point.
The baseline did not call a subagent at all in 5 runs under the neutral prompt. That detail helps explain the gap: a system can contain subagents, but it still needs a routing strategy that actually sends work to them.
As incoming activity rose from about 1 to 40 requests per minute, the Router’s batch size grew from 1.0 to 2.8. Per-request latency also rose, moving from 2.5 seconds to 3.9 seconds. The system handled more work in each batch, but heavier traffic still added waiting time.
An ablation test removed direct event pass-through. Router decisions rose about 30%, while cache-read tokens increased about 37%, from 23.23M to 31.77M. Those figures suggest that routing choices and repeated context access can carry a measurable cost as the system manages more events.
All of these figures are self-reported and come from secondary reports of the report, so they describe an early prototype rather than a finished coding product. DeepSeek has not measured real coding quality in these tests.
The release still marks a clear direction for DeepSeek as it competes with OpenAI and Anthropic on coding assistants. The company’s Harness team frames the project around a simple shift: instead of making a person supervise more sessions, let one Router organize authorized work and let isolated Workers handle the tasks.
That approach also fits a broader view of modern agents. A recent study examined 11 coding agents and found that every one used the same 7 parts, with only the size of each part changing. The study’s simple idea was that an agent is a model plus a harness: the model does the thinking, while the harness is the software around it that turns a text generator into a worker people can trust.
Based on
