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

Explaining Super Agent: It takes initiative to work, and better understands when to keep quiet. Letter List downloads the client. Exclusive early access. November 1, 2026, 12:47:49, from Beijing.

The DeepSeek Harness team published an article on the evening of October 31 titled "Super-agent Design Exploration: Toward a More Autonomous Agent System," in which they proposed 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.

A so-called Super Agent is equivalent to a colleague with an exceptional memory, online 24 hours a day, who never slacks off or cuts corners.

Whatever you previously assigned, even in the next task, it can still remember. 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 do not necessarily have to wait until you give it an order before it goes to 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 see where the problem lies, and if it can fix it, it directly takes action.

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 should not always wait for you to speak. This is the common point of both Super Agent and Duet.

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

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

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 starts 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 again has to start from looking up information. Even if an ordinary Agent goes through everything, in the end, only you yourself know the full picture of all the tasks.

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

But the DSH team observed that a person's energy is limited and they can usually 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 key to improving the model's work efficiency.

Then what if one employee does all the things 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. Even more frightening, the details of several tasks can easily get mixed together, causing the final result to be completely irrelevant and incoherent.

The first thing Super Agent needs to solve is allocating 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 picture, then deciding who the task goes to, but it does not personally do the specific execution.

The other is called Worker, which is the employee who actually does the work. Each Worker takes only one task and completes it in its own independent space. Those fixing bugs focus on fixing bugs, those writing reports focus 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 most easy-to-communicate project supervisor, and do not have to communicate with each Worker one by one.

At this point, 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 was that a bunch of sub-agents is less efficient than a single Agent.

In fact, the two are completely different.

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

Router does not consider any of that 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 matters.

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 work?

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

Any activity could become a "Trigger." Once Super Agent detects activity, it immediately enters working mode.

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

It's like when you place a repair order with a technician: you report the problem directly to the technician, and there is no need to have customer service relay it again.

In the DSH article there is a case, 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 passed 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 there.

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

In addition to watching 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 automated 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 pre-set rules: which groups it can see, 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 an offhand complaint, or is there really a problem that needs to be handled?

For this kind of judgment that requires understanding semantics, rules cannot write it out. Fortunately, the second filter is written in natural language, so if you want to change the strategy, you just change one prompt.

Only after both filters are passed 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've started working on it," and when it is done it sends the result back. During this period, you can still add requirements, call it off, 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 one more thing: DeepSeek believes that an Agent is meant to keep working continuously, so Super Agent in particular must stay online and keep working. But after working for a long time, the context becomes too long, and the Agent is very prone to errors.

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 connects remotely.

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

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

It's like a store manager doing a store inspection: 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 it is only a research prototype, not an official product. At present it mainly targets one GitHub repository, and can optionally connect to Feishu. Some of the designs in the article have not yet been implemented.

Super Agent's strongest ability is to "shut 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, the usual hope was that you would open them more. What Super Agent wants to do is handle things for you so that you open them 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 only you can make.

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

In the DeepSeek article there is an example of "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 it has confirmed the problem and found a simple solution; otherwise it stays quiet the whole time.

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

Yes, this ordinary Agent is very busy, and I get tired just watching it, but you really did get dragged around by it 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 secretaries for AI.

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 sentence means is that a session is not the correct product form; it is merely a habit left over from 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 group chats, code repositories, and emails, 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 the beginning, you have him write a plan first, 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 clarified 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 once every few hours, to prevent background tasks from quickly burning through the quota.

"Shut up" is not a lack of capability; it is precisely a more advanced product capability. It is a kind 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 unnecessary, 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 point must be noted. 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 will likewise consume users' plan quotas.

"Special statement: The above content (including videos, pictures, and audio if any) is uploaded and published by users of Dafeng Hao, a self-media platform under Phoenix Net. This platform only provides information storage space services.

Notice: The content above (including the videos, pictures and audios if any) is uploaded and posted by the user of Dafeng Hao, which is a social media platform and merely provides information storage space services."