DeepSeek Releases Super-agent Prototype to Handle Coding Tasks in Parallel

A coding agent built to manage several jobs at once

DeepSeek's Harness team published its Super-agent design on October 31, 2026, alongside an MIT licensed research prototype that turns requests for a GitHub repository into separate coding sessions. The aim is to let several jobs move forward together while developers spend less time switching between conversations and checking progress.

The team's preliminary experiment used about 300 simulated messages containing roughly 20 work requests. Super-agent completed half the tasks within 12.4 minutes and 95% within 15.7 minutes. A comparison system using one main session with access to a helper agent took 29.5 minutes to reach the 95% mark under neutral instructions.

DeepSeek's public prototype repository, named dsh-superagent-prototype, sets out a narrower, practical release: a proactive coding agent for one GitHub repository, packaged as a bundle for DeepSeek Harness. It listens to GitHub and optionally Feishu, opens a work item when an authorized person requests work, and responds in the original conversation, potentially with a pull request proposing code changes.

The README also gives a firm warning. The published code differs from the internal system and from parts of the design essay. Some proposed features remain future work, and DeepSeek describes the release as research code rather than a finished product.

The DeepSeek Harness team, which maintains the prototype, states its status in the README:

Research prototype for reference only, not an official DeepSeek product.

For developers, the release offers code to inspect and adapt. Its central experiment concerns how an agent organizes work, remembers related conversations and decides when a person needs to step in.

Why DeepSeek wants to hide the session management

DeepSeek's design starts with an observation from its own work: a person can usually follow only three to five active agent sessions at once. Each session holds its own conversation history, so the developer must remember which task belongs where and which instructions each agent has received.

A harness is the software around an AI model that manages tools, files, conversations and execution. The model reasons about a task; the harness determines how the task reaches it and how its actions run. Super-agent moves more of the responsibility for coordinating several jobs into that surrounding software.

The team names four goals: continuity across conversations, efficient parallel execution, proactive responses to events and persistent operation with recovery from faults. One example involves developers choosing a plan in a chat and later changing it in a GitHub comment. The system should connect those exchanges and adjust the same task.

The release follows DeepSeek's October 3 experiment with Claude Code extension compatibility in Harness v0.2.1-alpha.1. That update tested a bridge for extensions; Super-agent explores how the harness itself can coordinate ongoing work. Yujia Qiao is credited with implementing the system and writing the design essay, with 15 other people listed as review and discussion participants.

One Router coordinates, several Workers execute

Super-agent divides responsibility between a resident Router and separate Workers. The Router receives human interactions, maintains information shared across tasks and assigns work. It avoids doing the coding itself, keeping the coordination role available while other sessions are busy.

Workers handle the individual jobs. Each has its own conversation context and execution tools, allowing a bug investigation, a code review response and a feature change to proceed concurrently. Workers report results to the Router, which communicates with people rather than letting several sessions independently reply.

DeepSeek suggests that a lighter model can often handle routing, while stronger models perform the work that determines code quality. A Worker can also create helper agents for a complicated assignment. The Router manages relationships between jobs rather than planning every step inside them.

The prototype gives each work item its own session and directory, with launches running concurrently up to a configured limit. Operators therefore control how much work starts together. Separate conversation histories reduce the chance that details from one task crowd out another, while the Router preserves the shared view.

How messages become tasks without constant interruptions

Chat messages, code review comments and automated test results become events that can trigger action. The broader design also considers email and calendar reminders. Continuous integration, or CI, refers to automated checks that build or test code after a change, producing results an agent can respond to.

DeepSeek filters these events in two stages. Ordinary program rules first check matters such as the source, group and authorized users. A model then evaluates the remaining candidates using context and written policies. This saves model calls on routine messages that require no action.

Related events form a Thread, such as the comments under one pull request or one chat topic. Once a Worker takes the assignment, it subscribes to that Thread. Later comments and test results can go straight to it without asking the Router to assign them again.

Subscriptions can overlap. Several Workers touching the same pull request can receive the same updates, giving them a way to notice changes that affect their work. A Worker can also follow several related Threads, or return an event to the Router when it falls outside its assignment.

Acting early, but speaking only when useful

DeepSeek says an internal Super-agent already runs continuously, reproducing and fixing problems, responding to code reviews and helping develop Harness itself. A written rule allows it to investigate bugs mentioned in a group chat even when nobody directly tags the agent.

The rule calls for quiet investigation first. The agent tries to reproduce the reported problem and find a simple fix, then presents a useful result. In one example, developers were discussing a problem in which tildes appeared as strikethrough formatting while the agent had already opened a pull request with a proposed repair.

The Harness team describes the operating principle in its README:

take as little human attention as possible, and give as much value as possible.

The prototype acts when an authorized person asks or when a rule written by the team permits it. Its web panel lists work items needing human attention. This concentrates the interface on decisions and usable results, rather than every tool call or intermediate thought.

Keeping old context and new instructions available

DeepSeek's design treats a model's context window, the limited amount of information it can consider at once, like a cache. Frequently needed material stays close at hand; longer or less relevant history remains outside the window until requested.

The essay calls these operations Inline and Spill. Inline places useful details directly in the current context, such as nearby chat messages, identifiers or a short preview. Spill leaves longer content elsewhere with a reference the model can follow to read more.

