DeepSeek's New Coding Agent Does Not Wait to Be Asked, It Watches the Team Chat and Opens the Pull Request Itself


Every coding agent so far waits for you. This one is built not to.

The pattern of AI coding tools has not changed since the first assistant shipped: a developer notices a problem, opens a session, writes a prompt, and supervises what comes back. The human is the trigger for every unit of work, and human attention is the bottleneck the whole system runs on.

On Saturday, October 31, DeepSeek’s Harness team published a prototype built on the opposite assumption. Super-agent, released as open source under the MIT license alongside a design essay titled “Super-agent Design Exploration: Towards More Autonomous Agent Systems”, lives inside a team’s daily workflow. It listens to one GitHub repository and, optionally, to Feishu group chats. It watches issues, review comments and conversation go by, decides which are real work, and in DeepSeek’s internal deployment it reproduces bugs, finds the root cause, and submits a pull request with a fix, without anyone tagging it or asking.

The user manual states the goal in one line: take as little human attention as possible, and give as much value as possible. That sentence is the product. DeepSeek is not claiming its model writes better code than Anthropic’s or OpenAI’s. It is claiming the scarce resource in software development is no longer the model’s ability to answer, but the human’s willingness to keep asking.

What was actually released

Precision matters here, because the headline version of this story is bigger than the shipped code. What DeepSeek published is a research prototype, and the team says so repeatedly:

  • The package is dsh-superagent-prototype, a TypeScript bundle at version 0.1.0, published in a single commit under the MIT license. It runs as a profile on DeepSeek Harness, the company’s open-source agent runtime, itself in developer preview. The repository passed 4,000 GitHub stars within a day.
  • It brings no model of its own. The router and the workers use whichever model the Harness profile is configured with, and can be pointed at different models.
  • It is self-hosted, not a service. Operators run it on their own machines, for a single GitHub repository. Setup needs Node.js 22.19 or later, git 2.32+, Python 3.8+, pnpm, tmux and the GitHub CLI. Only github.com is supported, not GitHub Enterprise Server.
  • The public code is not the internal system. DeepSeek says it was adapted for publication, differs from the version the team runs, and that some ideas in the essay are future directions rather than shipped features. The README calls it research code, not production-ready, and not an official DeepSeek product.

The internal system is the more ambitious one. DeepSeek says it already runs its own Super-agent in daily development work, where it reads feedback in group chats, reproduces and fixes reported bugs, responds to code reviews, and helps build DeepSeek Harness itself. The prototype is the public sketch of that system.

The guardrail is a setting, and the default is “watch only”

A proactive agent raises an obvious question: what stops it acting on things nobody wanted done? DeepSeek’s answer is an accept mode that controls work the agent was not directly asked to do:

  • Off: nothing inferred becomes a candidate for work.
  • Observe (the default): the agent assesses inferred work and records it as “would accept”, but nothing executes. You get a log of what it would have done, and a chance to judge its judgement before it touches code.
  • Auto: a positive assessment is executed.

The repository states the rule plainly: the agent acts only when asked, or when a rule the team wrote allows it, and speaks only when someone must act or can use a result. Requests from people on an allow list are handled in every mode. That is the most transferable idea in the release. Proactivity is not a personality trait to bolt onto a model; it is a permission level, with a safe default, an audit trail in observe mode, and an explicit step up to autonomy when a team decides the agent has earned it.

Router and workers, borrowed from operating systems

Architecturally, Super-agent splits the job in two. A persistent router handles all interaction with people: it receives events, decides which task goes where, and replies on behalf of the workers, so concurrent jobs do not produce a jumble of competing answers in one thread. Isolated worker sessions do the execution, each in its own session and directory. Once assigned, a worker subscribes directly to the thread it owns, a pull request or a chat topic, and receives follow-up events itself.

Events, not prompts, drive the system. Messages, review comments and CI results are filtered first by deterministic rules and then by a model, so only candidates worth acting on reach reasoning. The team borrowed from classic computer science: scheduling, caching, storage and compute separation, and watchdog processes, aimed at keeping one agent running continuously across many tasks instead of living and dying inside a single chat session. The agent can also try a fix speculatively in the background, staying silent unless it confirms the problem and finds a workable solution.

The early numbers, from the team’s own tests, show both the payoff and the price:

  • Completion time: in a simulated stream of about 300 messages containing roughly 20 real work requests, Super-agent finished half its tasks in a median 12.4 minutes, with a 95th percentile of 15.7 minutes, against up to 29.5 minutes for a single session using a subagent tool. In a router stress test, trigger rates pushed from about one per minute to about 40 barely moved single-request time, from 2.5 to 3.9 seconds, because queued events can be merged.
  • The trade-off is tokens. Multiple persistent sessions cost more cache reads than a single session, and removing the workers’ direct-subscription shortcut raised router workload and token use by about 37 percent. The design spends compute to buy shorter, more stable completion times.

Read those numbers with the caution the team itself applies: the workloads were synthetic, the tools simulated, and real-world coding quality was not measured. The tests support a claim about coordination, not about code. Nobody outside DeepSeek has yet shown that the fixes this agent proposes unprompted are fixes a senior engineer would merge.

The uncomfortable part: it runs with your permissions

Self-hosting cuts both ways. Both presets run with “danger-full-access” as the operator’s operating system user. A worker can execute programs by path and read the operator’s home directory. The documentation recommends a dedicated operating system account holding only the agent’s credentials, and that should be read as a requirement, not a tip.

DeepSeek lists four open problems itself, and they are the right four: scaling the design once a single router can no longer keep up; collaborating with an agent that no longer lives in a chat window; drawing context boundaries as an organisation grows; and securing agents that reach into users’ own machines, where uncommitted changes and local credentials live. Add the political layer: on October 19, the US Department of Homeland Security ordered federal civilian agencies to remove DeepSeek products, and tools built using them, from government devices, citing data transfer concerns. Open source does not by itself settle that question for regulated buyers.

Why this release, why now

DeepSeek formed the Harness team earlier this year to build agents that compete with coding products from the leading American labs, and Bloomberg reports the company has raised about 100 billion yuan (about $15 billion) ahead of a planned IPO. Claude Code is the target in plain sight, and customers like Rakuten report time to market for new features falling from 24 working days to 5 with it. Rakuten’s engineers are now building an ambient agent that splits large jobs across 24 parallel Claude Code sessions, the same wager DeepSeek is making.

That convergence is the real story. The competition has moved past the chatbot and past the prompt, to who owns the layer that notices work, assigns it, and follows up. The tool that captures the least human attention per finished task wins the workflow, whatever model sits underneath.

What to do with this, this week

  • If you lead an engineering team: the idea to steal is not the code, it is the permission ladder. Any agent you deploy should have an observe mode that logs what it would do before it is allowed to do it. Judge the log for a month, then decide about auto.
  • If you want to try the prototype: do it on a low-stakes repository, under a dedicated account with only the agent’s credentials, in observe mode. Treat “danger-full-access” as the warning label it is.
  • If you buy coding tools: ask vendors the attention question. Not “how good is the model”, but “how many minutes of my engineers’ attention does one merged pull request cost, end to end?” That is the metric this release is designed around.

The bottom line

DeepSeek has not shipped a finished rival to Claude Code. It has published something more interesting: a working sketch, in open code, of the next competition in AI tooling, agents that notice work themselves, gated by explicit permission levels, coordinated by a router that treats human attention as the scarce resource it is. The prototype is rough, the benchmarks synthetic, and the security posture demands respect. But the direction is now public, MIT-licensed, and being pursued independently by the incumbent it targets. The prompt box was a phase. What replaces it looks a lot like this.