A Detailed Explanation of Super Agent: It Takes the Initiative to Complete Tasks and Knows Better When to Keep Silent

The DeepSeek Harness team published an article on the evening of October 31, titled "Exploring Super-agent Design: Towards More Autonomous Agent Systems", in which they put forward the concept of Super Agent.

At the same time, they also open-sourced the Super Agent prototype dsh-superagent-prototype on GitHub for developers' reference.

The so-called Super Agent is equivalent to a colleague with extraordinary memory, who stays online 24 hours a day and never slacks off at work.

Even when you move to the next task, it can still remember all the instructions you gave before. It can also perform the same work across different platforms such as various chat apps, emails and GitHub.

"Proactivity" is the core keyword of Super Agent: it does not necessarily wait for your explicit command to start working on certain things.

For example, when it sees someone reporting a Bug in the group chat, even if no one @s the Super Agent, it will first check where the problem is, and fix it directly if it can be solved.

Claude Duet previously launched by Anthropic is still in preview, but it will also proactively check emails and calendars, send you a briefing in the morning, and come to you when it finds important matters at ordinary times.

Agents should not keep waiting for your instructions, which is the common feature of Super Agent and Duet.

But "proactivity" does not mean showing off its presence unnecessarily.

A really easy-to-use Super Agent not only knows when to take the initiative to contact you, but also knows better which things can be handled by itself, under what circumstances it is allowed to disturb you, and when it should keep quiet.

It knows what to do, and also knows when not to bother you.

01

Super Agent vs Ordinary Agent

What Are the Differences?

The difference between Super Agent and ordinary Agent is that the former is like a full-time employee, while the latter is more like a temporary worker.

When you assign a task to an ordinary Agent, it will start to check materials, write codes and give results.

When you have another task next time, even if you call the same Agent, it will start from checking materials again. Even if the ordinary Agent has experienced all the tasks, in the end, only you know the full picture of all tasks.

Because each task is an independent Session, and the Sessions are not connected to each other. The conclusion drawn by the ordinary Agent in Session A is completely unknown to it in Session B. Only you know the full picture of the whole task.

However, the DSH team observed that a person has limited energy, and usually can only follow up 3 to 5 such active Sessions at the same time. Therefore, the problem is not only whether the Agent is smart enough, but also how many Agents you can monitor at the same time, which is also the key to improving the work efficiency of the model.

So what if we let one employee do all the things at the same time?

DSH believes that this is not realistic either. When an ordinary Agent fixes Bugs, writes reports and keeps replying to messages at the same time, the output speed will inevitably slow down. What's worse, the details of several tasks are easy to mix together, leading to a completely mismatched final result.

The first thing Super Agent needs to solve is to assign two roles.

One is called Router, which can be understood as the project supervisor. It is responsible for listening to demands, recording background information, looking at the overall situation, and then deciding who to assign the task to, but it does not do the specific execution itself.

The other is called Worker, which is the employee who actually does the work. Each Worker only takes one task and completes it in its own independent space. The Worker responsible for fixing Bugs focuses on fixing Bugs, and the Worker responsible for writing reports focuses on writing reports, and several Workers can start work at the same time.

It sounds ridiculous, but the fact is that these Workers with different divisions of labor also have different "personalities". Some are easy to communicate with, while others are extremely difficult to communicate with.

So for Super Agent, you only need to deal with the most communicative project supervisor, and you don't have to communicate with each Worker one by one.

Seeing this, you may ask: Isn't this just a main Agent with several sub-agents? A few days ago, Anthropic just published an article titled "Building Agents", whose core point is that a bunch of sub-agents are less efficient than a single Agent.

In fact, the two are completely different.

The main Agent in charge of coordinating sub-agents has a very heavy task, including deeply understanding task details, planning subtasks and high-frequency coordination, so its reasoning burden is very heavy. At the same time, each step of the sub-agents needs to be coupled, which requires the main Agent to coordinate frequently.

