While programmers are still debating how to fix bugs in group chats, AI may have already quietly reproduced the problem and even submitted the fix to GitHub.
Just now, the DeepSeek Harness team published a technical article titled "Super-agent Design Exploration: Toward a More Autonomous Agent System," detailing the Super-agent architecture they are exploring.
According to DeepSeek's vision, future AI Agents will no longer be confined to a single chat window, but will be able to stay online continuously, handle multiple tasks simultaneously, and proactively take action based on changes in the external environment.
More notably, DeepSeek has already built an internal Super-agent instance based on DeepSeek Harness and is using it for daily R&D collaboration.
For example, when team members report software issues in group chats, even if no one proactively @ mentions the AI, it can identify potential defects, attempt to reproduce the problem in the background, find a fix, and even directly submit a GitHub Pull Request for developers to review.
The same development task can also proceed continuously between group chats and GitHub. Developers first finalize a plan in the group chat, then later modify requirements in GitHub comments, and the Agent can understand the changes before and after and adjust its execution direction.
However, Super-agent is currently still an architectural exploration oriented toward engineering practice, with some designs already implemented through open-source prototypes, and is not yet an official standalone product from DeepSeek.
The next bottleneck for AI Agents may be humans themselves
Over the past year, AI tools represented by Coding Agents have been able to independently read code, locate bugs, run tests, and even complete complex software development tasks.
However, as model capabilities grow stronger, another problem has begun to emerge.
AI can complete more and more tasks simultaneously, but humans' attention for managing these tasks has not grown in sync.
Currently, most Agents still use Session, that is, conversation, as the basic unit of work. Users need to repeatedly switch between different windows, remember the context of each task, and continuously track execution progress.
The DeepSeek team mentioned that according to their observations, a person can usually only follow 3 to 5 active Sessions at the same time. Even if tools such as CLI and MCP allow Agents to connect to more platforms, it remains difficult to solve problems such as serial execution within a single session, chaotic multi-task context, and task interruption after local devices go offline.
To this end, DeepSeek proposed Super-agent, hoping to free Agents from single sessions and turn them into a continuous entity that can run long term, maintain context across platforms, and advance tasks in parallel.
According to the definition in the article, Super-agent needs four capabilities, including continuous interaction across sessions, efficient parallel multi-tasking, proactive response to environmental events, and long-term online operation and exception recovery.
In other words, humans can focus more on setting goals and accepting results, while the specific task scheduling and execution process is left to AI management.
One AI acts as supervisor while multiple AIs work simultaneously
To achieve this goal, DeepSeek designed a two-layer architecture composed of Router and Worker. It can be understood as a virtual team made up of AI, with the Router responsible for overall coordination and Workers responsible for specific execution.
The Router is a continuously running global coordination node that uniformly receives information from different platforms such as group chats, GitHub, and email, determines how tasks should be assigned, and maintains context across tasks.
The ones actually executing tasks are the Workers. Each Worker has independent context and tool capabilities and can separately handle tasks such as problem reproduction, code review, and feature development, and can further call Subagents when necessary.
After a task is completed, the Worker reports key results to the Router, which then communicates with the user in a unified way.
For the user, what they face is always the same AI assistant; for the system, multiple independent Agents may already be working simultaneously behind the scenes.
To reduce coordination overhead, DeepSeek also introduced a subscription mechanism. When a Worker takes over a GitHub Pull Request, subsequent comments and status changes can be sent directly to it, without needing to go through the Router for reassignment each time.
The Router is mainly responsible for information understanding and task assignment, so a relatively lightweight model may also be sufficient, while more capable models are used for complex task execution.
DeepSeek believes that traditional Agents making users manually manage Sessions largely continues the design habits of underlying large model APIs. As Agent capabilities improve, Session should gradually become an internal technical detail of the system.
Even if no one @ mentions it, AI can proactively fix bugs
Compared with multi-task parallelism, the more noteworthy capability of Super-agent is proactively finding things worth handling.
Traditional AI assistants usually require users to first ask a question and then call tools to complete the task. DeepSeek hopes to change this way of working, allowing Agents to take action directly based on events in the external environment.
Group chat messages, emails, calendar reminders, GitHub comments, and CI test results can all become events that trigger Agent action, technically called Trigger.
Considering that the vast majority of group chat messages do not require AI intervention, DeepSeek designed a two-level filtering mechanism, using program rules to quickly exclude irrelevant messages, and then handing them to the large model to determine with context whether action is needed.
Going further, DeepSeek also introduced the idea of speculative execution from computer systems. So-called speculative execution means that before it is determined whether a result will be adopted, background computing power is used in advance to make an attempt; valuable results are then submitted to the user, while worthless ones are directly abandoned.
For example, DeepSeek configured a "silent reproduction and fix" strategy in an internal user group. When someone reports a bug or discusses a modification plan, Super-agent can reproduce the problem in the background in advance, analyze the cause, and look for a fix. Only after confirming that the problem exists and finding a relatively simple fix will the AI submit the result to developers; otherwise it remains silent throughout.
In a case demonstrated by DeepSeek, while team members were still discussing a solution in the group chat, Super-agent had already submitted a fix Pull Request in the background.
Similar mechanisms can also be applied to personal assistants. For example, after receiving a meeting invitation, AI can check the schedule in advance, gather background materials, and prepare an email reply draft, waiting for user confirmation.
Even if the computer is turned off, AI can continue working
In addition to proactivity, DeepSeek also tries to solve the problems of response blocking and device dependence in traditional Agents.
In the common ReAct Loop, after the model initiates a time-consuming tool call, it needs to wait for the result to return, and during that period it may be unable to respond promptly to new instructions.
DeepSeek therefore designed an asynchronous ReAct Loop, allowing time-consuming tasks to be moved to background execution while the foreground session continues to receive user messages, and then sending the results back after the task is completed.
AI can accept new instructions while executing complex tasks, and users can also ask it to change direction or terminate a task during execution.
This mechanism has already been implemented in DeepSeek Harness, but is not yet enabled by default.
At the same time, drawing on the idea of separating storage and computation, DeepSeek places the Agent's execution loop in the cloud, saves session state to a database, while work environments such as code repositories, files, and toolchains can still remain on the user's device.
Locally, only a lightweight daemon needs to be deployed, responsible for receiving cloud commands and returning results. Even if the computer is temporarily offline, related tasks can continue after the device comes back online.
In addition, DeepSeek also introduced an independent Watchdog mechanism, equivalent to assigning the Agent an AI supervisor, responsible for checking whether tasks are making progress, whether they are stuck in ineffective loops, and trying to fix anomalies when they are found.
Measured efficiency improves, but more Tokens are consumed
To validate the new architecture, the DeepSeek team conducted a set of preliminary experiments. The experiment simulated group chat and GitHub CI message streams, with about 300 messages in a single run, of which about 20 were real work requests.
Researchers compared Super-agent with a traditional single-Session plus Subagent approach, repeating each approach five times.
The results showed that Super-agent's task completion time had a p50 of 12.4 minutes and a p95 of 15.7 minutes; the traditional single-Session approach using neutral prompts reached a p95 of 29.5 minutes.
The difference mainly came from task scheduling. Although the traditional approach supports Subagents, whether the model actually dispatches tasks still depends on prompts and on-the-spot judgment. Under the neutral prompt configuration, the model did not call Subagents even once in five experiments, and all tasks were executed in the main session, constantly interrupted by new messages.
Super-agent, by contrast, uses a two-layer architecture so that the Router focuses on task assignment and Workers execute independently, reducing this uncertainty.
However, the efficiency improvement also comes at a cost. Because multiple independent sessions need to be maintained, Super-agent consumes more cached read Tokens than single Session.
After canceling the event direct-pass mechanism, the number of decisions the Router needs to make increased by about 30%, and total cached reads rose from 23.23 million to 31.77 million Tokens, an increase of about 37%.
In addition, when the event arrival rate rose from about 1 per minute to 40 per minute, the Router could improve throughput through batch processing, with the duration of a single request increasing only from 2.5 seconds to 3.9 seconds.
It should be noted that the experiment used synthetic messages and simulated time-consuming tools, mainly validating task scheduling and collaboration capabilities, and did not directly evaluate real coding quality.
DeepSeek wants AI to become a true digital colleague
Although DeepSeek is already running Super-agent internally, there are still many challenges before large-scale adoption.
The first is long-term memory. When tasks accumulate over weeks or even months, how to accurately restore historical context remains a difficult problem.
The second is security and privacy. Because Super-agent continuously receives external messages and accesses local devices through the cloud, once it encounters prompt injection or server-side intrusion, it could threaten code repositories, sensitive data, and local credentials.
In addition, when Agents can advance a large number of tasks simultaneously, how users should view progress, intervene in execution, and decide which operations must be manually approved also needs to be redesigned.
At present, DeepSeek has implemented some designs as the dsh-superagent-prototype prototype plugin, and the related architecture is still being continuously explored.
It is worth noting that at the end of the article, the DeepSeek team admitted that they did not propose an entirely new theory, but instead applied classic computer system ideas such as task scheduling, cache management, event-driven design, and separation of storage and computation to Agent architecture.
But as models need less and less manual intervention to complete individual tasks, how many AIs humans can manage simultaneously is becoming a new question.
In the past, we needed to constantly send instructions to AI to tell it what to do next. According to the Super-agent vision, in the future humans can focus more on setting goals, making decisions, and accepting results, while letting AI discover problems, coordinate tasks, and complete execution on its own.
Perhaps the truly mature AI assistant of the future will not always stay in a chat window waiting for questions, but will be like a digital colleague who can participate in work over the long term and knows what it should do even when you do not actively seek it out.
Comments