Article · AI translation
AI has already found a bug and submitted a PR on its own
DeepSeek has made another move!
This time, the company has publicly shared the architectural thinking behind its Personal Agent.
Many people had been waiting for DeepSeek to launch the rumored “dsh dot,” but what arrived first was a discussion of architecture aimed at engineering practice—
Super-agent: Toward More Autonomous Agent Systems.
What does that mean? AI can discover bugs, pinpoint problems and even proactively submit fix PRs without anyone tagging it or giving it instructions.
It can also keep track of messages in work group chats, collaborate across platforms, handle multiple complex tasks in parallel and even run 24 hours a day.
The DeepSeek team also shared preliminary test results—
In a simulated multitask environment, Super-agent had a median task completion time of 12.4 minutes and a 95th-percentile time of 15.7 minutes, outperforming the traditional single-session approach tested.
AI really is beginning to move beyond waiting for humans to assign tasks one by one, gaining the ability to identify problems proactively and keep work moving.
In everyday software development, a common problem developers face is having to switch back and forth between platforms!!
For example, they might first discuss a technical approach in an IM group chat, then submit code on GitHub, and then revise the implementation based on PR comments.
For traditional coding agents, these steps are often spread across different sessions—
Users have to remember where each session left off and then give the AI the relevant context.
In their article, the DeepSeek team says that, based on their observations, a person can typically keep track of only 3 to 5 active sessions at once.
This creates a problem: as models become better at handling individual tasks, the efficiency of multitask collaboration becomes increasingly constrained by human attention.
As it happens, this is exactly the problem Super-agent aims to solve.
In an instance running within the DeepSeek team, the same development task can continue from an IM group chat through to a GitHub PR review.
For example, a user might first decide in the group chat to use approach A, then ask in a GitHub comment to switch to approach B.
Super-agent can understand that both messages concern the same task and adjust its subsequent work accordingly.
The user interacts with the same agent throughout, while the system manages multiple underlying sessions itself, and the agent begins to participate proactively in the work.
This also uses a technique called speculative execution.
When the AI notices something that may need attention, it can start working on it in the background.
For example, if someone discusses a bug in a group chat, Super-agent can start reproducing it and looking for the cause, then present the result to the user if it finds a simple, workable fix.
If it finds nothing useful, it can stay quiet to avoid interruptions. The same approach can be used for a personal assistant.
After receiving a meeting invitation, the AI can check for scheduling conflicts, gather relevant materials and prepare a draft reply for the user to confirm.
This reflects the 4 core characteristics DeepSeek proposes for Super-agent:
Continuity: It retains task context across sessions and work platforms, so users do not have to repeatedly explain what happened before.
Efficiency: It runs multiple complex tasks in parallel, so time-consuming tasks do not block new interactions.
Proactivity: It continuously monitors changes in its environment and takes action on its own when needed.
Persistence: It stays online over the long term and can try to recover automatically when something goes wrong.
To achieve this, DeepSeek designed a two-layer architecture.
The upper layer, called the Router, can be thought of as a dispatcher that receives messages and coordinates tasks. The lower layer, called Workers, consists of agent sessions that carry out specific tasks.
More specifically, the upper-layer Router acts as the central dispatcher, receiving messages, assigning tasks and maintaining global context.
The lower-layer Workers handle execution, allowing multiple tasks to move forward at the same time without interfering with one another.
Notably, DeepSeek also designed a subscription and direct-routing mechanism—
For example, once a Worker takes on a GitHub PR, it can subscribe directly to subsequent comments.
If someone then suggests a change, the message goes straight to that Worker for handling, without having to pass through the Router again.
That lets existing tasks receive continuous attention while new ones are assigned promptly, helping the whole system operate more efficiently.
Beyond multitask collaboration, long-term autonomous operation for Super-agent also requires solutions for message filtering, task blocking and recovery from failures.
First, message filtering.
When an agent is connected to work group chats, GitHub, email and other platforms at the same time, messages keep pouring in, but only a few may actually require action.
To address this, DeepSeek designed a two-stage event-filtering mechanism—
Programmatic rules first filter out irrelevant messages, then a large model determines whether the remaining events require action, reducing unnecessary token consumption.
Super-agent also introduces an asynchronous ReAct Loop.
The AI can continue responding to new instructions while carrying out time-consuming tasks, without waiting for the previous task to finish. This mechanism has been implemented in DeepSeek Harness but is not yet enabled by default.
For 24-hour availability, DeepSeek uses an approach that separates computation, state and the execution environment.
The agent's computation can run in the cloud, with session state stored separately, while the local device retains its original work environment. Even if the computer goes offline temporarily, the cloud agent can maintain the task state and continue the relevant work when the device comes back online.
The team has also introduced an independent Watchdog mechanism.
It acts like an AI dedicated to supervising other agents: it can detect program failures, determine whether a task is stuck in an unproductive loop or has drifted from its goal, and try to intervene and fix the problem.
The DeepSeek team also conducted a set of preliminary experiments—
They simulated a collaborative environment with about 300 messages and 20 work requests, comparing Super-agent with a traditional single-session-plus-subagent approach and repeating each configuration 5 times.
The results showed a median task completion time of 12.4 minutes and a 95th-percentile task completion time of 15.7 minutes for Super-agent.
With a neutral prompt, the traditional single-session approach had a 95th-percentile task completion time of 29.5 minutes.
Of course, the efficiency gains also come with some token overhead.
DeepSeek found that removing the direct event-routing mechanism increased the Router's decision count by about 30% and cached token reads by about 37%.
This also shows that sensible event routing can effectively reduce system operating costs.
Judging from this technical presentation, DeepSeek is exploring ways to move agents further beyond the limits of a single session, enabling continuous availability, parallel execution, proactive responses and automatic recovery from failures.
As AI gradually becomes able to complete complex tasks independently, keeping it working on multiple tasks over the long term and with stability is also emerging as a new problem for agent systems to solve.
GitHub link:
https://github.com/deepseek-ai/dsh-superagent-prototype