跪拜 Guibai
← All articles
Backend · Programmer · Artificial Intelligence

DeepSeek Harness's Super-Agent Architecture: Router/Worker, Triggers, and BYOM

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

This design moves agent systems from prompt-driven single sessions to persistent, multi-task operations that span IM, GitHub, and local machines, cutting the human attention bottleneck that caps current tools. BYOM keeps credentials and uncommitted changes local, avoiding the environment drift that plagues cloud-only execution.

Summary

DeepSeek Harness's Super-Agent design tackles the human attention limit of 3-5 sessions by splitting coordination and execution. A permanent Router layer, running a lightweight model, handles cross-task decisions and message filtering; Worker layers, each with a full-strength model and isolated context, execute single tasks. The system manages context at the infrastructure level, so users see one persistent agent rather than switching sessions.

The architecture is event-driven: Triggers from IM, email, CI, and code reviews pass through a two-stage filter (programmatic and semantic) to reach the right Worker. Related triggers are grouped into Threads, and Workers subscribe to them. Context is managed with an Inline/Spill mechanism that keeps likely-needed info in the window and pushes the rest to references, with Chain of Recall to navigate the object graph. An asynchronous ReAct loop allows new commands while tasks run. Compute runs in cloud containers, state lives in a database, and the actual working environment stays on the user's machine via a local daemon (BYOM). A Watchdog session detects and corrects agent loops that hang or drift.

Takeaways
— Human attention holds only 3-5 agent sessions, so multi-task agents must carry context across sessions.
— The Super-agent uses a Router layer (lightweight model) for coordination and Worker layers (top model) for execution.
— Triggers from IM, email, CI, and PR comments enter a two-stage filter: programmatic (Fast Path) then semantic (Slow Path).
— Threads group related triggers; Workers subscribe to Threads, and Fast Path routes new messages directly to subscribed Workers.
— Inline/Spill context management inlines likely-needed info and spills the rest with references, like OS page swapping.
— Chain of Recall links Trigger/Thread/Worker IDs so an agent can navigate the context graph without a huge memory store.
— Speculative execution lets the agent precompute uncertain results in the background, discarding useless output.
— An asynchronous ReAct Loop (full-duplex) accepts new commands while a task runs, already implemented but off by default in DeepSeek Harness.
— Compute, state, and environment are separated: containers handle compute, a database stores session state, and a local daemon (BYOM) executes commands on the user's machine.
— A Watchdog session, driven by timed messages, detects LLM loop deadlocks or goal drift and intervenes to correct.
Conclusions

By borrowing page swapping, speculative execution, and control loops from operating systems, the architecture shows agent reliability still depends on classical systems engineering, not just better prompts or tools.

The Router layer's explicit use of a lightweight model separates decision-making from raw capability, which could lower the cost of multi-agent coordination.

The BYOM approach inverts the usual cloud-everything trend: it keeps environments local and treats the cloud as pure compute, sidestepping the reproducibility problems of copying credentials and toolchains.

Concepts & terms
Router/Worker
A dual-layer architecture where Router coordinates and distributes tasks (lightweight model), and Workers execute specific tasks in isolated contexts (strong model).
Trigger
An environmental event (group message, email, CI result, review comment) that activates the agent's proactive work.
Thread
A sequence of related Triggers that constitute a continuous context, e.g., a PR discussion or an email chain.
Inline/Spill
Context management that keeps likely-needed information in the window (Inline) and pushes less-used info out with references (Spill), analogous to OS memory paging.
Chain of Recall
A mechanism assigning IDs to objects (Triggers, Threads, Workers) so the agent can navigate a reference graph to retrieve related context on demand.
BYOM (Bring Your Own Machine)
A separation pattern where compute runs in cloud containers, state in a database, and the user's local machine stays the execution environment via a lightweight daemon.
Source: juejin.cn ↗ Google Translate ↗ Backup ↗