Back to storiesEngineering

What is new in DeepSeek Super-agent? Routing, workers, and ongoing work

Understand DeepSeek's two-layer agent design, event subscriptions, context recall, and recovery. Compare its focus with Claude Code, Codex, and LangGraph, and read the preliminary experiments in context.

12 min readMarkdown
On this page9 sections

When agents can work alone, why does coordination still take so much time?

A bug starts in chat, becomes an issue, produces a CI failure, and gets new instructions in a pull request. Each fresh agent session can do useful work. You still have to remember which conversations concern the same problem, who has taken ownership, and which new instruction changes the task.

The most interesting change in DeepSeek Super-agent is moving session management into the system, so people can interact around ongoing work. A resident Router maintains continuity, independent Workers execute tasks concurrently, and event subscriptions, asynchronous interaction, and recovery connect the pieces.

This is an exploration of agent execution architecture. It does not introduce new model weights or a neural network structure. The official design article, published October 31, describes a broader system direction. The public prototype implements part of it for one GitHub repository, optionally connected to Feishu, as a DeepSeek Harness bundle. The repository explicitly calls it research code rather than an official DeepSeek product. Its design, implementation, and experimental evidence need to be read separately.

Two layers separate ongoing interaction from execution

Putting every message in one session preserves continuity, but a long task can occupy the execution loop, and unrelated implementation details compete for context. Creating a new session for every message increases concurrency, but three sessions might fix the same bug and independently report to the same chat.

Super-agent divides these responsibilities. The Router handles people, task relationships, and dispatch; a Worker completes a particular piece of work. The design recommends keeping concrete execution out of the Router, potentially omitting its Bash tool, so builds and long commands do not occupy the coordinator. Workers have execution tools and separate contexts. A complex Worker task may itself use subagents or an agent team.

That explains the difference in emphasis from a typical agent team. Teams often divide one complex assignment, with a lead deeply coordinating coupled steps. Super-agent primarily coordinates multiple ongoing assignments, leaving each Worker's internal decomposition to that Worker. The authors acknowledge that a team lead restricted to interaction and dispatch could also count as this two-layer design. Actual responsibilities and message paths matter more than the name.

Events pass a permission check into a Router, which assigns two Workers. Results and questions return to coordination, with ticket, session, and directory state retained below.
An original simplified illustration of new-task intake and coordination. Follow-up events on subscribed threads can go directly to Workers; the state layer does not imply shared code directories.

Direct event delivery does much of the coordination work

A Trigger is an environmental event: a chat message, review comment, or CI result. A Thread groups related events, such as discussion on one pull request. A Worker subscribes to threads it needs to keep following.

The Router decides where new work belongs. Once ownership is known, code sends subsequent events on that thread directly to subscribed Workers, avoiding another Router inference and forwarding tool call. Subscriptions are many-to-many: a Worker can follow both a chat discussion and a PR, while one PR can notify several relevant Workers. The Router retains global observation and cross-task coordination.

The public prototype also distinguishes a relationship from a delivery rule. Correlation supplies contextual links; Subscription controls delivery fan-out. Two events mentioning a search box do not necessarily describe the same defect, and neither needs to reach every Worker. See the domain model and intake implementation.

Persistent chat intake creates substantial noise. A deterministic first stage checks sources, identities, and permitted scope. A model then assesses semantic candidates against written rules. The prototype defaults proactive intake to observe, recording what it would accept; auto enables execution. Direct delivery to an existing subscription does not grant new authority. These distinctions appear in the authorization design.

Continuity does not require putting all history in the prompt

The Router needs task relationships without carrying every historical log. The design uses Inline & Spill: likely useful summaries, nearby messages, and related object IDs enter the context directly; long material stays outside, with an entry point for further reading.

Chain of Recall follows those references. A current message leads to its thread, its Worker, and a related review thread. The model can expand relevant history incrementally while limiting each input. Missing links, incomplete summaries, or a poor retrieval choice can still hide important background. The authors identify memory across months as an open problem.

In the public implementation, SQLite retains tickets, events, mandates, decisions, and pending deliveries, while Harness preserves session history. This supports recovery and traceability. It does not establish automatic learning from past work or a new general long-term memory algorithm. Durable work state, historical retrieval, and learning reusable experience require different evidence.

The broader design adds asynchronous tools, separate environments, and a Watchdog

The article replaces a long synchronous run() with asynchronous start() / stop(): starting returns immediately, and completion arrives as another event. People can add or change instructions while work runs in the background. The authors say this exists in Harness but is not enabled by default. New input is handled after the current inference step; this is not instantaneous interruption of any operation.

A second design separates the agent loop, persistent state, and execution environment. The loop can run in the cloud, state lives in a database, and a lightweight daemon executes commands on the actual development machine. Work requiring an intermittently connected machine can continue when it returns. An external Watchdog checks infrastructure failures and whether tasks are making meaningful progress, then intervenes when needed.

Together these explain the always-online goal. They should not all be presented as ready-made features of the public prototype. Its README says the publication version differs from both the internal implementation and the article, with some designs still unimplemented. Recovering a local process does not mean it continues while its host computer is off.

Where is it stronger? The experiments support scheduling benefits

Section 7 of the official article reports preliminary experiments using synthetic message streams: about 300 messages per run, roughly 20 work requests, and five runs per configuration. A tool that only consumes time replaces coding. Message intervals and work durations are scaled to one quarter, while model calls take real time. The experiment therefore primarily measures scheduling and coordination.

