The yardstick for next-generation agents has changed: it's now about who requires less human attention
DeepSeek has open-sourced dsh-superagent, a research prototype whose core goal is almost word-for-word identical to loopx's. Separating state from sessions, refining context, and extracting the router into a control plane—several approaches are converging, showing that the competitive focus for next-generation agents has shifted from capability to attention.
DeepSeek has open-sourced a research prototype called dsh-superagent.
The repo description is refreshingly candid: it's for reference, not an official product; the code grew out of the team's day-to-day development, so the style may be inconsistent. But the problem it aims to solve is stated in one sentence: much value and little human attention.
More value, less human attention.
Ruiteng Huang, the author of loopx, quickly pointed out that this phrasing is almost word-for-word identical to the title of loopx's August–September blog post this year: More useful work, less human attention.
Overlapping goals are no surprise. What is surprising is that the paths line up too.
Ruiteng Huang listed three specific points.
First, separating state from sessions. When an agent runs long tasks, intermediate state is decoupled from the conversation session, so switching sessions doesn't lose progress.
Second, context organization has been finely optimized, with both engineering efficiency and effectiveness in mind. Put simply, the model can only see so much at a time, and knowing how to fit the most important content into the window is a craft.
Third, treating general long-horizon capabilities as the foundation of a personal agent, with a butler or router serving as the interface for interacting with the user, responsible for minimizing attention and dispatching tasks.
These three points largely overlap with loopx's approach. The difference is that loopx has dense state information per goal and per agent, which places higher intelligence demands on the router.
A commenter asked the key question: how do you handle state rollback and compensation when a subtask fails? That question is far harder to answer than the arrows on an architecture diagram. Whether you can truly let the agent run on its own doesn't depend on how beautifully it plans, but on how it cleans up when it goes off track.
In a reply, Ruiteng Huang said dsh has the opportunity to radically co-design and co-train with models, which loopx does not. But he also noted that loopx started earlier: he began working on this line as a side project in February this year, and the project later reached 5k stars and hit No. 1 on GitHub Trending.
The architecture diagram shows the separation of control plane and execution plane: the controller session handles scheduling and contracts, the executor session does the work, and they are connected through tasks, findings, and artifacts.
The trend assessment is also stated bluntly: general long-horizon tasks need both a semantic control plane to run stably and the overhead of the control plane extracted out of the working session, so that the scheduling layer's context doesn't eat into the model's intelligence.
Optimization of differential context is still running benchmarks. Ruiteng Huang posted a screenshot of EdgeBench and said he was seeing promising signals that were hard to believe.
Related links:
- dsh-superagent repository: https://github.com/deepseek-ai/dsh-superagent-prototype
- DeepSeek technical article: https://mp.weixin.qq.com/s/zoS7GlReWPhfCjENGxXCdg
- loopx repository: https://github.com/loopx-project/loopx
- loopx RFC (separation of control session and executor session): https://github.com/loopx-project/loopx/blob/main/docs/architecture/rfcs/controller-executor-unified-contract-v0.zh-CN.md
- loopx September blog: https://loopx-project.github.io/loopx/blog/from-one-shot-agents-to-long-horizon-control/
发布时间: 2026-11-01 00:31