Overview
dsh-superagent is an open-source proactive coding agent from DeepSeek that serves a single GitHub repository. It installs as a bundle for DeepSeek Harness and sits in the background listening to GitHub, optionally to Feishu as well. When someone within the allowed scope asks for work, it opens a ticket, works in its own agent session and directory, then answers in the original conversation, usually with a pull request. A web panel lists what needs a person.
The repository is explicit about status: this is a research prototype that grew out of the team's daily work, not an official product, and the code may still contain bugs with an inconsistent engineering style, so review it before use. The license is MIT.
The problem it targets is not typing speed but attention. An agent one person can supervise will eat the attention of a whole team if it is careless, so it acts only when asked or when a rule the team wrote allows it, and speaks only when someone has to decide or can use the result.
Key Features
- One repository: A single instance is responsible for one GitHub repository, which keeps permissions, context and working directories inside that boundary.
- Event driven: It listens to GitHub with optional Feishu. Work starts only when an allowed request arrives, so idle time costs nothing.
- Tickets with their own directory: Each work item gets a ticket plus its own agent session and directory, so several jobs can run without stepping on each other.
- Answers where the request came from: Delivery goes back into the originating conversation rather than a separate channel, most often as a pull request ready for review.
- Authorisation with a human in the loop: Rules live in the repository policy, out-of-scope actions do not run, and the panel surfaces the items that need a person to decide.
- Setup done by an agent: The install is long, so the official path is to have a coding agent read SETUP.md, ask one short question at a time, show the plan and then configure everything.
Use Cases
- Small team repositories where an incoming issue is triaged by the agent and answered with a pull request a person only has to review.
- Repetitive maintenance such as dependency upgrades and documentation sync, run under rules and escalated only when something breaks.
- Review comments on a pull request fed back in as input, with a new revision and a note explaining what changed.
- Internal tooling that nobody owns full time, kept alive by an agent watching the repository in the background.
- Work assigned by mentioning it in a Feishu group, with the result posted back to the same group.
- Reading it as an architecture sample, following the nine numbered documents from philosophy through deployment to see how a standing agent should be layered.
Pros
- MIT licensed, with code, docs and design trade-offs all in the open and open to modification.
- Events rather than a person opening a terminal, so repeated requests do not need their background restated.
- Each ticket has its own session and directory, which isolates tasks and makes failures traceable to one item.
- Authorisation and policy live in the repository, giving out-of-scope actions a clear boundary.
- Delivery returns to the original conversation, so review and history stay on GitHub.
- The web panel gathers items that need human input instead of requiring someone to watch logs.
Pricing
Free and MIT licensed, with no hosted service. The running cost is model calls plus a machine kept online, using the session capability of DeepSeek Harness, and the total depends on repository activity and the model you connect. Installation needs Node and pnpm, and the repository ships typecheck, test and build scripts.
Summary
Most coding agents start with a person opening a terminal. dsh-superagent moves the starting point to events: a request appears in the repository, the agent decides whether to take it, opens a ticket, does the work and reports back. The important part of that structure is not model strength but the fact that every work item has its own session and directory, so results can be traced and a bad run can be stopped. At its current stage it is a research prototype, worth reading for the architecture and trying on your own repository, not something to put straight into production.
Version History
- v0.1.0 research prototype open-sourced: a proactive coding agent for one repository (2026-11-01): DeepSeek open-sourced dsh-superagent v0.1.0 under MIT, distributed as a bundle for DeepSeek Harness. It serves a single GitHub repository, listens to GitHub and optionally Feishu, opens a ticket when work is requested, executes in an isolated session and directory, and delivers back into the original conversation as a pull request, with a web panel listing items that need a person. The project describes itself as a research prototype, not identical to the implementation in the accompanying paper Exploring Super-agent Design, with some described designs reserved for future work.