Reported observationWhat it supportsWhat it does not establish
Super-agent completion p50 was 12.4 minutes and p95 15.7 minutes; a neutral-prompt single session with a subagent tool had p95 of 29.5 minutesFixed responsibilities reduced a long tail caused by main-session execution and repeated incoming-message interruptions in this workloadReal bug fixes are twice as fast, or it beats every multi-agent product
Removing direct delivery left completion times similar; Router decisions rose about 30%, and cache-read tokens rose from 23.23 million to 31.77 million, about 37%Direct delivery primarily reduced routing overhead in this workloadDirect delivery necessarily improves code quality or completion time
In a separate Router stress test, arrivals rose from about 1 to 40 per minute, average batches from 1.0 to 2.8, and request duration from 2.5 to 3.9 secondsBatching can amortize inference overhead within a rangeOne Router never becomes a bottleneck at any scale

There is an important trade-off: the authors report higher cache-read token consumption for Super-agent's independent sessions than for a single session, in exchange for shorter and more stable completion times. Saving routing overhead compared with its own no-direct-delivery variant is a different claim from costing less overall than a single session. Cache-read tokens alone also do not measure total charges for inputs, outputs, tools, and runtime.

My assessment is that its strongest opportunity is reducing the human work of moving context, identifying ownership, and chasing status. Whether that improves a real project depends on Worker capability, false intake, verification quality, and operating costs.

How does it compare with Claude Code, Codex, and LangGraph?

These are different layers: a research system, coding products, and a framework. The table compares design emphasis, rather than ranking finished products or reporting a controlled benchmark.

ApproachExisting capabilities and emphasisThe question raised by Super-agent
Claude Code subagents / Agent TeamsSeparate task contexts and background concurrency; Teams is experimentalWho continuously identifies, delivers, and responds to follow-up events across independent tasks?
Codex GitHub and scheduled tasksPR-comment review, enabled automatic review, and scheduled triggers already provide event-driven entry pointsHow does one assignment remain continuous across entry points, and which host must stay online?
LangGraphGraphs, conditional edges, dynamic Workers, checkpoints, threads, and interruptsHow will developers implement channel routing, authorization, idempotent effects, and the task interface?
Super-agent design and prototypeResident Router, Workers, thread subscriptions, and durable work stateCan it accept the right work, keep progressing, and recover while demanding less human attention?

Ordinary Claude Code subagents can run in the background alongside the main conversation; saying all subagent work blocks the main session would be inaccurate. Agent Teams is experimental and disabled by default. Super-agent's distinction should be assessed through ongoing coordination across tasks.

Codex GitHub demonstrates that event-triggered agent work predates this design. Local project automations still depend on the host and app being online; automation does not by itself imply cloud execution.

LangGraph provides building blocks for related systems, which still need concrete product workflows. Checkpoints and interrupt/resume do not automatically make external writes happen exactly once. Nodes can rerun after recovery; sending messages and creating PRs require idempotent effect design.

Follow one search-race bug through an ongoing assignment

This is a fictional design case, not a run performed in any of these products. At 9:00, chat reports that typing “cat” produces results for “c.” At 9:01, an issue adds that clearing the input still allows an old request to write back. At 9:02, CI fails in the same module. At 9:03, a developer says they have taken ownership.

A useful system first checks whether these reports share a cause, delivers relevant chat, issue, and CI information to the appropriate work, and respects existing ownership. The CI failure might be unrelated. Matching filenames are insufficient reason to combine tasks, and another developer taking over should prevent duplicate edits.

If the team authorized read-only reproduction, the Worker can inspect stale success, stale error, loading state, and invalidation after clearing. Editing needs the relevant authority. A useful delivery contains reproduction conditions, a diff, actual validation, and unresolved questions. Messaging the team, pushing, merging, and deploying each depend on the granted scope. Our reproduce-before-fixing guide develops the defect checks.

After restarting, the system also needs to inspect the actual directory, Git, and GitHub state rather than create the same PR again because a record says “unfinished.” The prototype's delivery layer reuses a request ID and retains pending delivery state to reduce duplicate session inputs. That is not a universal exactly-once guarantee for every external operation.

Evaluate this case through false triggers, duplicate edits, human intervention minutes, elapsed time from report to acceptance, actual total cost, and final behavior. Counting concurrent Workers cannot establish that the architecture helped the team.

How new is the architecture, and who should use the idea?

The authors conclude that they have not proposed an entirely new theory, but applied classic computer-systems ideas to agent construction. Routing and orchestrator-workers also appear in Anthropic's 2024 Building effective agents.

It is reasonable to call this an architectural exploration for ongoing agent collaboration. Its value lies in the particular combination of responsibilities, event paths, context organization, and recovery. The useful change in product expectations is concrete: people provide a continuing goal and authority; the system maintains the relationships and returns when a decision or acceptance is needed.

The research prototype still has important boundaries. Its deployment documentation describes execution as the operator's OS identity, with Router and Workers using danger-full-access. Separate directories are not an OS sandbox. Policy changes do not immediately revoke in-flight tickets. Prompt rules for automatic merging need external enforcement such as GitHub branch protection; model compliance is different from technically isolated permissions.

For a small bug in the current conversation, an ordinary coding agent with suitable verification is usually more direct. For independent subtasks, first split by context boundaries. When the actual problem is a continuous message stream, follow-up across entry points, and unattended task state, Super-agent offers a more targeted design. Start with one repository, limited sources, and observation mode to evaluate intake before expanding automatic execution.