跪拜 Guibai
← All articles
Cloud Native · Agent

DeepSeek's SuperAgent Splits an Agent Into a Full-Time Router and Concurrent Workers — and Alibaba Built Its Own Version

By 阿里云云原生 ·
Read original on juejin.cn ↗ Google Translate ↗ Alt translation

SuperAgent and Flock set a design template for always-on agents that run unattended in production: separate continuity from concurrency, keep a deterministic core around the model, and make tasks outlive sessions. Western teams building long-running agents can adopt these patterns directly instead of rediscovering the same distributed-systems pitfalls.

Summary

DeepSeek's SuperAgent architecture solves the core bottleneck of multi-agent work: a single human can only track three to five active sessions. It introduces a two-layer design where a resident Router owns continuity and global memory, while isolated Worker sessions run tasks concurrently; the Router simply routes and reports, never executing. Event-driven triggers, a Fast Path of rules, and subscription direct-pass keep the model out of most decisions and reduce Router load.

The accompanying prototype code (about 16k lines) reveals concrete engineering decisions: a deterministic core that validates model proposals, an Outbox pattern for reliable side effects, external text treated as untrusted data, and a 30-word cap on Router notes to prevent distortion. Alibaba's Flock goes further, hiding sessions entirely behind a Sessionless model, using a Quest as the persistent task object, and growing DAGs organically as work happens. Both systems converge on the same insight: once the model handles single tasks, the remaining problem is reliable scheduling, persistent state, and human accountability.

Takeaways
— A human can typically follow only 3 to 5 active agent sessions; the ceiling for single tasks is the model, for multiple tasks it's human attention.
— SuperAgent meets four requirements: continuous, efficient, proactive, and persistent.
— The two-layer architecture puts continuity in a Router and concurrency in Workers; the Router doesn't execute work and can run a lighter model.
— Event streams are high-noise, low-trigger; in DSH's synthetic load, only about 20 of 300 messages were work requests.
— Subscription direct-pass (Thread subscription) removes Router involvement for later events, saving about 30% of Router decisions and 37% of read cache tokens, with no change in task completion time.
— Inline and Spill manage context like a cache; Chain of Recall follows references between objects to retrieve old tasks without keeping all history in the window.
— Full-duplex converts long-running commands to async start/stop so the model loop never blocks on a tool; the prototype backgrounds any command exceeding 5 seconds.
— Separation of compute, state, and environment lets tasks survive device offline; state resides in the cloud while local daemons execute commands.
— In experiments, SuperAgent hit P50 of 12.4 minutes vs 20.4 for a neutral single-session prompt, but read 3.8x more cache tokens; a prompt tweak got within 11% of P50 with under half the tokens.
— The prototype uses an Outbox pattern: external actions are recorded as data and executed after commit, so crashes don't lose work.
— Model proposals are validated by a deterministic core; model errors are limited to rejected requests.
— External text (chat, reviews) is always treated as untrusted data; Router notes are capped at 30 words and cannot include implementation plans or acceptance criteria.
— Proactive actions are gray-scaled: new rules start in trial mode, recording what the model would do without executing.
— Human priority includes a reserved concurrency slot, status sorted by who is waiting, and distinguishing 'delivered' from 'read' messages.
— Alibaba's Flock uses Channels as isolated boundaries, a Sessionless model where sessions are consumables, and Quest as the persistent task object with a 'pending acceptance' state.
— Task chains grow organically: each new task defaults to a subtask, dependencies are declared, and the system rejects orphan tasks.
— Proactivity is implemented as state-change wakeups, not a constantly thinking process; mutual wakeups are controlled by separating @ (communication) from Quest (delegation) and capping consecutive wakeups at 3.
— Memory is shifted from pushing context to pulling via file-like interfaces; long messages keep head and tail, folding the middle for retrieval.
— Two trends: agent architectures are converging under constraints, and agents are returning to classic distributed systems engineering (write-ahead logs, Outbox, leases, replayable events).
Conclusions

The Router-Worker split is a direct answer to a fundamental tradeoff: continuity and throughput can't both live in one session, so the design gives each to a different layer.

Centralization in agents doesn't suffer from human bandwidth limits; DSH's stress test shows per-decision latency drops as event rate rises, because batching amortizes reasoning.

The debate between Anthropic and Cognition over multi-agent systems isn't about whether to split, but where the boundary lies: only independently verifiable work should be parallelized.

Agent reliability shifts from model correctness to system recovery; deterministic shells around LLM calls matter more than the model's raw ability.

Alibaba's choice of Channel isolation over a single Resident Router trades continuity for blast-radius control, a deliberate enterprise-oriented tradeoff.

The convergence of SuperAgent and Flock on Ticket/Quest, task chains, and Outbox patterns suggests constraints, not copying, drive agent design.

Concepts & terms
Router
The persistent central component in SuperAgent that handles all human communication, inter-task coordination, and global memory. It never executes work; it routes events and delegates to Workers.
Worker
An isolated execution unit in SuperAgent that handles one task per session. Workers run the strongest model and report results back to the Router.
Thread
A series of events under the same PR or group topic. Workers subscribe to a Thread to receive subsequent events directly, bypassing the Router.
Ticket
A persistent work order in SuperAgent that survives session restarts and executor changes. It represents an approved piece of work.
Mandate
The authorization credential attached to a Ticket, specifying who requested it, the scope, and which rule version. Separating it from the Ticket lets the system revalidate old work against current rules.
Chain of Recall
A method of retrieving old context by following references between objects (Inline/Spill), letting a model expand hop by hop without loading all history into the window.
Inline/Spill
Context management borrowed from compiler optimization: Inline puts likely-needed information in the window; Spill leaves low-frequency or over-budget content outside with only a summary or reference.
Full-duplex
In agent design, the ability to receive and process interrupts asynchronously; long-running commands become async start/stop so the model loop continues and new messages are handled at the next step.
Outbox pattern
A distributed-systems pattern where external actions are recorded as data in the same transaction as state changes, then executed after commit. This ensures exactly-once side effects and crash recovery.
Sessionless
Alibaba's design principle: sessions are just execution consumables, not identity or task containers. The system computes whether to continue a conversation based on context keys, so users never see 'new session'.
Quest
Alibaba's persistent task object, analogous to SuperAgent's Ticket. It has a goal, acceptance criteria, and a single responsible person, and lives longer than any session.
From the discussion
Featured comments
咬代码的兽

I agree with this observation about design convergence. Once the various Agent framework patterns converge, what matters is engineering details and context management. This kind of practice review is updated pretty frequently on ai345, and it's convenient for finding Chinese materials.

See top comments, translated →
Source: juejin.cn ↗ Google Translate ↗ Backup ↗