The Router doesn't consider those at all. It only cares about "who should I assign this task to". The contexts between Workers are isolated and independent from each other, and they perceive conflicts by subscribing to the same Thread.

Therefore, from the perspective of product logic, Super Agent is completely different from the sub-agent system.

02

Where Does the "Proactivity" of Super Agent Come From?

The second thing Super Agent does is: how does it take the initiative to work when no one gives a specific command?

DeepSeek's approach is to make it pay attention to the movements in the working environment.

Any movement may become a "Trigger". Once Super Agent detects a movement, it will immediately enter the working state.

After the task is assigned, subsequent communication does not have to go through the supervisor all the time. For example, if a Worker has already started to fix a certain Bug, new comments under this topic will go directly to the Worker.

It's just like after the maintenance worker takes the order, you will directly report the problem to the maintenance worker instead of asking the customer service to relay it again.

There is a case in DSH's article, which was also mentioned at the beginning: someone in the group said "There is a BUG in this project". No one @s the Agent, but after this sentence enters the system, it is first filtered by rules, and then judged by the model that it conforms to the "silent reproduction and repair" strategy written in advance by the team.

The project supervisor assigns the task to a Worker, who reproduces the problem, finds the cause and tries to fix it in its own independent space. If the problem is not reproduced, or the repair is found to be very complicated, it will keep quiet. If it confirms the problem and finds a simple solution, it will submit a PR, and finally hand over the result to humans for acceptance.

Later, if someone in the GitHub comment asks to change the repair method, the Worker can also switch from the original chat app scenario to GitHub to continue the work.

The internal example shown in DeepSeek's article is to continuously advance the task between group chat and GitHub in this way, and even take the initiative to submit an application for repair code without being @ed by anyone.

In addition to checking messages in chat apps, Super Agent will also observe all visible information, such as receiving a new email, schedule changes, and failed automatic code checks.

But most of the messages in the group chat are small talks, and the vast majority of them have nothing to do with Super Agent. If the model reads every message, it will be slow and expensive.

So DeepSeek added two screening layers for Super Agent.

The first layer is pre-defined rules: which groups can be viewed, whose messages or robot messages are valid, and which sources should be ignored directly.

The second layer is judged by the model: for the remaining candidate messages, is this sentence just a casual complaint, or is there really a problem that needs to be dealt with?

Such judgments that require semantic understanding cannot be written out with rules. Fortunately, the second screening layer is written in natural language. If you want to change the strategy, you only need to modify one prompt word.

Only after passing both screening layers will the project supervisor assign the task.

Another major feature of Super Agent is to put work in the background, first tell you "I have started working", and then send back the result after finishing. During this period, you can still add requirements, stop the task, or arrange the next thing.

DeepSeek said that this asynchronous task mechanism has been implemented in DSH, but it has not been enabled by default yet.

When you order food in a restaurant, after ordering, the waiter will not stand in front of the stove and wait for the dish to be cooked. He will come back to continue serving other guests, and go to serve the dish to you when it is ready.

Another thing is that DeepSeek believes that Agents need to keep working continuously, so Super Agent needs to stay online all the time and work continuously. But after working for a long time, the context will be too long, and the Agent is prone to make mistakes.

Therefore, DeepSeek separates the "brain" of the Agent, task records and the actual operating computer.

The brain can work in the cloud, task records are saved separately, and codes and files remain on the original computer. In this way, even if a cloud machine restarts, the records are still there. When it is necessary to operate your computer, connect to it remotely.

At the same time, DeepSeek also arranged a Watchdog for Super Agent.

Ordinary monitoring can only check whether the Agent has crashed, while Watchdog also checks whether the task is progressing and whether the direction is deviated.

It's just like a store manager patrolling the store, not only checking whether the light on the stove is on, but also checking how many grams of salt the chef puts and how long he cooks.

