跪拜 Guibai
← All articles
AI

DeepSeek's Super-Agent Architecture Finds Bugs and Files PRs Without Human Hand-Holding

By miofly ·
Read original on juejin.cn ↗ Google Translate ↗ Alt translation

Context switching across sessions is the bottleneck in agentic coding, and this architecture demonstrates a way to hold context across IM and GitHub while cutting wait time with speculative execution. The tradeoff is measurable token overhead, and the benchmark is small, but the prototype is open, so teams can start experimenting with the same patterns today.

Summary

Developers juggle IM chat, GitHub PRs, and review comments across separate agent sessions, and human attention caps at 3-5 concurrent sessions. DeepSeek's Super-agent collapses that into one agent with a Router on top and a pool of Workers underneath. When a Worker takes a PR, it subscribes directly to its comments, so new review feedback bypasses the router and lands on the same Worker, keeping context without manual relay. A two-tier filter (program rules then a model pass) cuts token spend, and an async ReAct Loop lets the agent accept new instructions while a long task is still running.

In DeepSeek's internal test, the agent connected a group-chat decision on Plan A to a GitHub comment switching to Plan B, and changed direction accordingly. It also runs speculative execution, reproducing reported bugs in the background and only surfacing a fix when it has one. To stay online 24/7, compute runs in the cloud, session state is stored separately, and the local environment can disconnect and resume; a Watchdog AI monitors for both failures and off-track loops, then tries to fix them. The measured costs are real: dropping direct delivery raises Router decisions ~30% and cached-token reads ~37%. In a small simulation (~300 messages, 20 requests, 5 runs each), the Super-agent finished tasks with a median of 12.4 minutes and a 95th percentile of 15.7, versus 29.5 at the 95th percentile for a traditional single-session baseline.

Takeaways
— A human typically tracks only 3-5 active agent sessions before attention becomes the bottleneck.
— Super-agent uses a Router layer over multiple Worker sessions; Workers subscribe to new PR comments and receive them directly, bypassing the Router.
— Two-tier message filtering uses program rules first, then a model judgment, to cut token consumption.
— Async ReAct Loop lets an agent take new instructions while a previous task is still running; it's implemented in DeepSeek Harness but off by default.
— 24/7 operation separates compute (cloud), session state (independent), and execution environment (local device); the agent resumes when the device reconnects.
— Watchdog monitors for program failures, infinite loops, and goal drift, and attempts to intervene.
— Dropping direct delivery raises Router decision counts ~30% and cached-token reads ~37%.
— In a simulation of ~300 messages and 20 work requests (5 runs per config), Super-agent median completion 12.4 min, 95th percentile 15.7 min; single-session baseline hit 95th percentile at 29.5 min.
— Prototype code is open on GitHub.
Conclusions

The token overhead numbers are the price of central orchestration; the savings come from not re-sending context across sessions, but the cost is high enough that teams should measure before adopting.

Speculative execution is a bet: the agent spends background compute on potential fixes and only surfaces when it finds something. It only pays off if reproduction and fix rates are high enough to offset wasted tokens.

The Router/Worker split with direct subscription is event-driven architecture for agents, moving responsibility from a central brain to edge workers, a pattern that generalizes beyond coding.

Keeping these features off by default in DeepSeek Harness signals caution about maturity; the simulation is small, so real-world performance is unverified.

Concepts & terms
Async ReAct Loop
A variant of the ReAct loop that lets an agent handle new instructions while a previous task is still running, without blocking.
Speculative execution
The agent proactively starts reproducing and locating a bug while it's still being discussed, and only reports back if it finds a viable fix.
Watchdog
An independent supervising AI that both detects technical failures and monitors whether a task is looping pointlessly or drifting off target, and attempts to intervene.
Source: juejin.cn ↗ Google Translate ↗ Backup ↗