DeepSeek's Super Agent on GitHub: dsh-superagent Setup Guide
DeepSeek's dsh-superagent-prototype is an open-source proactive coding agent for one GitHub repository. The honest caveats, how it works, and how setup runs.

DeepSeek's newest repo is not a model. dsh-superagent-prototype, published on October 31, 2026, is a proactive coding agent for exactly one GitHub repository: it listens to GitHub — and, optionally, Feishu — and when someone allowed asks it for work, it opens a work item, does the work in its own agent session and directory, and answers in the original conversation, usually with a pull request. A web panel shows what needs a person.
Five days in, the repo has passed 18,600 stars, so the honest part comes first here. The README opens with "Research prototype for reference only, not an official DeepSeek product." The code grew out of the team's day-to-day development work, with much of the engineering done by coding agents, and the published version was adapted for release: it is not identical to DeepSeek's internal build, nor to the system described in the paper Exploring Super-agent Design: Towards a More Autonomous Agent System. Some designs in that paper are future directions this prototype does not implement.
Below: what the repo is, how it works, the attention philosophy it is built around, the agent-driven setup, its relationship to DeepSeek Harness, and who should — and shouldn't — run it.
What dsh-superagent is
| Field | Value |
|---|---|
| Project | dsh-superagent |
| Repository | deepseek-ai/dsh-superagent-prototype |
| What it is | A proactive coding agent for one GitHub repository, packaged as a bundle for DeepSeek Harness |
| License | MIT |
| Created | October 31, 2026 |
| Stars | ~18,700 as of November 5, 2026 |
The name says super agent; the scope says otherwise. The GitHub description is just the paper's title — "Towards a More Autonomous Agent System" — because the substance lives in the repo: one deployment serves one repository, and one agent is responsible for it. It is not a standalone binary either. It ships as a bundle for DeepSeek Harness, DeepSeek's open-source agent framework, which provides the runtime base — profiles, sessions, the plugin system — that the prototype runs inside. The bundle adds the proactive layer on top: Sources that listen for requests, a policy that decides who may ask, and a web panel that surfaces what needs a human.
The documentation is part of the design too: nine numbered files, 000 through 008, each building only on the ones before it, readable by a person and by a coding agent in the same pass.
The caveats first: research code, and not the paper's system
The README's own disclaimer is the best summary, quoted in full:
Research prototype for reference only, not an official DeepSeek product. This code grew out of our team's day-to-day development work, with much of the engineering done by coding agents. Treat it as research code, not production-ready software. It may still contain bugs, and its coding style and engineering practices may be inconsistent. Review and adapt it before using it in your own environment.
Three practical consequences. First, you are the reviewer: expect bugs and inconsistent style, and budget time to read what you deploy. Second, coverage of "DeepSeek's internal super agent" describes a system you cannot clone — the released code was adapted for publication, so mechanisms described elsewhere may not match this repo. Third, the paper is a map of ideas, not a changelog: part of what it describes is explicitly future work. When a post claims a feature, check the repo's numbered docs before believing it ships.
The flip side of that honesty: MIT license, no marketing gloss, and a team telling you exactly how much to trust it. That is rarer than it should be.
How it works: from a message to a pull request
The domain model (docs/001) is small. A Source — GitHub, optionally Feishu — delivers Triggers. A request only counts when it addresses the agent directly and comes from an allowed person: a name on the allowed list, or anyone in a conversation the team opened to requests. An Assessor evaluates each Trigger; an accepted request opens a Ticket with its Mandate — what this piece of work is allowed to do — plus an Assignment. The Executor works in its own agent session and a fresh checkout directory, then reports back: ready, blocked or failed. Every outgoing reply passes through an Outbox and lands in the conversation the request came from — an issue comment, a Feishu message — usually with a pull request attached.
The web panel shows what needs a person, and that is nearly all it shows: it lists first what waits on a human, and a healthy state takes no space.
Proactive work — acting without being asked — exists but is gated twice. It needs a rule the team wrote, and it starts in observe mode, which records what the agent would have done without doing it. Auto-merge on the agent's own pull requests is off by default: people merge until its PRs have been right for a while.
With Feishu enabled, the details are considerate: the bot reads only mentions, direct messages are on, and who may ask in Feishu can stay in sync with the members of the team's chat.
If you want the code-level map, docs/007-architecture.md is thorough: a Runtime composition root, a central Engine that is the only writer of Triggers, Tickets and Decisions, the Assessor and Executor behind small interfaces, and a transactional Outbox for every outgoing message. It is the file to read when you want to modify the prototype rather than just run it.
The philosophy: spend as little human attention as possible
docs/000-philosophy.md states the core principle as a design contract: "take as little human attention as possible, and give as much value as possible." Everything in the repo is judged against the attention it costs — messages, questions, settings, panel elements.
What that demands of the agent:
- It acts only when asked, or when a written rule allows it.
- It speaks only when a person must act or can use a result: it confirms a request once, stays quiet while working, and writes again when a result is ready, a decision is needed, or it cannot finish.
- It asks one concrete question at a time.
- It stops by impact, not by effort — a change needing a design decision stops with a clear question.
- It reports honestly: drafts are marked unfinished, failures are reported as failures.
And what it demands of the operator is written down too: start narrow, with a short allowed list and proactive work only recorded; tune for less noise instead of adding messages that explain the noise; never use it to produce volume — mass pull requests and busywork cost a team more than they give; and own what it says, because every message it posts under the team's accounts is yours to answer for.
Setup: your coding agent does it with you
Setup has many steps, so an agent does it with you. Ask your coding agent:
Read SETUP.md in this repository and set up dsh-superagent with me.
SETUP.md is written to the agent, and it encodes the same philosophy. The agent probes your machine first, then asks one short question per message — each with a recommended answer you can accept in one word — collects every answer, sends the full plan once, and executes only after you confirm. Secrets are never requested in chat: steps that need your hands, such as creating the agent's GitHub account or signing in a CLI, arrive as one message with the exact commands to run in your own terminal.
The probe checks the prerequisites:
- Node.js 22.19+ or 24+
- pnpm
- git 2.32+
- tmux
- Python 3.8+
- GitHub CLI 2.48+
- DSH itself, plus a model provider configured in it
Then the questions, in order: GitHub only, or GitHub plus Feishu; which repository to take over, as owner/name; which GitHub account the agent acts as — the recommended answer is a dedicated account, never yours, since everything it writes appears under that name; who may ask for work; where each Ticket checks out, by default a fresh clone under ~/src/<name>; what its commits name as author; and whether to enable auto-merge, where the recommended answer is no.
Values with good defaults are not asked at all — they are listed in the plan: a superagent profile kept apart from the one you work in, port 3082, an hourly check from your own profile that restarts the agent if it stops, an agent/ branch prefix, and observe mode for proactive work.
For development on the prototype itself, pnpm check runs the typecheck, the tests and the build.
The docs, in reading order:
- 000 Philosophy — the principle, and what it asks of the operator
- 001 Domain model
- 002 Authorization
- 003 Execution
- 004 Prompts
- 005 Panel
- 006 Deployment — manual setup, configuration, upgrades and troubleshooting
- 007 Architecture
- 008 Cookbook — adding a Source
Any coding agent you keep around — Claude Code, Codex, Kimi Code — can run this flow. That is the point of it.
DeepSeek Harness: the framework underneath
dsh-superagent is a bundle for Harness, not a fork of it. deepseek-ai/deepseek-harness was created on August 13, 2026, carries the motto "Everything is a Plugin," and has passed 272,000 stars. Harness provides the runtime — profiles, sessions, the plugin system — and the bundle contributes the Sources, the authorization policy, the panel and the numbered docs. The setup plan covers DSH too: the probe checks dsh --version, and a missing install becomes an item of the plan. If DSH has never run with a model, configuring a model provider is part of your setup.
If you are new to DeepSeek's ecosystem, start with our DeepSeek tools page; the models side is covered in our guide on how to use DeepSeek.
Who it is for — and who should wait
A good fit: teams with one active repository and a steady stream of small, well-scoped requests; teams that already collaborate in Feishu, since the integration is native to the design; developers who want to study how a proactive agent is designed — the numbered docs may be worth more than the code; and teams with the review capacity to keep a human between the agent's work and main.
A poor fit: anyone expecting a polished, supported product — the README rules that out in its first line; teams hoping to farm output, which the philosophy explicitly warns against; solo work where a chat agent in your editor already covers it; and any team that plans to skip docs/002-authorization.md. An agent that can open pull requests and message your colleagues under a real account is a security decision, not a toy. Read the authorization doc before widening its allowed list, and let observe mode run until what it would have done looks right.
The one-repository scope is the point — this is a caretaker, not an assistant. If you want proactive help beyond a single repo, that is a different genre; our OpenClaw page covers that side. And if you like GitHub projects best when you can read their receipts, we have also walked through Reverse Engineer Anything — same genre, different problem.
FAQ
Is dsh-superagent an official DeepSeek product?
No. It is published under the deepseek-ai GitHub organization, but the README states verbatim: "Research prototype for reference only, not an official DeepSeek product." Treat it as MIT-licensed research code that you review and adapt yourself.
What is the difference between dsh-superagent and the super-agent paper?
The published code was adapted for release and is not identical to DeepSeek's internal version or to the implementation described in Exploring Super-agent Design: Towards a More Autonomous Agent System. Some designs in the paper are future directions and are not implemented in this prototype — check the repo's own docs before assuming a mechanism exists.
Does dsh-superagent cost anything?
The code is free under MIT. You host it yourself, so your costs are infrastructure plus model usage through whatever provider you configure in DeepSeek Harness — modest on a cheap model such as DeepSeek 4.1 Flash. The expensive resource is the operator's attention, which is exactly what the design tries to conserve.
How does dsh-superagent relate to DeepSeek Harness?
dsh-superagent is a bundle that runs inside Harness. DeepSeek Harness — about 272,000 stars, "Everything is a Plugin" — provides the runtime, profiles and plugin system; the bundle adds Sources, the authorization policy, the panel and the docs. One setup pass configures both.
Can dsh-superagent run on models other than DeepSeek's?
The repo does not say. Setup only requires that DSH has a model provider configured; neither the README nor the numbered docs state whether this bundle is limited to DeepSeek models or also works with third-party ones. The fastest way to find out is to run it — cautiously, in observe mode.


