DeepSeek dsh-superagent: Free GitHub Coding Agent You Host Yourself

On October 31, 2026, DeepSeek's Harness team quietly pushed a new repository to GitHub: dsh-superagent, a coding agent that watches one of your GitHub repositories, takes requests from people you allow, and does the work in isolated sessions that report back with pull requests. Within about a day it had passed 4,700 stars. But the most interesting part of this release is not the star count. It is the rulebook the agent runs on: "take as little human attention as possible, and give as much value as possible." Here is what dsh-superagent actually is, how its Router-Worker design works, what it costs to run, and the catches DeepSeek itself flags before you install it.

What DeepSeek actually released

dsh-superagent is a research prototype, and DeepSeek says so in the first paragraph of the README: "Research prototype for reference only, not an official DeepSeek product." The code grew out of the Harness team's day-to-day development work, much of it written by coding agents, and it is adapted for publication. It does not match the internal version DeepSeek runs inside its own company, and some ideas from the companion design article, Exploring Super-agent Design: Towards a More Autonomous Agent System, are listed as future directions rather than implemented features.

The repository (github.com/deepseek-ai/dsh-superagent-prototype, MIT license) went up on October 31, 2026 with a single commit titled "add the dsh-superagent research prototype." The live GitHub API numbers when I checked on November 1: 4,759 stars and 445 forks. The design article it accompanies was published the same evening on the DeepSeek Harness team's official WeChat account, according to Yicai's October 31 reporting.

Technically, dsh-superagent is a bundle for DeepSeek Harness (dsh), DeepSeek's open-source agent runtime that wraps a language model with an agent loop, tools, and a sandbox so it can do work on your machine. Harness itself is MIT-licensed and positioned as an open alternative to Claude Code; the parent deepseek-harness repository sits above 267,000 stars. If you want background on the incumbent it is being compared with, my explainer on Claude Code, Anthropic's agentic coding tool covers the model-led alternative.

How it works: Router-Worker, Tickets, and staying quiet

The prototype is built around a two-layer Router-Worker architecture. A long-running Router session handles interaction and dispatch with a deliberately small tool set. Actual work happens in isolated Worker sessions, each in its own directory. The flow runs like this:

