The DeepSeek Harness team proposes the Super Agent design and open-sources a prototype

On the evening of October 31, the DeepSeek Harness team published an article titled "Super-agent Design Exploration: Toward a More Autonomous Agent System," in which they proposed a concept: 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 an exceptional memory who is online 24 hours a day and never slacks off or cuts corners.

Whatever you assigned before, it can still remember even when it comes to the next task. It can also carry out the same piece of work across various chat apps, email, GitHub, and other different places.

"Proactive" is the core keyword of Super Agent; some things don't necessarily have to wait until you give it an order before it goes to do the work.

For example, if it sees someone reporting a bug in a group chat, even if no one @-mentions Super Agent, it can first go look at where the problem is, and if it can fix it, it will just go ahead.

Anthropic's previously launched Claude Duet, although still in preview, also proactively checks email and calendars, gives you a briefing in the morning, and comes to you when it finds something important.

An Agent shouldn't always wait for you to speak; this is a commonality between Super Agent and Duet.

But "proactive" does not mean constantly making its presence felt.

A truly useful Super Agent not only needs to know when it should proactively reach out to you, but even more so needs to know which things it can handle itself, under what circumstances it is allowed to disturb you, and when it should stay quiet.

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

What is the difference between a Super Agent and an ordinary Agent?

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

When you assign a task to an ordinary Agent, it will start looking up information, writing code, and giving results.

When you have something else next time, even if the one you call over is still it, it will again start from looking up information. Even if an ordinary Agent goes through everything, in the end, you are still the only one who knows the full picture of all the tasks.

Because each task is an independent session, and sessions are not connected to one another. A conclusion an ordinary Agent reaches in Session A is completely unknown to it in Session B. Only you know the full picture of the entire task.

But the DSH team observed that a person's energy is limited, and usually one can only follow 3 to 5 such active sessions at the same time. So the problem is not just whether the Agent is smart enough; how many Agents you can keep an eye on at the same time is also a key point in improving the model's work efficiency.

Then what if one employee does everything at the same time?

DSH believes this is also unrealistic. If an ordinary Agent is fixing a bug, writing a report, and constantly replying to messages at the same time, its output speed will inevitably slow down, and what's more frightening is that the details of several tasks can easily get mixed together, causing the final result to be completely irrelevant.

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

One is called Router, which can be understood as a project supervisor. It is responsible for listening to requirements, recording background, and looking at the overall situation, then deciding who to hand the task to, but it does not personally carry out specific execution.

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

There is a saying that sounds rather absurd, but the fact is that these Workers with different divisions of labor also have different "personalities." Some are easy to communicate with, and some are extremely difficult to communicate with.

So with Super Agent, you only need to deal with the project supervisor who is easiest to communicate with, 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 leading several sub-agents? A few days ago, Anthropic just published an article titled "Building Agents," whose core point is that having a bunch of sub-agents is not as efficient as a single Agent.

In fact, the two are completely different.

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

Router does not consider those things at all; it only cares about "who should I push this work to." Workers have isolated contexts and are independent of each other, and they perceive conflicts by subscribing to the same Thread.

So from a product logic perspective, Super Agent and sub-agents are completely different things.

Where does Super Agent's "proactiveness" come from?

The second thing Super Agent does is: when no one specifically gives an order, how does it proactively go to do work?

DeepSeek's approach is to have it pay attention to activity in the work environment.

Any activity can become a "trigger." Once Super Agent detects activity, it will immediately enter a working state.

After a task is dispatched, subsequent communication does not have to go through the supervisor every time. For example, if a Worker has already started fixing a certain Bug, then new comments under that topic will go directly to the Worker.

It is like after a repair technician accepts a work order, you report the problem directly to the repair technician, and there is no need to have customer service relay it again.

There is a case in the DSH article, also mentioned at the beginning, where someone in the group said: "This project has a BUG." No one @-mentioned the Agent, but after this sentence entered the system, it first went through rule filtering, and then the model judged that it matched the "silently reproduce and fix" strategy written in advance by the team.

The project supervisor assigns the task to a Worker, and the Worker, in its own independent space, reproduces the problem, looks for the cause, and tries to fix it. If it cannot reproduce the problem, or finds that the fix is very complex, it stays quiet. If it confirms the problem and finds a simple solution, it submits a PR, and finally hands the result to a human for acceptance.

If someone later asks in a GitHub comment for a different fix, the Worker can also switch from the original chat software scenario to GitHub and continue working there.

The internal example shown in the DeepSeek article is exactly like this: it continuously advances the task between group chat and GitHub, and even proactively submits a request to fix code without anyone @-mentioning it.

In addition to looking at messages in chat software, Super Agent also observes all the information it can see, such as receiving a new email, a schedule change, or an automatic code check failing.

But most messages in group chats are casual chatter, and the vast majority have nothing to do with Super Agent. If every message were read by the model, it would be slow and expensive.

