DeepSeek Super-Agent Core Features Explained and Practical Guide: Bringing Operating System Concepts into Agents

---

theme: devui-blue

Introduction

On the evening of October 31, the DeepSeek Harness team published an article on their official public account, "Super-Agent Design Exploration: Toward More Autonomous Agent Systems", and simultaneously open-sourced the research prototype dsh-superagent-prototype. This is undoubtedly another "technical nuclear bomb" thrown recently by DeepSeek (their recent moves have been quite frequent). The dsh-superagent-prototype repository gained 15,000 stars in just three days, showing the community's strong interest.

So what exactly is Super-Agent, and why has it drawn such attention? In short, it's an agent system architecture. As the official statement puts it: "The ceiling for a single task depends on model capability, while the ceiling for multiple tasks depends on human attention." Super-Agent aims to solve the behavioral constraints caused by "human attention cannot be overly dispersed" in multi-task scenarios.

The author has been reading technical articles and source code related to Super-Agent every day. Today, we'll break down Super-Agent's core principles and architecture layer by layer, and see how the DeepSeek Harness team moved classic concepts like process scheduling, caching, and storage-compute separation from operating systems into agent systems.

1. Why Do We Need Super-Agent?

I'm sure everyone has experienced this: a pile of tasks on hand, fixing bugs, writing docs, running data... Each task usually requires its own session, so you open three sessions at once and keep switching over to check progress. If there are more tasks, more sessions pile up, and soon you forget which session is doing what.

This isn't your problem; it's a problem with current LLM product architecture. The DeepSeek team observed a harsh truth: a person can typically follow only 3 to 5 active sessions simultaneously. Current mainstream agents use a single session as the basic unit, and sessions are independent of each other, with no shared context. No matter how strong the model is, if human attention can't keep up and you can't handle many sessions at once, efficiency stays low.

Super-Agent's goal is to break the binding between an agent and a single session, making it a continuous entity that maintains cross-session context, handles multiple tasks in parallel without interference. The DeepSeek official team has defined four core characteristics for Super-Agent:

• Continuous: Interactions in any channel (IM group chat, GitHub comments, etc.) feel like there's only "one" agent; no need to open multiple sessions.
• Efficient: Processes multiple complex tasks in parallel, without waiting for the previous task to finish.
• Proactive: Continuously observes environmental events, actively seeks work, and stays quiet when not needed.
• Persistent: Online 24/7, automatically recovers from anomalies.

2. Super-Agent Core Architecture: Five Modules

dsh-superagent is a plugin for DeepSeek Harness, and it's an "extremely proactive" agent, currently supporting GitHub repositories and Feishu. Taking GitHub as an example: when someone sends a work request to the agent, the agent opens a work item and automatically assigns a Worker to execute the task. Humans don't need to decide which session the task belongs to; they only focus on the task itself. The Super-Agent plugin uses several clever design ideas, mainly in five categories:

2.1 Two-Layer Architecture: Router Dispatches Tasks, Worker Handles the Work

The two-layer architecture is Super-Agent's most core design. DeepSeek Harness uses two layers to maintain global continuity and support high-concurrency execution:

• Router Layer: A persistent global router that uniformly handles human interactions, maintains global context, and dispatches tasks. It only dispatches, doesn't execute work, and may not even have basic command-line tools like Bash.
• Worker Layer: Execution sessions with isolated contexts, carrying full toolchains, focused on completing a single task, usually configured with the strongest model. Workers only execute, don't interfere with conversations, and report results uniformly to the Router, which then replies externally.

You might ask: "What's the difference between this and my usual multi-agent setup?" Actually, they are fundamentally different. Multi-agent setups usually still happen within one session: the main agent assigns tasks, and child agents execute. The Router-Worker architecture, on the other hand, targets multiple sessions. It gathers all sessions into a unified entry point. Your single task is just one task in this entry, and the Router notifies the Worker to complete it. How the Worker completes it can be decided by the Worker itself, or the Worker can internally adopt a multi-agent collaboration approach. That should clarify it.

What's the benefit of a single session? For example: you say "Use plan A" in IM, and then later change to "Plan B" in a GitHub PR comment. The Router can still recognize this is the same task and notify the corresponding Worker to adjust direction. With multiple sessions, both sessions would proceed simultaneously, and the project could get messed up (unless you stop one in advance). Router-Worker works like process scheduling in an operating system: Router is the kernel scheduler, Workers are isolated processes.

2.2 Event-Driven: Proactively Seeking Work Instead of Waiting for Instructions

Traditional agents are "you ask, it answers," handling only the current assigned task. Super-Agent's input includes not just user instructions but also environmental events: group chat messages, emails, schedule reminders, code review comments, CI run results, etc., all triggering the agent to execute related operations. These triggering events are collectively called Triggers.

A clear problem: the real environment has a lot of noise. Sending every message to an LLM for judgment would cost too much. DeepSeek borrows the Fast Path / Slow Path idea to design a two-level filter:

• Fast Path (program level): Uses deterministic code to quickly filter out irrelevant messages based on source, group, and whitelist.
• Slow Path (semantic level): Only candidate events that pass the initial filter go to the LLM, which then decides whether to act based on context.

