DeepSeek shows an AI manager that hands work to AI workers and fixes bugs unprompted

What DeepSeek described

As Ifanr reported, DeepSeek's Harness team published a technical article on what it calls a Super-agent. The idea is an AI agent that stays online, works on several tasks at once and acts when something happens in the outside world, rather than living inside one chat window.

DeepSeek says it already runs an internal version built on its Harness software for everyday development work. If a teammate mentions a software problem in a group chat, the agent can spot a likely bug without being tagged. It tries to reproduce the problem in the background and may open a pull request on GitHub, which is a proposed code change that waits for a developer's review.

The same task can also continue across tools. A developer settles on an approach in chat, then changes the requirements in a GitHub comment, and the agent follows the change. DeepSeek is clear that this is an architecture exploration. Some of it exists as an open-source prototype, but it is not a standalone product.

The human attention problem

DeepSeek's starting point is that AI can now handle more tasks at once than a person can supervise. Most agents still work in sessions, meaning separate conversations. You switch between windows, remember what each one is doing and keep checking progress.

DeepSeek's own observation is that a person can usually follow only 3 to 5 active sessions. Connecting agents to more tools does not fix the deeper problems it lists: tasks run one at a time within a session, context gets muddled across tasks, and work stops when your local machine goes offline.

The Super-agent is meant to behave like one continuous helper. DeepSeek lists four needed abilities: continuing across sessions, running many tasks in parallel, reacting to events, and staying online with recovery from failures. People would set goals and accept results, while the AI handles scheduling and execution.

A manager AI and its workers

The design has two layers. The Router runs continuously, takes in messages from chat, GitHub and email, decides who should handle what, and keeps track of context across tasks. Workers do the actual jobs, such as reproducing a bug, reviewing code or building a feature. Each has its own context and tools, and can call further helper agents.

When a Worker finishes, it reports key results to the Router, which talks to the user. You see one assistant, while several agents may be working behind it. To cut coordination overhead, a Worker that takes over a pull request can subscribe to later comments and status changes directly. DeepSeek also notes that the Router's job is mostly understanding and assigning, so a lighter model may be enough, with stronger models saved for hard tasks.

For the event-driven part, DeepSeek uses two filters. Simple programmed rules throw out irrelevant messages first. Then a language model, looking at context, decides whether action is needed. That matters because most chat messages need no AI involvement.

Working ahead of the request

The most unusual idea borrows speculative execution from computer design: start work before you know whether the result will be used, keep it if it is useful and drop it if not. DeepSeek set up a 'silent reproduce and fix' policy in an internal group. When someone reports a bug, the agent tries to reproduce it and find a fix in the background. It speaks up only if the problem is real and the fix looks fairly simple. In one example, the fix pull request appeared while teammates were still discussing solutions.

DeepSeek suggests the same pattern could help a personal assistant. After a meeting invitation arrives, it could check your calendar, gather background and draft a reply for your approval.

Other pieces target reliability. An asynchronous loop pushes slow tool calls to the background so the agent keeps taking new instructions, and you can redirect or stop it mid-task. DeepSeek says this is built into Harness but not on by default. The agent's loop runs in the cloud, session state sits in a database, and code and files stay on your device behind a small helper program. If your computer goes offline, tasks resume when it returns. A separate Watchdog checks for progress or pointless loops and tries to repair problems.

What the test showed, and what it did not

DeepSeek ran a preliminary experiment with a stream of about 300 simulated chat and GitHub CI messages, of which about 20 were real work requests. It compared the Super-agent with a conventional single session plus helper agents, running each setup five times.

The Super-agent's median completion time (p50) was 12.4 minutes, and its slow-end time (p95, a measure of the slower runs) was 15.7 minutes. The single-session setup with neutral instructions had a p95 of 29.5 minutes. DeepSeek attributes the gap to scheduling: in all five runs of that baseline, the model never called a helper agent, so everything piled into the main session and kept getting interrupted by new messages.

There was a price. Because many separate sessions must be maintained, cache-read token use went up. In one variation, with a shortcut for events removed, the Router's decisions rose about 30% and total cache reads climbed from 2323 万 to 3177 万 tokens (万 means ten thousand), a rise of about 37%. Meanwhile, when incoming events rose from about 1 per minute to 40, the Router handled them in batches and request time went only from 2.5 seconds to 3.9 seconds.

The caveat is important. The test used synthetic messages and simulated slow tools, so it checks scheduling and teamwork, not the quality of real code.

Open problems

DeepSeek lists several unsolved issues. Long-term memory is one: after weeks or months of work, restoring the right history is hard. Security is another. An agent that constantly reads outside messages and reaches your devices through the cloud could be hurt by prompt injection (hidden instructions planted in text the AI reads) or by a server breach, putting code, data and credentials at risk.

Oversight is the third. If an agent runs many tasks, people need new ways to see progress, step in and decide which actions need approval. DeepSeek also admits it proposes no new theory. It applies familiar computing ideas, including scheduling, caching, event-driven design and separating storage from compute, to agents.