DeepSeek's SuperAgent Splits an Agent Into a Full-Time Router and Concurrent Workers — and Alibaba Built Its Own Version
About DeepSeek's SuperAgent, and Our Practice
Author: Alibaba Cloud Native
By Zheng Tian
This article is excerpted from the Alibaba Cloud AI Agent Handbook, project address: https://github.com/aliyun/ai-agent-handbook
Alibaba Cloud AgentCore now supports DeepSeek Harness deployment, accelerating enterprise production validation.
After DeepSeek released SuperAgent, the industry consensus is that agent design has largely converged. For us too. Besides introducing DeepSeek SuperAgent's design, this article focuses on our technical and productization exploration similar to SuperAgent.
What Problem DeepSeek Wants to Solve
Consider an afternoon many developers have experienced. You use an agent to do three things at once: fix bugs, write a proposal, and run data. Here are two ways that afternoon can go:
Figure 1 · Two ways the same afternoon can go
The problem on the left is not that agents are weak; each agent in its own window does fine. The problem is that scheduling falls on the human: who is waiting for you, which message relates to which task, where a decision was made—all of it depends on your memory. The DSH team observed that a person can usually follow only 3 to 5 active sessions at a time. Their summary is precise: the ceiling for a single task is the model; the ceiling for multiple tasks is human attention.
So SuperAgent's goal can be summed up in one sentence: make it feel like there is always just one agent, and it can do many things at once. To do this, it must satisfy four requirements:
- Continuous: If you say "use plan A" in a group chat and later change to "plan B" in a code review, it can follow up. You don't have to think about "which session has this information."
- Efficient: You don't have to wait for the previous task to finish before starting the next one.
- Proactive: It watches what happens in the environment, advances when it's worth doing, and stays quiet when it's not necessary.
- Persistent: It stays online always, recovers from problems on its own, and doesn't stop because you closed your laptop.
The DSH team gave an internal example where no one @-mentioned it in the group, and it discovered a problem and submitted a fix on its own:
Figure 2 · No one @-mentioned it, SuperAgent proactively located the root cause and submitted a fix (source: DSH original)
Where Exactly Do Humans Become the Bottleneck?
Many people first reading SuperAgent misunderstand it as "an agent distributing tasks to multiple agents." Distribution is only a means. What it truly aims to do is increase agent autonomy and free humans from bottlenecks at every stage. Humans block agents in more than one place; the four characteristics correspond to four bottlenecks:
Figure 3 · The four human bottlenecks and SuperAgent's corresponding design (personal summary)
What the Industry Did Before DeepSeek SuperAgent
These bottlenecks aren't discovered only by DSH; everyone had partially addressed them before. Cursor's Background Agents put tasks in the cloud so you don't have to watch constantly, but initiation and scheduling still involve humans:
Figure 4 · Cursor Background Agents (source: madewithlove test [1], 2025)
LangChain's Ambient Agents [2] addresses "needs human initiation": event-driven agents, with humans only handling requests in an inbox. This September's wave of Personal Agents, like Muse, dots, Grok Bot, address "needs human online": close the app, work continues.
| Approach | Representative | Problem Solved | Session | Limitation |
|---|---|---|---|---|
| Background Agent Panel | Cursor | Needs human watching | Becomes task list | Initiation and scheduling still human |
| Event-driven Agent | LangChain Ambient Agents | Needs human initiation | Hidden behind events and inbox | Multi-task coordination requires self-building |
| Resident Personal Agent | Muse, dots, Grok Bot | Needs human online | Hidden behind main chat or bot | Personal, not team accountability |
| Router + Worker | DSH SuperAgent | Solves the above | Becomes implementation detail | Long-term memory, organizational boundaries, security |
Principle: Turn One Agent into a Small Team
The DSH original has six modules; some descriptions are convoluted, but essentially simple. We'll give a simplified version later.
SuperAgent original architecture
Think of it as a small team: the resident Router is like a front desk, receiving all new things and deciding who to hand to; Workers are specialists, each doing their own. The front desk doesn't do concrete work; specialists don't talk directly to customers. Events in the environment are called Triggers, which pass through a filter before entering, to decide who responds.
The whole design can be simplified: of the things happening in the real world, which need agent attention, what kind of agent needs to pay attention, and then find a balance point between a huge stream of events and limited context: from rules, LLMs, to routing agents.
Figure 5 · Simplified SuperAgent architecture
Now analyze each part's purpose and why it's designed this way.
2.1 Two-Layer Architecture: Why Router and Worker
When designing agent systems, there's an unavoidable contradiction: continuity vs. throughput. Putting everything in one session gives the most continuity, but a single ReAct loop is serial, everything queues, and tasks interrupt each other. Opening a new session for each task allows concurrency, but tasks don't know what others are doing, and each talks to you separately.
Figure 6 · Continuity and throughput force a choice, so split into two layers to solve separately
The solution is to separate them: the Router handles continuity—all human communication and inter-task coordination passes through it, it's the global ordering point and memory. Workers handle concurrency—each task gets an isolated session. To keep the Router unblocked, it doesn't execute concrete work; DSH can even skip giving it Bash, often a lighter model suffices. Workers get the strongest model; reasoning and tool calls stay in their own sessions, and when there's a conclusion, they report to the Router, which replies externally.
Here's a passage from the original to help understanding: A common question is: What's the difference from a Team Lead in an Agent Team? A Team Lead dives into a task to decompose it, while the Router only manages relationships between tasks. If a Worker wants to use Subagents or a Team internally, that's transparent to the Router. A key sentence in the original: if you use prompts to constrain the Team's main session from doing work itself, "it can also be seen as this two-layer architecture." So the two-layer architecture is about division of responsibilities, not a specific component.
2.2 Event-Driven: Too Many Messages, Most Don't Need the Model
To remove the "needs human initiation" bottleneck, the agent must be woken by the environment. The drive is no longer human-typed commands but triggers like group messages, code reviews, CI results. But once connected to the real environment, event streams are "high noise, low trigger rate"; asking the model every time would be slow and expensive.
DeepSeek SuperAgent splits into a Fast Path for simple cases and a Slow Path for rare complex ones. Sounds complex, actually simple. The Slow Path is the model; the Fast Path is rules. Rules include, for example, certain group messages the agent monitors closely, or certain users' speech (like product managers or bosses' requirements 🤣). In DSH's experimental load, about 300 messages contain only about 20 work requests:
Figure 7 · Model placed at the end of the funnel. 300 and 20 come from DSH experimental load, synthetic data
The cleverest part is routing. A series of events under the same PR or group topic is called a Thread. Once a Worker takes a task, it subscribes to this Thread; subsequent events go directly to it without passing through the Router. This is called subscription direct-pass. Workers and Threads are many-to-many; two Workers subscribing to the same PR can see each other's actions, answering "won't Workers conflict if they don't communicate?"
DeepSeek also ran ablation experiments showing the value of direct-pass: removing it barely changes task completion time, but the Router makes about 30% more decisions and reads about 37% more cached tokens. That is, it saves Router load, not task time.
2.3 Context Organization: Inline, Spill, and Chain of Recall
Once events enter a session, the next question is how much to put into the context window. Too much squeezes the window and dilutes model attention; too little makes the model repeatedly call tools, increasing steps. DSH treats the window as a cache, using two terms from compiler optimization: Inline puts information likely needed soon directly into the window, saving a tool call. Spill keeps content that exceeds budget or is low-frequency outside the window, leaving only a summary or reference. What goes in is determined by locality—for example, adjacent messages around an IM message, or adjacent comments in a code review discussion.
Applying this rule consistently to Triggers, Threads, Worker Sessions forms a reference graph: each object inlines the ID of the next-hop object. The model can start from the current event and expand hop by hop along references. This is Chain of Recall. The Router doesn't need all history in the window to retrieve old tasks when someone mentions them:
Figure 8 · Example of Chain of Recall (schematic)
The original also admits its limits: this mainly solves recent tasks; across months, long-term memory remains a bottleneck.
2.4 Full-Duplex: Is It the Same as Codex Interruptions?
Codex users might ask: is full-duplex just interrupting at runtime? Related, but not exactly the same. Interruption solves "can a message come in"; full-duplex also solves "how long until a message is processed."
Codex's steer can inject a message into an ongoing turn, seen by the model at the next reasoning step; DSH's docs also use the word steer. But the model loop is "reason, call tool, wait for result, reason again." If currently waiting for a synchronous tool, the next reasoning step waits for its return. So with only interruption, saying "stop" might wait 20 minutes for tests to finish.
Figure 9 · The difference between three modes is when "stop" is seen by the model (schematic)
The original's "full-duplex" targets this blocking. It turns long-running commands and subtasks into async start and stop: the call immediately returns "started", the loop continues; the tool runs in the background, results come back as a new event; the model can also proactively stop. Thus reasoning steps stay short, and new messages are processed after the current step ends. The model still runs step by step, not doing two things simultaneously.
The prototype's landing is direct: Worker foreground commands exceeding 5 seconds automatically move to background, documented reason being to receive new messages at the next step.
2.5 Separation of Compute, State, and Environment: An Example
Local agents bind the compute (Agent Loop) that advances a task, session state, and the real working environment to one computer. Look at a specific scenario to see the difference when separated:
Figure 10 · Same task spanning a weekend (scenario illustration; intermittently online device handling from original)
This example has two layers of decoupling. First, compute and state separated: Agent Loop goes in a cloud stateless container, Session stored in a database; restarting or replacing the container doesn't affect progress. Second, compute and environment separated: your local machine has uncommitted changes, private credentials, internal dependencies; rebuilding in the cloud is costly and error-prone. Since the environment itself is hard to sync, keep it in place, and install only a lightweight daemon that doesn't save session state, responsible for executing commands and returning results. After the device comes back online, the cloud agent continues the parts that need to run on that device. This is also the general BYOM (Bring Your Own Machine) solution. In short, rather than rebuilding the environment, dispatch operations that require local-machine interaction down to the local machine to keep the overall environment lightweight. (The cost is dependence on device online. When the local machine is offline, the step needing it pauses until it reconnects; progress isn't lost because state is in the cloud. Cursor Background Agents, Codex cloud tasks go the other way: rebuild environment in the cloud. Benefits are not depending on your computer, parallelism, isolation; cost is the replication overhead. The two approaches trade off different things, no absolute good or bad.)
Figure 11 · Anthropic's "brain-hand separation" same idea: Session, Harness, Sandbox as separate interfaces. DSH's difference is prioritizing intermittently online personal machines (source: Anthropic Engineering [3])
There's an easily overlooked problem: Agent failures often aren't process crashes; the process runs fine, but the model spins in place. Liveness probes can't detect this. So DSH puts an independent Watchdog session outside the system, periodically judging whether each Worker has real progress and whether direction has drifted.
2.6 How to Read the Experimental Results
The most eye-catching number in the original is "nearly twice as fast," but the full table should be read this way. P50 is the median completion time, P95 is nearly all completion time, reflecting the slowest tasks.
| Approach | P50 (min) | P95 (min) | Read Cache Tokens |
|---|---|---|---|
| SuperAgent | 12.4 | 15.7 | 23.23M (3.8x) |
| Single session, prompt asks prioritize delegation | 13.8 | 29.0 | 10.82M (1.8x) |
| Single session, neutral prompt | 20.4 | 29.5 | 6.05M (baseline) |
Only changing one prompt line, half the tasks finish only 11% slower than SuperAgent, with less than half the tokens. What does the architecture buy? It buys stability: the model will sometimes judge "this task is tiny, I'll do it myself," and that one time drags the slowest task to 29 minutes, randomness that prompts can't eliminate. The cost is doubling token usage. Also, this is a synthetic load; coding tasks are replaced with a time-consuming tool, so it measures scheduling, not that real teams will be this much faster.
SuperAgent Code Implementation Analysis
DSH also open-sourced a prototype [4], about 16k lines. Here's a deep source-level analysis:
3.1 Know the Concepts First
The prototype organizes around several objects. They correspond to plain real-world questions:
Figure 12 · Prototype core concepts and relationships
- Trigger and Thread: What happens in the world, which belong to the same thing.
- Ticket: A work order that is approved to start. It's the most stable thing in the system; sessions can break, executors can change, the Ticket remains.
- Policy: Team rules, e.g., who can initiate work, under what circumstances proactive actions are allowed. Rules change, so they have versions.
- Mandate: The credential for "why this Ticket can be done," specifying who requested it, scope, and which rule version.
Why separate Ticket and Mandate? Imagine: a fix is merged, the Ticket ends. A week later someone says under that PR "there's still a problem." What should the system do? Re-evaluating is slow; directly starting work might exceed authority. With a separate Mandate, handle it this way: resume work using the old Mandate, but first check against the latest rules whether the Mandate is still valid. Whether a piece of work can continue and its current status are two questions.
3.2 How a Message Becomes a Work Order
With these concepts, trace a message's full journey into the system:
Figure 13 · From entry to work. The whole chain has only one model call
The first step is "entry registration": regardless of usefulness, the message is persisted to the database, and duplicates are counted once. So after a system restart, messages aren't replayed, and you can later query "where did this message go." This is the classic Append-Only approach in engineering design. Second step: determine owner. If a person's subsequent messages fall on a Thread that a Ticket is following, that Ticket is its owner, and it goes directly to the corresponding Worker for judgment; the Router doesn't intervene. Third step is the gate: code determines if the sender is qualified. Only the fourth step uses the model. Fifth step, when creating a work order, the Ticket, Mandate, subscription, and confirmation reply are generated in one go, avoiding the intermediate state of "order created but no one knows."
3.3 Code Design Decision One: Model Proposes, Program Disposes
This is the most core architectural decision in the whole prototype. There's a deterministic core that is the only writer of Ticket state. The Router model "accepting a work order" is essentially submitting a request; the core validates permissions, rules, parameters, and current state, rejecting if not qualified.
Figure 14 · Model provides flexibility, program provides reliability
The benefit: if the model errs or is injected, the worst case is a rejected request. This aligns with the experimental conclusion in section 2: since the model can "think this task is tiny," don't rely on its self-restraint. So the Router not doing work isn't just in prompts; operations like long waits are rejected at the code level.
3.4 Code Design Decision Two: Record First, Then Act
A long-running system's biggest fear is crashing mid-execution. For example, state already changed to "accepted," but the confirmation message hasn't been sent; after restart, unclear whether to send again. The prototype treats external actions as data too, recording them in the same transaction as state changes, then executing them one by one in the background after commit:
Figure 15 · External actions first enter the ledger, execute after commit. After crash restart, unfinished ones continue
In distributed systems this is called the Outbox pattern; not new, classic engineering. DeepSeek uses it thoroughly: starting Workers, delivering messages, sending IM all go through this path. Model work can't be fully replayed, so after restart, a Worker receives a prompt to first check the code directory and PR's actual state before deciding whether to redo.
3.5 Code Design Decision Three: External Text Is Always Data
SuperAgent spends all day reading group chats and comments, which may contain malicious instructions. The prototype explicitly defines priority; the defense line is in this diagram:
Figure 16 · Above always overrides below; external text is at the bottom
There's an easily missed detail: when the Router transfers a task, the note is at most 30 words, and it's forbidden to add implementation plans and acceptance criteria; the Worker must read the original message itself. This guards against "telephone game" distortion, just like human teams: the more relayed, the more distorted.
3.6 Code Design Decision Four: Proactive Ability Must Be Gray-Scale
Proactivity is the most likely capability to go wrong; an agent that randomly opens PRs will be turned off quickly. The prototype separates "judgment" from "execution": new rules default to trial mode, the model judges as usual, but only records "if allowed, I'd take this order," without actually starting. The team sees records and, if judgment is accurate, enables execution. Also, judgment must give conclusions per rule, and accepting orders must quote the original message as evidence. This is like gray-release, a notable design in the current prototype.
3.7 Code Design Decision Five: Humans Have Highest Priority
DSH says to save human attention; the code has three concrete points:
- Status is computed by "who we're waiting for," with human-waiting tasks prioritized, so you can see at a glance who's blocking.
- Keep one concurrency slot for humans: when all Workers are busy, a human message can still wake existing work; new tasks can't crowd out a human.
- Distinguish "delivered" from "read": a message entering a Worker's session doesn't count; only entering the model's history counts. If a human message is unread when the Ticket ends, it's returned for re-evaluation. If a human says at the last second "wait, don't merge, plan changed," the agent must handle it correctly. The Router may reopen the task, create a new Ticket, or reply directly.
3.8 Current SuperAgent Prototype Boundaries
It also has obvious simplifications. State is in a single-machine database; one deployment corresponds to one repository and one set of accounts; Workers run with the operator's system identity, docs explicitly say command wrappers aren't a security boundary; Watchdog and speculative execution mentioned in the article aren't found in the prototype's code, docs, or prompts. And completion relies mainly on external facts like PR merged; natural for development, insufficient for business work. These are exactly what we need to fill.
My Thoughts: Starting from Digital Employees
4.1 The Word "Digital Employee" Is Overused
Many products call themselves digital employees these days, but open them and mostly it's a chat box plus a knowledge base plus a few tools. You ask, it answers, close the window and it's done, next time you explain the background again. These are useful, but calling them employees isn't quite right.
Figure 17 · My four-level classification of "digital employee" (personal view)
I judge whether something is a digital employee by four questions:
- Do you need to re-explain the background every time? A real colleague doesn't, so it can't have the concept of "new session."
- Does it keep working after you leave? Even with one task, it must continue persistently, wait for others, and pick up.
- Does it move when no one urges? Upstream finished, CI failed, time is up; it must be wakeable by these events.
- When it errs, can you trace who and why? In enterprises, an employee without accountability and audit is unusable.
So a real digital employee should be Always-on by form. SuperAgent is heading this direction. Its "continuous, efficient, proactive, persistent" is another way of saying the basics of a good colleague. Next, my views on its technical choices.
4.2 Router Isn't Mandatory; Can Be Replaced by Coordinator
Readers easily focus on the Router component. But split it apart: it packages three jobs—front-end human interaction, routing judgment, global memory. These three don't have to live in the same resident session; the original itself says Router's "partial logic may not need to call the LLM."
Figure 18 · We assigned the same three jobs to different things
Our approach: the front-end is the Channel itself; humans and agents see the same timeline. Who should be awakened is computed by program based on task state. The part needing judgment goes to a Coordinator, an ordinary member of the Channel, with clear responsibilities, "doesn't directly execute business operations, but decomposes, assigns, tracks, and summarizes." Memory is placed in Quest and files.
This trade-off has gains and losses. Gains: the Coordinator needn't be resident, context doesn't expand infinitely, awakened on demand and done, clearer permission boundaries. Losses: the continuity of a resident Router and the batch processing benefit of "accumulated events processed in the next round." We currently wake once per execution, which is what we need to learn from DSH.
4.3 The Design Origin of Centralized Router: Agent Bandwidth Differs from Humans
People with organizational management experience are naturally wary of centralization: everything goes to one person, that person gets overwhelmed. That conclusion is correct, but its premise is human bandwidth is narrow. A manager can't follow many things, so human organizations layer, compressing information level by level.
Figure 19 · Same centralization, different cost structure. Right numbers from DSH Router stress test
Agents don't have this constraint. They read fast, don't get tired, and don't need meetings to sync. DSH's stress test has a counter-intuitive result: as events per minute rise from 1 to 40, average reasoning time per decision drops from 6.4s to 1.6s. Because events queued while the Router thinks get processed in a batch in the next round. Humans' decision quality degrades under load; models within a range become cheaper due to batching.
Figure 20 · Router batch stress test: more events, cheaper per decision (source: DSH original)
Takeaway: Don't directly transplant human organizational forms onto agents. Hierarchies, weekly meetings, bottom-up reporting—all invented to fit human bandwidth. Many multi-agent systems design roles after corporate structures, possibly learning the wrong lesson. Centralization is a bottleneck for humans; for agents, it might be the simplest, most effective structure.
4.4 But Bottlenecks Remain, Just Moved
Of course, that doesn't mean centralization has no problems. That stress test used fake models for Workers and only up to 40 events/min; can't extrapolate to any scale. I think centralization has at least four bottlenecks:
| Bottleneck | Why | DSH Mitigation | Our Mitigation |
|---|---|---|---|
| Context capacity | Everything passes through it; window eventually full | Later events direct-pass to Workers; Chain of Recall; admits cross-month is bottleneck | Coordinator not resident, split by Channel, query on demand |
| Judgment quality | Handling many things in one round, errors have wide impact | Only when message explicitly points to a Ticket does it get assigned; @ counts as communication, formal Ticket for delegation | |
| Cost | Must re-read large context each time | Accepts 3.8x read cache tokens | Only call model when needed, but not yet merged wakeups |
| Blast radius | All events and permissions converge; if injected, affects globally | External text treated as data, permissions enforced by code | Isolate by Channel; cross-Channel needs mutual authorization |
DSH also says: finer cuts yield higher throughput but lower continuity; "until the global memory problem is solved, this trade-off always exists." We configure Coordinators per Channel, effectively sharding from the start by business boundary; the cost is users must know which Channel to go. Neither choice is perfect; in enterprises, I'd rather have boundaries first.
4.5 The Center Should Care Only About Results, Not How
This is the point I agree with most, and where DSH and we independently arrived. Once the center starts caring about "how," it must read details and plan, instantly degrading into a heavy Team Lead, and the bottleneck returns. For the center to stay thin, it must only look at results.
Figure 21 · Coordinator gives a contract; middle is executor black box; center only re-enters when results return
In our collaboration space, a task only defines the goal, acceptance criteria, responsible person, and dependencies; there's no "implementation plan." The Agent receiving the task decides how: read materials, use subagents, run workflows, even split off parts to others; the Coordinator doesn't need to oversee. After decomposing, the Coordinator can end its round without polling; when all subtasks finish, the platform wakes it. DSH goes more extreme: Router can't even write acceptance criteria; the Worker must return to the original requirement to judge, even "Router accepting an order doesn't prove it should be done."
The difference is interesting. DSH can skip acceptance criteria because development has objective facts like PR, CI. We must write them because many business tasks lack objective completion signals; acceptance criteria are the task's interface.
However, "results only" has a premise, hitting a famous industry debate. In June 2025, Anthropic published its multi-agent Research system, with main agent decomposing tasks and subagents searching in parallel.
Figure 22 · Anthropic Research system architecture (source: Anthropic Engineering [5])
Almost simultaneously, Cognition published "Don't Build Multi-Agents," arguing the opposite. Its example: building Flappy Bird—one subagent made a Mario-style background, another a mismatched bird, because each action carries implicit decisions and they can't see each other.
Figure 23 · Cognition's view: parallel splitting "unreliable", single-threaded "good" (source: Cognition [6])
My understanding: both sides are right. Research can be split; a game's art style can't. So the answer isn't whether to use multi-agent, but where the split boundary lies: only independently verifiable work can be split off.
Our Practice: Collaboration Space Flock
The above views aren't only from reading the original; many came from pitfalls in building our collaboration space. The question we answer differs slightly from DSH. DSH asks "how can one agent do many things at once"; we ask "how can a group of humans and a group of agents take responsibility for one thing to the end."
5.1 Overall Architecture
Look at the big picture. The system splits into four layers. Walking through the numbers in the diagram is the complete process of one thing:
Figure 24 · Collaboration space architecture and running process
The most important is control plane and execution plane separation. Control plane holds business facts: who's responsible, progress, which version is the result. Execution plane just runs this round: model calls, tool execution, checkpoint recovery. Execution can fail, retry, change executors; accountability and progress stay in control plane and don't get lost. This is same idea as DSH's "Ticket doesn't follow session," but we made it a product humans can see and operate directly.
5.2 Product Form: A Network of Channels
Unlike DSH's single center, ours has many Channels. Each Channel corresponds to a project or business scenario, containing humans, Coordinators, various Agents, including local Qoder on users' machines. They share one timeline; context and permissions default to not leaving this space.
Figure 25 · Channels and cross-Channel collaboration
After isolation, solve cross-boundary collaboration. DSH leaves it open; we have a working version. A dev agent needing business handoff doesn't pull the other side in; it creates a task in the other's Channel, executed in their own space. A small design I like: the same interaction line exceeding a cap (default 6 rounds) gets rejected with a suggestion to merge spaces. If two sides need that many rounds, the boundary is probably wrong.
Local Qoder deserves mention; it corresponds to DSH's "bring in everyday machines." Difference: we make it a member of a Channel, using the same tasks and acceptance as platform Agents, but it actively picks up tasks and executes on the user's machine.
5.3 Sessionless: How Sessions Are Hidden
You don't "create a new colleague" each time you talk to a colleague. That's our Sessionless: it doesn't mean there's no session underneath, but sessions no longer represent identity and tasks; they're just consumables for execution. Look at what one round of work looks like in the system:
Figure 26 · User sees one thread; system runs several sessions
Each session type has different rules, all with reasons. Chat needs continuity, so conversation sessions continue. Task execution opens new ones each round as much as possible, because inheriting an old session "lets context accumulate across rounds"; only subtask closing back to parent and manual breakpoint restart continue. Acceptance always creates new sessions, because the assessor shouldn't carry the executor's context and has no execution authority.
The conversation session best shows this. Users have no "new session" button; the system computes a key from several facts, and same key continues the chat:
Figure 27 · Whether to create a new session is computed, not chosen by user
"Who can see" is an easily ignored privacy boundary: when a Channel changes members, new conversations automatically switch to new sessions, newcomers can't read prior context. Single-instance DSH doesn't need to consider this; multi-human, multi-agent Channels must.
After hiding sessions, a new problem emerges: how to audit when something goes wrong. So in September we added a lineage table; nodes can be sessions or tasks, each edge records who triggered it. After a human @-mention, one query shows the whole growth tree of work.
5.4 Quest: Something That Outlives Sessions
Sessions become consumables; what's stable? The answer is Quest. Its table comment is three characters: responsibility contract. It's a piece of work that can be assigned, tracked, and accepted, with goal, acceptance criteria, and a single responsible person. Essentially similar to DSH's Ticket, a structured task. The purpose is to turn our chats and sessions into a structured, explicit task list.
Figure 28 · Quest lifecycle
The key design is the "pending acceptance" state: Agent ran successfully doesn't equal task complete. It only means a result was submitted; only after a human or designated acceptance Agent approves is it done. If unsatisfied, reject and execute again; the previous version stays. In enterprises, "done" requires someone to acknowledge.
5.5 Task Chain: DAG Is Not Pre-Planned
Many orchestration systems require drawing a flowchart first, then executing. But complex tasks often can't be drawn in advance. We do the opposite: each action records only its relationships; the graph naturally grows as work happens.
Figure 29 · Structure grown from a pickup task
The mechanism is simple, three rules. First, when an Agent executes a task and creates a new task, default is a subtask of the current task. Second, when creating a task, state dependencies; upstream completion wakes downstream. Third, when all subtasks finish, the platform wakes the parent and brings the accepted results for summary. In the figure, "failed order review" was split off mid-way by the executor; the Coordinator didn't know initially.
The "execution overview" managers see is expanding these relationships into a DAG; the system doesn't separately maintain a flowchart. Of course, "grow" isn't laissez-faire: if an Agent can't state which task the new one belongs to, the platform rejects creation, otherwise a free-floating task would make the parent wait forever.
Figure 30 · Real system graph
5.6 Quest Chain Context Recall
Quest chain has a byproduct. DSH uses event references for Chain of Recall; our task chain is itself a reference graph, edges are work relationships, more stable than event relationships. Consider a complex question:
Figure 31 · Answering a two-week-old question along the Quest chain (scenario and numbers illustrative)
This answer's pieces are scattered in three places: the clue in the second version's annotation, evidence in upstream failure details, reason in a business person's reply. The Agent doesn't need to remember two weeks ago; just walk along the work relationships.
5.7 Proactive Advancement: Why It Moves When No One Urges
Many people understand proactivity as a process always thinking "what should I do." Our implementation is simpler: task state lives in a ledger; a state change computes who to wake; call the model only when there's something. One execution's output becomes the next execution's trigger; things advance on their own.
Figure 32 · Proactive advancement loop
The biggest pitfall we hit is mutual wakeups, a problem single agents don't face. On a pre-release environment there was a task "organize a report count"; ideal is 3 executions: Coordinator @-mentions two Agents, each replies, then summary. Actual ran 10+ times, same task produced 8 execution instances, and one Agent @-mentioned itself. Root cause wasn't model stupidity but the platform putting "being @-mentioned" and "task assignment" in the same chain; the @-mentioned Agent got the instruction "must submit deliverables after completion," so it earnestly started decomposing tasks and sending notifications.
The fix is separating semantics: @ is communication; Quest is delegation. Being @-mentioned only replies, doesn't take execution authority; to do work, first create a task. Plus: CC doesn't wake; consecutive wakeups between Agents default to at most 3 times; human intervention resets to zero. This matches DSH's conclusion: platform hard constraints are more reliable than prompts.
5.8 Across Sessions: How to Remember Everything
This is the hardest problem; DSH also admits cross-month long-term memory is a bottleneck. We had a turning point here. Early approach was natural: every wakeup, we stuffed member list, today's messages, recent dynamics, fearing it might miss something. Result: context grew fat and full of filler. Later we slashed them all:
Figure 33 · From push to pull. Same conclusion as DSH's Inline, Spill; we were forced by production issues
A small detail in tools: long messages are no longer truncated; head and tail are kept, middle collapsed with instructions on how to retrieve. Because the Agent is fully fresh at each wakeup, retrieval is its only path to understanding the past; truncation would make it treat the fragment as the whole.
Going further is the MDC (Meta-Dance-Context) idea: Don't make the Agent remember; make the Agent able to find. Memory doesn't live in the model's head, nor in an infinitely long session, but behind a file interface the Agent can browse. Each wakeup compiles a clean window, and it reads whatever it needs.
Figure 34 · Memory as file interface (directory is planning illustration). Results auditable, referenceable, portable across models
In Conclusion: Two Trends
First, agent architecture is converging. After SuperAgent's release, a quick scan told me DSH and we were solving the same problems, and community feedback echoed similar work. Later, comparing source code confirmed it. Possible among these similar solutions, ours might be nearly identical to DSH's. Even task objects like Ticket and call chain organization are highly similar. I don't think this is coincidence or mutual copying; it's constraints compressing the solution space:
- The model can complete a single task; the bottleneck becomes human attention, so a unified external portal is needed.
- Tasks get longer and more numerous, so isolated execution units are needed.
- Tasks must outlive sessions, so persistable, trackable task objects are needed.
Once the problem is clearly defined, answers converge, just as databases ultimately converge on write-ahead logs, operating systems on processes and schedulers.
Second, agents are returning to traditional engineering. When agents move from "a conversation" to "a long-running process," they must face distributed systems' classic problems: processes crash, machines go offline, messages duplicate, side effects can't run twice. So in DSH's and our code, we see more and more classic database and distributed system techniques: write-ahead logging (record before act), Outbox for exactly-once side effects, leases to prevent double claiming, replayable event records.
The model is the only uncertain component; engineering's job is wrapping it in a deterministic shell. Models can err; systems must converge. Reliability no longer depends only on whether the model gets it right, but also on whether the system can recover when it's wrong or interrupted. Agents will become more and more like systems engineering: the model is the CPU, the Harness is the OS and database.
Related links:
[1] madewithlove test https://madewithlove.com/blog/using-cursor-background-agents/
[2] Ambient Agents https://blog.langchain.com/introducing-ambient-agents
[3] Anthropic Engineering https://www.anthropic.com/engineering/managed-agents
[4] A prototype https://github.com/deepseek-ai/dsh-superagent-prototype
[5] Anthropic Engineering https://www.anthropic.com/engineering/multi-agent-research-system
[6] Cognition https://cognition.ai/blog/dont-build-multi-agents
Top 1 from juejin.cn, machine-translated. The original thread is authoritative.
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.