DeepSeek Open-Sources Super-agent Architecture for Autonomous Cross-Platform Collaboration

Mengyao Reporting from Aofeisi

QbitAI | WeChat Official Account: QbitAI

DeepSeek has made another move!

This time, the official team directly disclosed the underlying architectural approach for their Personal Agent.

Previously, many were waiting for DeepSeek to release the rumored "dsh dot." Instead, they received an article exploring architectural concepts focused on engineering practice—

Super-agent: Towards More Autonomous Agent Systems.

What does this mean? It means AI can now discover bugs, locate issues, and even proactively submit fix PRs without anyone @-mentioning it or giving explicit instructions.

It can even continuously monitor work group messages, collaborate across platforms, handle multiple complex tasks in parallel, and achieve 24/7 online operation.

The DeepSeek team also shared preliminary benchmark results—

In a simulated multi-task environment, Super-agent had a median task completion time of 12.4 minutes and a 95th percentile of 15.7 minutes, outperforming traditional single-session approaches in testing.

AI is truly beginning to evolve from waiting for humans to assign tasks item by item, to proactively discovering problems and driving work forward.

No @-Mentions Needed: AI Finds Bugs and Submits PRs Autonomously

A common pain point in daily software development is the need to switch back and forth between different platforms!!

For example, discussing technical solutions in an IM group chat, then submitting code on GitHub, and finally modifying the implementation based on PR comments.

For traditional Coding Agents, these operations are often scattered across different sessions—

Users have to remember where each session left off and manually provide relevant context to the AI.

In their article, the DeepSeek team noted that, based on their observations, a person can typically only track 3 to 5 active sessions simultaneously.

This creates a bottleneck: as models become increasingly capable at handling individual tasks, the efficiency of multi-task collaboration becomes increasingly limited by human attention.

Coincidentally, this is exactly the problem Super-agent aims to solve.

In instances running within the DeepSeek team, a single development task can seamlessly transition from IM group chats to GitHub PR reviews.

For example, a user might initially decide on Solution A in the group chat, but later request a change to Solution B via GitHub comments.

Super-agent understands that these two messages belong to the same work item and adjusts its subsequent execution direction accordingly.

The user always interacts with the same Agent, while the system manages multiple underlying sessions automatically. Moreover, the Agent begins to actively participate in the work.

A key technique used here is Speculative Execution.

When the AI identifies something that might need processing, it can attempt to handle it in the background beforehand.

For instance, if someone discusses a bug in the group chat, Super-agent starts reproducing the issue and investigating the cause. If it finds a simple, viable fix, it presents the result to the user.

If no effective solution is found, it remains silent to avoid disturbance. This same logic applies to personal assistants.

Upon receiving a meeting invitation, the AI can pre-check schedule conflicts, organize relevant materials, and prepare a draft reply, waiting for user confirmation.

This aligns with the four core characteristics DeepSeek proposed for Super-agent:

• Continuous: Maintains task context across sessions and work platforms, eliminating the need to repeatedly explain previous situations.
• Efficient: Executes multiple complex tasks in parallel; long-running tasks do not block new interactions.
• Proactive: Continuously observes environmental changes and takes action autonomously when necessary.
• Persistent: Operates online long-term and attempts automatic recovery upon encountering anomalies.

To achieve this, DeepSeek designed a dual-layer architecture.

The upper layer is called the Router, which acts as a dispatcher responsible for receiving messages and coordinating tasks. The lower layer consists of Workers, which are a set of Agent sessions responsible for specific task execution.

Specifically, the Router serves as the central dispatcher, handling message reception, task allocation, and global context maintenance.

The Workers handle concrete execution, allowing multiple tasks to progress simultaneously without interference.

Notably, DeepSeek also designed subscription and direct-pass mechanisms—

For example, once a Worker takes over a GitHub PR, it can directly subscribe to subsequent comments.

Later, when modification suggestions are raised, the messages are passed directly to this Worker for processing, bypassing the need for layered forwarding through the Router.

This ensures that ongoing tasks are consistently tracked while new tasks are allocated promptly, making the entire system run more efficiently.

24/7 Online, Autonomous Recovery, and More Stable Task Completion Times

Beyond multi-task collaboration, enabling Super-agent to operate autonomously long-term requires solving issues such as message filtering, task blocking, and anomaly recovery.

First, regarding message filtering.

When an Agent connects to platforms like work groups, GitHub, and email simultaneously, a large volume of messages floods in, but only a few actually require processing.

To address this, DeepSeek designed a two-level event filtering mechanism—

Programmatic rules first filter out irrelevant messages, and then the LLM determines whether the remaining events require action, reducing unnecessary Token consumption.

Meanwhile, Super-agent introduces an asynchronous ReAct Loop.

While executing time-consuming tasks, the AI can still respond to new instructions without waiting for the previous task to complete. This mechanism has been implemented in DeepSeek Harness but is not enabled by default.

Regarding 24/7 online operation, DeepSeek adopted an approach separating computation, state, and execution environments.

The Agent's computational logic can run in the cloud, session states are saved independently, and local devices retain their original working environments. Even if a computer goes offline temporarily, the cloud-based Agent maintains task status and continues related work once the device comes back online.

Furthermore, the team introduced an independent Watchdog mechanism.

It functions as a dedicated AI supervisor for other agents, capable of detecting program failures, identifying whether tasks are stuck in unproductive loops or deviating from their goals, and attempting to intervene and repair them.

The DeepSeek team also conducted a set of preliminary experiments—

They simulated a collaborative environment containing approximately 300 messages and 20 work requests, comparing the Super-agent approach against the traditional single-session plus subagent method. Each configuration was tested five times.

The results showed that for the Super-agent, the median task completion time was 12.4 minutes, and the 95th percentile task completion time was 15.7 minutes.

In contrast, under neutral prompts, the traditional single-session approach reached a 95th percentile task completion time of 29.5 minutes.

Of course, this efficiency gain comes with a certain token overhead.

DeepSeek found that after disabling the event pass-through mechanism, the Router's decision-making frequency increased by approximately 30%, and cached tokens read increased by about 37%.

This indicates that effective event routing can significantly reduce system operational costs.

From this technical sharing session, it is evident that DeepSeek is exploring ways to further liberate agents from the constraints of single sessions, enabling continuous online presence, parallel execution, proactive responses, and self-healing capabilities.

As AI gradually becomes capable of independently completing complex tasks, how to enable it to drive multiple workflows long-term and stably has begun to emerge as a new challenge that agent systems need to address.

GitHub Link: https://github.com/deepseek-ai/dsh-superagent-prototype