However, the dsh-superagent-prototype on GitHub cannot be regarded as the "complete form" of Super Agent. DeepSeek said that it is only a research prototype, not an official product. At present, it mainly targets one GitHub repository, and can also choose to access Feishu. Some designs in the article have not been implemented yet.

03

The Most Powerful Ability of Super Agent Is "Keeping Silent"

There is a sentence in the documentation of the GitHub prototype: Occupy human attention as little as possible, and provide as much value as possible.

DeepSeek regards every message, every notification, every question and every setting item as a kind of attention cost. If it cannot provide sufficient value, it should be deleted.

The prototype also clearly stipulates that the Agent keeps quiet when working, and only speaks again when the result is available, human decision is needed, or the task cannot be completed.

This is almost the opposite of the logic of past Internet products.

In the past, when making products, people often hoped that you would open the app more often. What Super Agent wants to do is to help you handle things so that you open the app less often.

A really practical Agent should not summarize 20 group chat messages into another 20 notifications and let you confirm them one by one. It should finish most of the things first, and you only need to make the decisions that no one but you can make.

Therefore, the core of Super Agent's proactivity is not "talking a lot", but that it knows when not to disturb you.

There is an example of "silent reproduction and repair" in DeepSeek's article.

The Agent can first reproduce the Bug and find the repair plan in the background, but it will only deliver the result after confirming the problem and finding a simple solution, otherwise it will keep quiet the whole time.

An ordinary Agent may reply "Received, I'm analyzing" as soon as it sees the message, send a process description ten minutes later, and tell you that the problem has not been reproduced half an hour later.

Yes, this ordinary Agent is very busy, and I feel tired just watching it, but you are really bothered by it for a long time.

But the information generated by the Agent is not equal to the value provided by the Agent. Super Agent is redefining the relationship between humans and AI: humans should not work as secretaries for AI.

DeepSeek repeatedly emphasizes a concept: Sessions should be managed by the system in the background, and users should not worry about them.

The article mentions that "From this perspective, letting users manually manage Sessions is largely a design inertia inherited from the underlying LLM API". This sentence means that the session is not the correct product form, it is just a habit left by the early large model API.

Since what users really want to manage is tasks, the system should manage sessions by itself, and humans only need to check whether things are done.

With Super Agent, you don't need to specially open a certain AI application every day. It can work on its own in group chats, code repositories and emails.

Of course, the more proactive the Agent is, the more important its sense of boundary becomes.

DeepSeek's Super Agent has such a rule: Super Agent acts only when requested, or permitted by written rules. For tasks that are not directly required by anyone, the team needs to write down the rules in advance.

It's just like when you recruit a new employee, at the beginning, you ask him to write the plan first, and you have to review it. Only after confirming that he understands the task, will you gradually delegate power to him. Which results need to be approved, and which operations must be stopped to ask for instructions, must be made clear in advance.

Anthropic's Duet follows the same idea. It can read information, draft replies and prepare work on its own, but before sending messages, making payments, signing documents or deleting content, it must wait for human approval.

It proactively provides a briefing every morning, and checks every few hours to avoid the background task consuming the quota quickly.

"Keeping silent" does not mean insufficient ability, on the contrary, it is a more advanced product capability. It is a kind of restraint: it does not broadcast the process when there is no result, does not act without authorization when there is no permission, and does not create new messages when it is not necessary.

And restraint is also the keyword of Liang Wenfeng. At the previous investor exchange meeting, Liang Wenfeng said: "The more restrained you are, the more likely you are to build AGI successfully."

However, one point must be reminded: Super Agent uses more tokens in exchange for human time and attention.

DeepSeek said that the multi-Session design will bring more token consumption. Duet's morning briefing and background checks will also occupy the user's package quota.

This article is from the WeChat official account "Letter AI", author: Miao Zheng, editor: Wang Jing, published with authorization from 36Kr.