DeepSeek proposes Super-agent with Router/Worker architecture for autonomous systems

The DeepSeek Harness Team released this week a design document and an open-source prototype aimed at solving an almost invisible bottleneck in the age of AI agents: human attention. The `dsh-superagent-prototype` repository, published under the MIT license on October 31 alongside the paper "Exploring Super-agent Design: Towards More Autonomous Agent Systems" (in Chinese), presents a radically different approach to building assistants that run 24 hours a day, processing multiple tasks simultaneously without requiring a human to switch between windows.

The problem the Super-agent addresses

The core intuition of the document is deceptively simple. Current AI models are good enough to complete a complex task with minimal human intervention. What remains as the bottleneck is no longer model capability, but human capacity. According to DeepSeek itself, an average person can simultaneously track between three and five active agent sessions — and this accounts only for sessions of a single model. When you expand to use a local CLI, an MCP tool and external connectors, each additional task forces the human to remember which window has which context, which task is in what state and when intervention is needed.

The Super-agent proposes turning the agent into a persistent, multi-tasking entity rather than stacking sessions. The system consists of two main layers: a routing layer (Router) that talks to humans and distributes work, and an execution layer (Worker) where isolated sessions process tasks in parallel.

The two-layer architecture

The central idea is to separate responsibilities. The Router is a persistent session that receives messages from any channel — Slack messages, GitHub comments, emails, CI notifications — and decides what should be done. It does no work itself, has no tools like Bash and does not run code. Its function is to understand, decide and delegate.

The Worker layer is where real execution happens. Each Worker is an isolated session that receives a task from the Router, works on it with all available tools (Bash, file editor, repository explorer) and reports results back to the Router. The Worker does not speak directly to the end user — the Router is the single point of external communication.

The design allows a Worker to subscribe directly to conversation threads or pull requests. Once the Router creates a Worker for a bug-fix PR, for instance, subsequent PR comments are delivered directly to the Worker without passing through the Router. The document reports that this reduces cache-reading tokens by 37% and cuts the Router's decision count by roughly 30%.

Event-driven operation and autonomy

The Super-agent operates in an event-driven manner. Any change in the environment — a new comment on an issue, an email about a meeting, a build result — works as a "trigger." The system first filters triggers by programmatic rules (who sent it, which channel, which time) and then the Router decides whether the task deserves attention.

What distinguishes the Super-agent from other "autonomous agent" models is its cautious approach to autonomy. The system has three behavior modes: "off" (only receives commands), "observe" (analyzes automatic events but does not create tasks on its own) and "auto" (can create tasks automatically based on predefined rules). By default, it operates in "observe" mode, which means the system analyzes but does not act — unless a human explicitly requests something.

Still, when running in "auto" mode, the system is capable of identifying bugs in public repositories, opening fixes and submitting pull requests without any human having explicitly asked. The document describes this behavior as one of the most ambitious experiments in the field.

Results and limitations

DeepSeek published preliminary experiments comparing the Super-agent with a conventional "single session plus sub-agent" workflow. In tests using a synthetic workload of 300 messages and approximately 20 work requests, the Super-agent completed tasks significantly faster: median 12.4 minutes and p95 15.7 minutes, compared to 29.5 minutes for the single-session workflow in neutral configuration.

The costs are relevant. The multi-session system consumes more cache-reading tokens — each Worker needs to re-read its own history and the task context. The document itself admits it does not reveal how many more tokens the architecture burns compared to a single-session solution.

Crucially, the prototype released on GitHub is a partial implementation. The README begins with an explicit warning: "Research code for reference, not an official DeepSeek product." Several features described in the article — including the Watchdog (an external process that checks whether Workers are progressing), speculative execution (anticipating tasks and starting work before an explicit request) and separation between cloud and local devices — are not implemented in the current repository. The existing code is a starting point, not a final version.

What this means for the future of agents

The DeepSeek Super-agent represents an interesting moment in the evolution of AI agents: the transition from tools that help humans do one thing at a time to systems that work with an entire team. The Router/Worker architecture is not new in the sense that routers and workers are patterns of distributed systems since the 1990s — what is new is the way they have been adapted for AI agents, with language models replacing much of the routing and decision-making logic.

DeepSeek's approach is particularly interesting because it places the human as the control point, not the executor. The system is designed to run autonomously, but with an emergency exit mechanism that allows a human to interrupt, re-examine or re-orient any task. It is, essentially, a response to a question many developers are asking right now: "what happens when agents are good enough to do the work, but humans are not?"

DeepSeek's answer is clear: you need a system that thinks like a project manager, not a text editor. And this difference in perspective — from tool to entity — might be the most important one in the next wave of AI.

The question that remains is whether the Router/Worker architecture will become the standard for autonomous agent systems, or whether it will be just another academic experiment that never scaled to widespread production use.

Sources: Pandaily, Cocoloop, GitHub

✓ Independent sources cross-checked and verified before publishing