• Source. GitHub or Feishu (ByteDance's enterprise messaging platform, called Lark outside China) produces a stream of events. The GitHub source polls the repository on a schedule and collects the notifications of the agent's account.
• Trigger. Every event becomes an immutable Trigger tied to a conversation thread.
• Eval. A two-stage check first looks at who is writing and whether they are addressing the agent (a mention or direct message), then the main session judges whether to accept the message, ignore it, or attach it to already-open work.
• Ticket. Accepted work becomes a Ticket, a unit of authorized work with a Mandate: the record of why it may proceed and how far it can go. A Mandate never widens; a bigger job needs a new Ticket.
• Worker. Each Ticket gets its own executor session, worker-<ticket-id>, with its own working directory. Shell commands move to the background after 5 seconds so the Worker can read new messages while tests run. Background jobs get at most 30 minutes after each turn, then they are terminated and the Ticket reports it is waiting.

The result, typically a pull request, goes back to the conversation it started from. A local web panel shows only what needs a person, and state lives in a single SQLite file.

The part that stands out: an agent designed not to disturb

Most coding agents compete on capability. dsh-superagent's nine numbered design documents compete on restraint. The core principle, in the project's own words: every message, notification, panel element, or paragraph of documentation costs someone's attention, and each has to give more value than it costs or it is removed.

That philosophy turns into concrete behaviors: the agent acts only when asked directly by someone on the allowed list, or when a written team rule permits it. It confirms a request once, stays quiet while working, and writes again only with a result, a question, or a failure. It asks one concrete question at a time instead of dumping reports. It stops by impact, not by effort: a local change runs all the way to a reviewable result, while a change needing a design decision stops with a clear question. A draft is marked unfinished, a failure is reported as a failure, and a limit is never bypassed to avoid asking.

Proactive work ships with the brake on. The acceptance mode has three values, off, observe (the default), and auto. In observe, work the agent would have accepted is only logged, so a team can read for days what the agent would have done before granting it permission. The authorization doc adds two guardrails worth quoting: an ordinary bot can never make explicit requests, and quoted messages, comments, or documents are data, never permissions.

The benchmarks: real numbers, but simulated ones

DeepSeek tested the design with simulated group-chat and GitHub CI streams, as reported by MarkTechPost's November 1 breakdown. Each run had about 300 messages, of which roughly 20 were real work requests, and each scheme ran five times:

• Super-agent: median task completion 12.4 minutes, p95 15.7 minutes.
• Single session plus subagents: p95 of 29.5 minutes. The baseline called a subagent zero times in five runs under a neutral prompt.
• Scaling: as arrivals rose from about 1 to 40 per minute, batch size grew from 1.0 to 2.8 while per-request latency rose from 2.5 to 3.9 seconds.

All of these figures are self-reported and come from secondary reports of DeepSeek's design article. Real coding quality was not measured: there are no benchmarks on how many pull requests get accepted, what a Ticket costs in tokens, or which model performs best. Treat the ~1.9x speedup as a lab result, not a guarantee on your repository.

Setup: an agent installs it with you

Setup has enough steps that DeepSeek recommends having your coding agent do it with you: "Read SETUP.md in this repository and set up dsh-superagent with me." The prerequisites are Node.js 22.19 or 24+, pnpm, git 2.32+, tmux, Python 3.8+, GitHub CLI 2.48+, and DeepSeek Harness in the required range, plus a configured model provider. The setup agent asks one short question at a time, shows the full plan once, and only executes after you confirm.

Three setup choices matter most:

• A dedicated GitHub account for the agent, never your personal one, because everything the agent writes appears under that name. Every message it posts on GitHub opens with "This is by an automated agent, not a human" by default.
• A short allowed list. Only the logins you name can ask the agent for work, and Feishu chats stay in sync with their members.
• Start in observe mode. The agent records what it would have done until you trust it, and auto-merge on its pull requests stays off until its PRs have been right for a while.

What it costs: free code, metered models

The code costs nothing: MIT license, no paid tier, no subscription. The costs sit around it. You need an always-on machine (the agent runs in a tmux session with an hourly health check), a dedicated GitHub account, and a configured model provider in Harness. The prototype uses whatever model your Harness profile defaults to, and you can set different models for evaluation and for Workers. The repository does not estimate what a Ticket consumes in tokens.

As a rough sense of the model side: DeepSeek's own API pricing page listed V4.1 Flash at $0.15 per million input tokens and $0.60 per million output tokens at off-peak, with cached input at $0.003 per million, doubling during peak windows (01:00–04:00 and 06:00–10:00 UTC, Monday to Friday), when I read it on October 23 — re-check the live page before budgeting. At November 1 market rates that is roughly £0.11/£0.45 and C$0.21/C$0.84 per million tokens. You can also point Harness at other providers, which is where the "everything is a plugin" design pays off. For the model that rate card belongs to, see my DeepSeek V4.1 Flash 1017 breakdown.

How it compares with other GitHub coding agents

The meaningful difference is not in the feature rows. It is that dsh-superagent is the only one whose rulebook you can read, audit, and rebuild, and the only one its own creator says is not ready for production. GitHub's competing answer, the model-routing approach, is covered in my GitHub Universe 2026 Copilot roundup.

The catches, stated plainly

DeepSeek and independent reviewers flag the same warnings, and they are worth taking literally:

• Full OS-user access. The router and worker sessions run with full access as the operating system user that starts them, without approval prompts. The recommended posture is a dedicated system account holding only the agent's credentials, a separate GitHub account, and a short allowed list. Sandboxing is your job, not the agent's.
• Research code. Possible bugs, inconsistent engineering, no measured coding quality, an alpha Harness dependency (0.2.1-alpha.2). Do not point this at a repository you cannot afford to clean up.
• One repository per install. Each installation follows a single repo on github.com; GitHub Enterprise Server is not supported. More repos means more profiles or code changes.
• No model recommendation. The documents name no best model, and anyone hunting for hints about DeepSeek's next flagship model will not find them here.
• Noise is the operator's responsibility. The philosophy doc is blunt: if the agent is noisy, make its prompts shorter and stricter, or pause it. Do not use it to mass-produce pull requests or broadcast messages. You own everything it says under your accounts.

Who it is for

dsh-superagent fits teams that already live in GitHub and want an open, self-hosted way to triage issues and draft pull requests without handing their repository to a vendor's cloud. It does not fit solo developers looking for a chat assistant, anyone who needs production guarantees, or teams that cannot dedicate a machine and a human to supervise an agent with full OS access. The honest pitch, in one sentence: DeepSeek published its own team's agent rulebook as research code, and the most valuable thing in the repo may be the restraint it teaches rather than the code it ships.

FAQ

Is dsh-superagent an official DeepSeek product?

No. The README calls it a "research prototype for reference only" and says it is not an official DeepSeek product. It is adapted from DeepSeek's internal Super-agent work, and some ideas from the design article are not implemented in the published code.

How much does it cost to run?

The code is free under the MIT license. You pay for the model your Harness profile uses (per-token API rates of whichever provider you configure), plus an always-on machine and a dedicated GitHub account. The repository gives no estimate of per-Ticket token consumption.

Can it watch multiple repositories?

No. Each installation follows one repository on github.com. Covering more repositories requires more profiles or extending the code, and GitHub Enterprise Server is not supported.

Does it only work with DeepSeek models?

No. The prototype uses the default model of your DeepSeek Harness profile and lets you pick different models for the evaluation and worker stages. Which providers work depends on what you configure in Harness, where models are also plugins.

How do you stop it from spamming your team?

Three controls: only named people can ask it for work, proactive work starts in observe mode (it logs what it would have done without acting), and its default behavior is to stay silent except for results, questions, or failures. The operator is explicitly responsible for everything the agent posts.

Sources

• DeepSeek Harness team, dsh-superagent-prototype repository and README, GitHub, published October 31, 2026 — github.com/deepseek-ai/dsh-superagent-prototype
• DeepSeek, DeepSeek Harness product page — deepseek.com/en/harness
• Yicai (第一财经), "DeepSeek发布全新Agent架构", October 31, 2026 — yicai.com/news/103419784.html
• MarkTechPost, "DeepSeek Open-Sources dsh-superagent, a Router-Worker Coding Agent", November 1, 2026 — marktechpost.com
• Pasquale Pillitteri, "DeepSeek releases the open source prototype of its Super-agent", November 1, 2026 — pasqualepillitteri.it
• Early Signal, "dsh-superagent-prototype: DeepSeek releases autonomous coding agent prototype for GitHub repos", October 31, 2026 — earlysignal.news
• Zubiqo via FourWeekMBA, "DeepSeek Releases Open-Source GitHub Coding Agent Prototype That Runs Tasks in Parallel", October 31, 2026 — zubiqo.com
• Coheser, "DeepSeek Super-Agent Open Source: Free, With Caveats", November 1, 2026 — coheser.com