Chain of Recall links those references. Events, Threads and Worker sessions receive unique identifiers, letting the agent move from a current message to its discussion, then to a related Worker and another code review. The goal is to recover an old task across channels without repeatedly loading its entire history.

DeepSeek also addresses a more immediate interruption problem: a long command can block a conventional agent from responding. Its asynchronous mechanism starts work in the background and sends the result back as a new event. Users can continue issuing instructions, including asking the agent to change direction or stop.

The team says this mechanism is implemented in DeepSeek Harness but is not enabled by default. Communication rules also vary by channel: the design caps a single instant messaging reply at 100 words, while pull requests and documents receive more structured explanations of changes and verification.

Cloud coordination with work on a local computer

DeepSeek separates the computation running the agent, the stored session history and the machine where commands execute. The proposed agent loop runs in cloud containers, session state lives in a database, and a lightweight local service executes commands and returns results.

This arrangement supports Bring Your Own Machine, or BYOM. A developer can connect an existing computer containing the repository, tools and unfinished changes instead of moving everything into a new remote environment. Cloud coordination can remain available when that computer disconnects, while tasks requiring it wait for the device to return.

An independent Watchdog session checks for failures and stalled work. Its purpose goes beyond detecting an error message: it uses model judgment to assess whether Workers are making real progress or drifting away from the goal, then attempts recovery when needed.

DeepSeek presents these elements as parts of its broader architecture exploration. The README warns that the public bundle and the internal implementation differ, so developers need to check the released code before relying on a particular design feature.

What the experiment measured

DeepSeek repeated each experimental setup five times, comparing Super-agent with a version lacking direct event delivery and two configurations of a single session equipped with a helper agent. The workload used synthetic messages and a tool simulating lengthy coding work. Message intervals and work durations were scaled to one quarter.

The 12.4 minute median means half the tasks finished by that point. The 15.7 minute 95th percentile means 95% finished within that time. Compared with the neutral single session's 29.5 minute 95th percentile, Super-agent reduced that measure by 13.8 minutes, or about 47%.

Delegation behavior helps explain the result. Under neutral instructions, the single session never called its helper agent in any of the five runs. When prompted to prioritize delegation, it delegated in four runs and handled the work itself in the fifth. Super-agent makes the separation between coordination and execution a structural choice.

The tests evaluated scheduling and coordination with simulated execution. Real coding quality, independent performance measurements and active user numbers remain unreported, while the team labels its measurements preliminary. DeepSeek has given no date for a production release.

Faster coordination uses more cached tokens

Super-agent's concurrency came with greater use of cached input. It read 23.23 million cached tokens, compared with 6.05 million and 10.82 million for the two single session configurations. Tokens are the small units of text a model processes; cached reads reuse input retained from earlier requests.

Removing direct event delivery increased cached reads from 23.23 million to 31.77 million, about 37%, and increased Router decisions by roughly 30%. Sending follow-ups straight to the assigned Worker therefore saved coordination work within the parallel design.

Batching helped the Router manage heavier traffic. As event arrival rose from about one to 40 triggers per minute, average batch size increased from 1.0 to 2.8 and request duration rose from 2.5 to 3.9 seconds. The reported inference time allocated to each Router decision fell from 6.4 to 1.6 seconds.

The practical tradeoff is between less waiting for people and more model processing across separate sessions. The token figures do not provide a monetary bill; teams considering deployment would need to account for their model prices, concurrency settings and actual workload.

Local permissions make security a central concern

The prototype's execution documentation says Worker commands run without approval under the operator's operating system account. Foreground shell commands move into background execution after five seconds, and background work gets up to 30 minutes per turn. These settings make the operator's account permissions a concrete deployment concern.

A connected machine may hold credentials, private code and sensitive files. Prompt injection, in which hostile content tries to redirect an agent through material it reads, becomes especially serious when incoming messages or repository content can influence commands on that machine.

DeepSeek identifies security and privacy, Router scaling, memory over long periods and communication between agent instances as unfinished areas. Its README asks users to review and adapt the code, warning that bugs and inconsistent engineering practices may remain. Much of the engineering was itself done by coding agents.

The launch drew rapid attention, including a post by Hugging Face head of research Leandro von Werra. The sequence shows how quickly the prototype spread:

• October 31, 2026, at 09:32 UTC: the GitHub repository was created.
• October 31: the Harness team published its design essay; by 22:10 UTC, the repository had 2,046 stars and 172 forks.
• November 1, at 04:20 UTC: the repository had reached 3,433 stars.

For engineering teams, the immediate decision is whether to inspect and adapt an experimental coordination system. Its appeal is the prospect of handling more jobs with fewer interruptions; its operating demands include reviewing code, setting permissions and deciding which actions need a person.

Key Points

• DeepSeek released an MIT licensed research prototype for coding work in one GitHub repository, with optional Feishu integration.
• A Router handles coordination while separate Workers execute tasks concurrently.
• The internal system can investigate reported bugs under written rules without being directly tagged.
• Synthetic tests recorded a median completion time of 12.4 minutes and a 95th percentile of 15.7 minutes, with higher cached token use than single session alternatives.
• Workers execute commands under the operator's account without approval, making permissions and credentials central concerns.
• The public code differs from the internal system and remains a research prototype rather than an official DeepSeek product.