So DeepSeek added two filters to Super Agent.

The first is a set of pre-defined rules: which groups can be viewed, whose messages or which bots' messages count, and which sources are directly ignored.

The second is left to the model to judge: among the remaining candidate messages, is this sentence just a casual complaint, or is there really a problem that needs to be handled?

Judgments of this kind that require understanding semantics cannot be written as rules. Fortunately, the second filter is written in natural language, so if you want to change the strategy, you just change one prompt.

Only after passing both filters will the project supervisor dispatch a task.

Another major feature of Super Agent is that it puts work in the background: it first tells you "I have started working on it," and then sends the result back when it is done. During this period, you can still add requirements, stop it, or arrange the next thing.

DeepSeek says that this asynchronous task mechanism has already been implemented in DSH, but is not yet enabled by default.

When you go to a restaurant and order food, the waiter cannot stand in front of the stove waiting for the dish to be finished. He will go back to continue serving other guests, and only when the dish is ready will he bring it to you.

There is another point: DeepSeek believes that an Agent is meant to keep working continuously, so Super Agent especially needs to be always online and continuously working. But after working for a long time, the context becomes too long, and the Agent is very likely to make mistakes.

Therefore, DeepSeek separates the Agent's "brain," task records, and the computer on which it actually operates.

The brain can work in the cloud, task records are stored separately, and code and files remain on the original computer. In this way, if a certain cloud machine restarts, the records are still there. When it needs to operate your computer, it then connects remotely.

At the same time, DeepSeek also assigned a Watchdog to Super Agent.

Ordinary monitoring can only see whether the Agent has crashed, while the Watchdog also needs to see whether the task is making progress and whether the direction has gone off track.

It is like a store manager inspecting a store: not only checking whether the stove light is on, but also checking how many grams of salt the chef put in and how long it was cooked.

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

Super Agent's strongest ability is "shutting up"

In the README of the GitHub prototype, there is this sentence: occupy as little human attention 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 enough value, it should be deleted.

The prototype also explicitly stipulates that the Agent stays quiet while working, and only speaks again when the result is usable, a human decision is needed, or the task cannot be completed.

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

In the past, when making products, companies often wanted you to open them more. What Super Agent wants to do is help you get things handled, so that you open it less.

A truly useful Agent should not summarize 20 group messages into another 20 notifications and then make you confirm them one by one. It should first finish most of the work, and you only need to make the decision that no one but you can make.

So the core of Super Agent's proactiveness is not "talking more"; it is knowing when it should not disturb you.

There is an example in the DeepSeek article called "silently reproduce and fix."

The Agent can first reproduce the Bug in the background and look for a fix, but it delivers the result only after confirming the problem and finding a simple solution; otherwise, it stays quiet the whole time.

Switch to an ordinary Agent, and it might reply "Got it, I'm analyzing it now" as soon as it sees the message, then ten minutes later send over a chunk of process, and half an hour later tell you it couldn't reproduce the issue.

Yes, this ordinary Agent is very busy—I get tired just watching it—but it really did put you through the wringer for quite a while.

But the information an Agent produces is not actually equal to the value an Agent provides. Super Agent is redefining the relationship between people and AI; people should not be serving as AI's secretary.

DeepSeek repeatedly emphasizes one concept: Sessions should be managed by the system behind the scenes, and users should not have to worry about them.

The article mentions that "from this perspective, making users manually manage Sessions is to a large extent a design inertia inherited from the underlying LLM API." What this means is that the session is not the correct product form; it is merely a habit left over from the early large-model APIs.

Since what users really want to manage is tasks, the system should manage sessions itself, and people only need to see whether things have been completed.

With Super Agent, you no longer need to deliberately open some AI application every day; as long as it is in the group chat, the code repository, and email, it can work on its own.

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

DeepSeek's Super Agent has this rule: Super Agent acts only when requested, or when written rules permit it. For tasks that no one directly requests, the team needs to write the rules in advance.

This is like hiring a new employee. At first, you have him write a plan, and you have to review it first. Only after confirming that he understands the task do you gradually delegate authority to him. Which results need approval and which operations must stop and ask a person must all be spelled out 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 prevent background tasks from quickly burning through the quota.

"Shutting up" is not a lack of capability; it is precisely a more advanced product capability. It is a form of restraint: when there is no result, do not broadcast the process; when there is no permission, do not act on your own; when it is not necessary, do not create new messages.

And restraint is also a keyword for Liang Wenfeng. At an earlier investor exchange meeting, Liang Wenfeng said: "The more restrained you are, the more likely you are to achieve AGI."

However, one thing must be pointed out. Super Agent is using more tokens in exchange for people's time and attention.

DeepSeek states that the multi-Session design will bring more token consumption. Duet's morning briefing and background checks likewise consume the user's plan quota.