Research

Inside DeepSeek's Super-Agent Prototype: One Router, Many Workers

DeepSeek's team released an MIT-licensed prototype that splits coding work between a persistent Router and several context-isolated Workers, and says it's a research demo, not a product.

Daniel HarrisDaniel Harris
Heat: 1,900
Inside DeepSeek's Super-Agent Prototype: One Router, Many Workers

DeepSeek's research team published a working prototype that hands coding work to several isolated agents and keeps one coordinator talking to humans. It ships under an MIT license, with a warning label worth reading first.

What DeepSeek Published on October 31

On October 31, DeepSeek's coding agent team put dsh-superagent-prototype on GitHub under the MIT license. Alongside the code, it published an architecture essay called "Exploring Super-agent Design: Towards a More Autonomous Agent System."

The prototype targets one GitHub repository at a time. It's a proactive coding agent, which means it doesn't wait for a chat message before it starts moving. It watches the repo, picks up requests, and comes back with work.

Distribution is the unusual part. It ships as a bundle rather than a standalone app with an installer. That choice tells you who it's for. You don't download a binary and click through a wizard. You point your own coding agent at the setup file and let it walk you through.

The Attention Budget Behind the Router and Worker Split

Most coding agents run as one long conversation. Context grows, instructions stack up, and the agent loses track of which request it's answering. DeepSeek's answer is to stop pretending one session can hold everything.

The design has two layers. A persistent Router handles the human side. It holds the global context, takes requests, and decides what work needs doing. It doesn't write the code. Below it, Worker sessions run in parallel, each with its own session and its own directory.

Why bother? Attention is the scarce resource. The team's phrasing on the repository page is that the system should take up as little of a person's attention as possible while producing as much value as it can. A single sprawling session spends your attention on progress reports. A router spends it on decisions.

That's the whole bet. A better division of labor, not a bigger model.

Context isolation does the rest of the work. When one Worker goes down a bad path, the damage stays inside that session and that directory. Nothing leaks into the next work item, and two jobs can run at the same time without arguing over the same files.

How a Single Request Travels Through the Prototype

The flow starts with a GitHub event. Someone with permission asks for something, and the Router turns that into a work item. Feishu integration is optional, for teams that live in chat rather than in issue trackers.

From there, a Worker opens its own session and does the job. When it finishes, it returns to the original conversation and answers there. Usually the answer is a pull request.

Workers aren't sealed off after that first reply. They can subscribe to later comments on their pull request, so a review note doesn't restart the whole process from zero. That one detail is what separates a demo from something a team can use. Code review is a conversation, and an agent that can't hear the second message is only useful once.

A web panel shows which items need a person to step in. That's the queue of decisions, kept separate from the queue of work.

The handoff matters more than any feature on the list. The Router keeps the thread of the conversation. The Worker keeps the thread of the code. Neither one has to hold both.

Where the Workers Are Allowed to Act

A system that can act for a whole team can also waste a whole team's attention. DeepSeek handles that in the rules, not just the architecture.

The stated policy is narrow. The agent acts only when it's asked, or when rules the team wrote for itself allow it. It speaks up only when a human has to handle something, or when the result is something someone can actually use.

Read that second condition again. "Someone can actually use it" is a higher bar than "the task finished." A merged pull request that nobody asked for is still noise.

The Disclaimer at the Top of the README

This part is easy to skip and shouldn't be. The README says the repository is a research prototype, provided for reference only. It's not an official DeepSeek product. It's not production-grade software. It may contain bugs, and the code style and engineering practices may be inconsistent.

It goes further. The code was adapted for public release, and it differs in detail from both the internal version and the implementation described in the architecture essay. Some designs in that essay are future directions the prototype doesn't implement.

So the essay describes a target, not a shipping product. Treat the two as related documents, not as one specification. Anyone quoting the architecture article as a description of the code is quoting a plan.

How the Community Read It

Discussion took off within a day of the release, across Chinese and English AI circles. The common reading was that this is an architectural answer to closed coding agents like Claude Code and Codex.

That reading is reasonable, and it's still an interpretation. DeepSeek doesn't frame the release as a competitor in the README, and the prototype ships without benchmarks or a comparison table. Star counts have been quoted at wildly different numbers, so we're not using any of them here.

What's actually on offer is a set of opinions about structure: a persistent router, isolated workers, and human attention treated as the budget line.

Installing It Is a Conversation With Your Own Agent

Setup is deliberately low-tech. The repo includes a SETUP.md and nine numbered documents, from 000 to 008. They cover philosophy, the domain model, authorization, execution, prompts, the panel, deployment, architecture, and a cookbook for adding new Sources.

Your own coding agent reads SETUP.md and walks you through it. It asks one short question at a time and ends with a full plan. No config file to hand-edit, no environment variables to guess.

That approach fits the project's premise. If the agent is supposed to manage attention well, the install is the first test of whether it can.

What to Watch Before You Clone It

The honest answer to "can I use this" is that you can run it, and you should expect prototype behavior. Missing pieces and rough edges are disclosed up front, which is more than most research repos bother to do.

Try it on a repository where a bad pull request costs you nothing. Watch how often the Router interrupts you, and how often a Worker asks a question it could have answered itself. Those two numbers tell you more about the attention budget idea than any architecture diagram.

Share This Story

Sources

Related AI News

Concentric spiral curves crossed by a vertical line with bright points pinned along it
Research

An Anthropic Researcher Says Claude Proved the Riemann Hypothesis. Stanford Answered Within Hours

A researcher says he and Claude produced a proof of the hardest problem in mathematics, and the code compiles. Verification is a different job, and it has barely started.

Heat: 1,860
A stack of agent nodes linked by a path to a server rack, with a keyhole and a breach mark on the rack
Research

An AI Agent Found a Zero-Day and Owned a University Server in 11 Minutes

An operator gave the agents one goal and no method. They found an undocumented flaw in medical imaging software and owned the server, after 148 failed actions somewhere else.

Heat: 1,520
A funnel carrying small token blocks from one model box to another, with a shield plate blocking part of the flow
Research

OpenAI Cut Reasoning Theft From 54% to 0.2%. The Rest Is an Industry Problem.

OpenAI published the before-and-after numbers for its latest safeguards and they look like a fix. The same post explains why the fix has to be repeated every week, by everyone.

Heat: 1,420
A green chip grid with one highlighted cell and a jagged signal line beside the words Blackwell fingerprints
Research

Blackwell fingerprints in six Chinese models: what a checkpoint can prove

Dek: PyTorch fills billions of empty weights with random numbers, and the GPU doing the filling leaves a mark in the finished file. Someone checked six Chinese checkpoints and found newer silicon than the rules allow.

Heat: 1,250