2.3 Thread Subscription Direct-Pass: Subsequent Events Don't Necessarily Go Through the Router

When Super-Agent is designed, consecutive events under the same GitHub PR or the same IM topic are grouped as a Thread. The Router only creates a Worker during new task cold start and assigns tasks. Once the Worker starts the task, that task becomes a Thread; subsequent events on the same Thread are delivered directly to the Worker by a program, without going through the Router.

Don't underestimate this design. According to DeepSeek Harness's ablation experiments, removing the Thread subscription direct-pass increases the Router's decisions by about 30%, and read-cache tokens rose from 23.23 million to 31.77 million, burning about 37% more tokens! This feature effectively protects the wallets of heavy DeepSeek Harness users like me.

2.4 Context Organization: Inline & Spill + Chain of Recall

For a full-flow agent like this, an obvious problem is that context will explode because there are too many information sources. Super-Agent addresses this in two layers:

• Inline & Spill: Recent and frequently used information goes directly into the context window (Inline); overly long or low-frequency content is truncated and stays outside the window (Spill), and tools fetch it when needed.
• Chain of Recall: Triggers, Threads, and Worker Sessions all have unique IDs. When injecting context, IDs of associated objects are inlined to construct a reference graph. The model can start from the current message and hop along IDs to retrieve old task context from three months ago.

2.5 Storage-Compute Separation and Watchdog: Ensuring Persistent Online Status

• Storage-Compute Separation: The "computation" that advances the Agent Loop runs continuously in the cloud, while session "state" is stored in a database, so server restarts don't lose it; local code repositories are remotely called via a lightweight background process.
• External Watchdog: Long-running agents may fall into infinite loops or go off track. An independent external Watchdog monitors the status of each Worker and intervenes to correct anomalies when they occur.

3. Quick Look at Super-Agent Source Code

The Super-Agent plugin released by DeepSeek Harness has source code at: https://github.com/deepseek-ai/dsh-superagent-prototype. The author recently analyzed the plugin's source code and found its directory structure clearly corresponds to Super-Agent's architecture:

• src/core: The core Router logic, also the core source of the scheduling system, responsible for task distribution and concurrency control.
• src/sources: Event source plugins like GitHub, Feishu, etc.
• src/executor: Worker executor; each Worker can derive an independent Session and working directory.
• src/core/health.ts: Health checks through heartbeats, the prototype of the Watchdog.

What impressed the author even more is DeepSeek's security awareness: the plugin has strict role isolation. Sources can only report events, the main Session can only evaluate and dispatch, and the Executor can only report facts. Architectural constraints don't rely on "developer self-discipline"; they block privilege escalation at compile time.

4. Super-Agent in Practice

Once the theory is clear, let's experience Super-Agent's features through practice. Follow the steps below to install and use Super-Agent.

Note: Super-Agent is a plugin for DeepSeek Harness, so you must install DeepSeek Harness first. Refer to the author's article DeepSeek Harness Getting Started is Simple (1) - Understanding and Installing DeepSeek Harness. Also, the Super-Agent plugin currently does not support running on Windows. You can use WSL to install DeepSeek Harness following the article's instructions.

1. Give the DeepSeek Harness repository URL to DeepSeek Harness, then ask it how to install the plugin (https://github.com/deepseek-ai/dsh-superagent-prototype):

   

2. Follow DeepSeek Harness's instructions to complete configuration. After configuration, you will see a plugin named Super-Agent in DeepSeek Harness. The configuration process is complex: you need to register a GitHub alt account to act as the DeepSeek Harness agent bot, and create a GitHub repository linked to that bot. However, you can complete it by following DeepSeek Harness's guidance throughout.

   

   

3. After configuration, for a project in the same GitHub repository, users can @ mention the agent's alt account to ask it to complete tasks. The alt account will receive the task, call the local DeepSeek Harness to complete it, and submit a PR.

   

4. You can also configure an automated bot in Feishu; try it yourself. Then you can issue commands directly without worrying too much about context. Quite powerful, isn't it!

   

However, based on the author's actual experience, issuing coding tasks via GitHub isn't as intuitive as doing it in Trae or directly in DeepSeek Harness. After all, Super-Agent is currently version 0.1, and the official positioning is a reference prototype rather than a complete product. It also consumes a lot of memory and system resources. Interested users can try it, but integrating it into daily work isn't realistic yet.

That's all for this article~

5. Summary

This article introduced Super-Agent. The most noteworthy aspect isn't how good it is now, but that it provides a new approach: systematically moving classic OS concepts like process scheduling, cache layering, and storage-compute separation into agent architecture. The Router-Worker two-layer architecture solves global continuity and concurrent execution; event-driven lets the agent proactively find work; Thread subscription direct-pass reduces Router load; Inline & Spill with Chain of Recall controls context explosion; and storage-compute separation with Watchdog ensures persistent online status. These five designs interlock to form a practical engineering reference.

If you found this valuable, feel free to like, bookmark, and follow my column "DeepSeek Harness from Beginner to Advanced" for future updates. See you next time! For more exciting content, follow my Juejin account and column, or follow my WeChat public account with the same name 大模型真好玩. All code from each installment can be obtained by private message.