dsh-superagent-prototype turns authorized GitHub requests into agent work inside DeepSeek Harness. Use it to study or adapt a repository request-to-PR workflow if you can manage its accounts, processes and permissions. Skip it if you require supported unattended delivery or an OS security sandbox. Our November 18, 2026 source run at commit 8c32a9d installed and built successfully, then failed its test command with 1,196 passes and one failure. The project README calls the code a research prototype; our source measurements give a concrete starting point for evaluating it.
What people use dsh-superagent-prototype for
Operators report using dsh-superagent-prototype for GitHub task delivery, notification troubleshooting and application startup with stand-in services. The reports describe different workflows, so their outcomes belong beside their setup details. RoyDevCh used a shared-account demonstration with local filter removals; Wanke15 requested a small Python tool after changing notification reading. Those disclosures explain the reported path from a request to a pull request more clearly than a general promise of autonomous coding.
| Who used it | What they did | What came out |
|---|---|---|
| RoyDevCh | Sent a GitHub issue through intake, a worker worktree, a commit and a branch push | Reported a pull request on Linux after removing self-authored-message filters for a shared-account demonstration. RoyDevCh's run notes |
| Wanke15 | Requested a Python command-line addition tool on a scratch repository after patching notification reading | Reported an explicit trigger, acceptance, a worker and PR #5; repeated polling produced no duplicate ticket. Wanke15's live reproduction |
| Argusic Runner | Started the application with stand-ins for external services | Reported responding management endpoints and a verdict of Runs with mocks. Argusic's recorded evaluation |
| Presenter of DeepSeek's New SuperAgent Can Build an Autonomous AI Coding Team! | Had an agent follow SETUP.md inside Harness | Described the installation process. Setup video transcript |
RoyDevCh explicitly called the filter removals a test hack and said a dedicated agent account avoided them. Wanke15's report instead traces a notification-reading change through request intake and delivery. That difference matters when choosing a starting configuration: one demonstration changes how the same account's messages are filtered, while the other changes when notified threads are read. The upstream account requirements provide the documented baseline for comparing those local changes.
What happened when we ran it
Our November 18, 2026 source run at commit 8c32a9d installed dependencies in 11 seconds and built in 16 seconds. The test command failed after 68 seconds: 1,196 passed and 1 failed out of 1,197. Our run used a sandbox configured with 3 CPUs and 8 GB RAM, carrying the image label lab-node:22. The measurements separate dependency installation, compilation and test outcomes, so a completed build does not turn the failed test step into a passing check.
| Source-run step | Result | What it means |
|---|---|---|
| Dependency installation | Succeeded in 11 seconds; 235 dependencies recorded, 133 MB on disk | The pnpm dependency step completed in this sandbox. |
| Build | Succeeded in 16 seconds | The source build completed. |
| Tests | Failed, exit 1, after 68 seconds | Vitest reported 1,196 passed and 1 failed out of 1,197. |
| Repository scan | 216 files, about 30,359 source lines, 2.6 MB checked out | The scan found a tests directory, zero CI workflow files and no Dockerfile. |
The failing file was tests/sources.spec.ts, with one failure among its 71 tests. The supplied tail reports one failed test file and 58 passing files, followed by the lifecycle failure. Nearby passing test names concern polling, launch retries and worker lifecycle handling. The measured result is therefore a source build followed by a failed test command, with the failed file identified. The harness also recorded zero skipped tests and a total run time of 100 seconds.
Our separate November 19 hands-on attempt failed its safety step because none of the accepted Compose filenames existed. Its runner required a Compose file and returned an unsafe repo label for that missing prerequisite. Teardown recorded ok. The same attempt's summary nevertheless says it deployed with its own Docker Compose and bound every port to 127.0.0.1. The failed prerequisite is the recorded stopping point; the deployment summary contradicts it.
Where people get stuck: missing requests and misleading status
Discussion #11700 reports a live service that status could not find and GitHub mentions lost before task creation. mikel38487 describes local fixes; Wanke15 supplies an independent notification reproduction and a subsequent request-to-PR result. These reports make intake and service monitoring useful first checks when the agent appears idle. The following table separates the observed symptoms from the changes operators described. Discussion #11700 and its reproduction.
| Symptom | What the reporter found | Practical response and patch status |
|---|---|---|
| Status returns no process while the API answers | On the reported Node 24 Linux setup, the process name was MainThread and the service script discarded it | Reporters changed identification to use the executable in argv and reported local success. |
| A mention arrives but creates no ticket | A notified thread was read using a window newer than its issue or comment, then its cursor advanced past the event | Reporters used the thread's own cursor and a one-hour lookback for its first read. |
| A notification is indexed after the next poll | Wanke15 identifies a separate race in the notifications query | Wanke15 proposes bounded overlap, for example 60 seconds, with deterministic trigger IDs. |
| Native Windows configuration fails | RoyDevCh hit stateDir validation and POSIX dependencies in service operations | The reporter used WSL; changing path validation alone leaves the other dependencies. |
| One GitHub account is requester and agent | Self-mentions send no notification, while upstream filters self-authored events | Use the dedicated-account setup or assess the fork's shared-account workflow. |
| An edited issue gains a mention but no request arrives | The deployment guide distinguishes an edited issue body from a new notification-producing comment | Post a new comment mentioning the agent. |
The notification reproduction reports that fetched notifications produced zero triggers, decisions or tickets while thread cursors advanced. Enabling repository streams afterwards did not recover the earlier events because their reading windows began after those issues were created. That failure happens before a coding turn, so inspecting worker output alone misses the intake problem. The process-detection defect also caused startup to exhaust its health check and stop to find no process, despite a responding API. Notification and process findings, Windows findings, edited-issue guidance.
Other reported problems concern setup and maintenance. The bundle changes process-wide PATH and Git settings, making the documented dedicated profile consequential. Repeating profile creation during an upgrade deletes the existing cordis.patch.yml and its machine configuration; edit the existing file instead. mikel38487 also reports that the setup probe printed the gh version without enforcing the documented 2.48 minimum, and that the prototype's disabled issues and pull requests led to posting fixes on fork branches in the Harness discussion. Deployment requirements, upgrade instructions, operator report.
Community test reports also name a Feishu consumer timing failure. Argusic associates its remaining failure with asynchronous error handling in the stdout handler, while RoyDevCh calls the single failure a Feishu consumer timing test. Our supplied test tail identifies tests/sources.spec.ts and its count; the community explanations belong to their reported runs. The discussion additionally reports an undeliverable author email address, explaining why its contributor used the Harness discussion and fork branches. Argusic's test account, RoyDevCh's account, contribution report.
Authorization controls intake; workers keep OS-user access
A worker can execute programs by path and read the operator's home directory. The deployment guide says both presets run with danger-full-access as that OS user, and credential wrappers select credentials without isolating the process. Its recommended isolation measure is a dedicated OS account containing only agent credentials. Separate sessions and working directories organize tasks, while the OS account determines which local files and credentials execution can reach. Worker permissions and account guidance.
The authorization document assigns intake policy to the host: allowed lists, rules and Mandates determine who can request work and what a task may include. Messages on subscribed threads can reach a worker as context without granting new authority. Observe mode assesses inferred candidates and records positive assessments without accepting them, while explicit requests work in every mode. Start with observe and review those recorded decisions before enabling automatic acceptance, following the documented authorization workflow.
Setup needs accounts, a profile and a local clone
Setup requires a GitHub user with repository write access, its own CLI credentials, a configured Harness model provider and a local repository clone for worktrees. A GitHub App cannot be the agent because this workflow reads the account's notifications. The documented repository host is github.com, and Feishu is optional. These requirements explain why the 11-second source dependency installation is only one part of preparing an operational service. Deployment prerequisites and accounts.
The documented tools include Node.js 22.19+ or 24+, pnpm, Git 2.32+, Python 3.8+, tmux and gh 2.48 or later. The README offers agent-assisted setup through SETUP.md, but account creation, CLI login and entering app secrets are operator actions. English README, setup and deployment material is supplied. The setup video describes an agent following setup.md; the written guide gives the operator responsibilities to retain when using that approach. Tool requirements, operator actions, installation transcript.
The README sets communication rules; the experiment uses simulated work
The README tells the agent to act when asked or permitted by a team rule and to speak when someone must act or can use a result. That is a concrete communication policy a reader can examine when designing repository automation. The supplied X discussion asks which agent last overwhelmed readers with messages. It supplies a reader question about noise, while the README supplies the prototype's intended response to that problem. README communication policy, captured X question.
Marktechpost describes an orchestration simulation using synthetic messages and simulated tools. Its account says the neutral-prompt single-session baseline called a subagent zero times in five runs. The Reddit discussion supplies a different kind of evidence: Beneficial-Ad-8127 asks about actual Superagent use after describing Harness search setup, while Thin_Pollution8843 criticizes Harness and prefers OMP. These are an experiment report and individual runtime experiences, respectively, rather than interchangeable accounts of repository task delivery. Simulation coverage, Reddit discussion.
dsh-superagent-prototype vs the jwangkun fork, Devin and Claude Code
The jwangkun fork documents shared-account requests and restoration of host environment settings after setup checks. Those changes address specific account and profile choices. Devin appears as a Reddit suggestion, and Claude Code appears in video framing. The table identifies what each supplied comparison contributes to a purchasing or setup decision. Its entries describe the evidence behind each mention, so readers can distinguish a documented fork behavior from a suggested alternative. Fork README, Reddit comparison, Claude Code video framing.
| Alternative people mention | Evidence in the pack | When to investigate it |
|---|---|---|
| jwangkun/dsh-superagent | Its README documents shared-account requests and restoring host PATH and Git settings after setup checks | One GitHub account or a shared Harness profile is a requirement. Fork README |
| Devin | ProtectionSuper5648 suggests a paid system with a similar integration idea | You are deciding whether to operate this research bundle or investigate a paid service. Reddit suggestion |
| Claude Code | A video introduces the release through comparisons with Claude Code | You want to compare repository event orchestration with your existing coding workflow. Video transcript |
| A single session with a subagent tool | Marktechpost describes a synthetic baseline that did not call subagents | You are studying dispatch strategies under a controlled workload. Experiment coverage |
The fork's README says a shared-account deployment reads repository issue and comment streams because mentioning yourself sends no notification. A request starts with the account mention; other messages by that account are ignored to avoid triggering work from the agent's own output. RoyDevCh instead removed two filters for a demonstration. These are distinct approaches to one account constraint, and the upstream guide chooses a dedicated agent account. Fork request rules, demonstration changes, upstream accounts.
What the other reviews get wrong
Kael Zhang's overview says rejection creates a Ticket; the authorization document and Wanke15's delivery report associate task creation with acceptance. Its panel description also omits history and operational health, which the supplied panel overview explicitly includes. These corrections affect how a reader follows a request through admission and then checks the system's state. Kael Zhang's overview, authorization flow, panel description, accepted-task reproduction.
Pandaily describes isolated worker sessions; the deployment guide specifies that workers retain OS-user access. AGTP lists email and calendar triggers, whereas the prototype README names GitHub and optional Feishu and says some design-article ideas are future work. Argusic's all-errors-fixed language sits beside its own 1,196-of-1,197 test result. Its detailed result supports application startup with stand-in services and a remaining failed test. Pandaily's description, worker permissions, AGTP's trigger list, prototype README, Argusic's result.
ToolPilot treats persistent status failure too narrowly as a setup problem: the reproduced process-detection defect lets a live management API coexist with failed status. The setup video's suggestion that nothing needs manual installation also needs the written operator steps: creating an account, signing a CLI in and entering secrets. These corrections give readers a better next action than repeatedly restarting a live service or waiting for an agent to complete an account step. ToolPilot tutorial, process report, setup video, operator responsibilities.
Questions people ask
Yes, operators report completed pull requests, including Wanke15's PR #5 after a notification-reading patch. That answers the supplied Reddit question about actual use with a specific outcome and configuration. The questions below separate what the application does, how requests gain authority and what access workers retain. Those distinctions matter because successful delivery, admission policy and process permissions describe different parts of the workflow. Reported delivery, Reddit usage question, authorization document.
Has anyone actually used dsh-superagent-prototype, and how well does it work?
Wanke15 reports a completed request-to-PR workflow after a notification patch; RoyDevCh reports delivery with shared-account filter changes. Argusic reports application startup with stand-in services. Each outcome belongs to a specific configuration: the first addresses notification reading, the second changes self-authored-message filtering, and the third substitutes external services. Choose the account of the workflow you want to reproduce rather than combining them into a single reliability score. Live delivery report, shared-account demonstration, mock-service startup.
What does DSH Superagent actually do?
DSH Superagent listens to GitHub and optional Feishu events for one repository. When an allowed person asks for work, it opens a work item, runs that work in its own agent session and directory, and answers in the original conversation, for example with a pull request. The README also describes a web panel that shows work needing a person. Upstream workflow description.
Can Superagent investigate and fix a bug reported on GitHub?
The documented workflow accepts authorized GitHub requests and can return a pull request, and community reports describe completed delivery. For a bug request, specify the reproduction and acceptance conditions so the proposed change has something concrete to satisfy during review. That recommendation follows the task-to-result workflow rather than treating the arrival of a pull request as the acceptance decision. README workflow, reported GitHub delivery.
Would you let an agent take on work without being asked?
Observe is the documented default for inferred work: it records positive assessments without accepting those tasks. The authorization guide recommends reviewing recorded decisions before switching to auto. Explicit requests work in every mode. Start with that documented sequence when assessing the question raised in the supplied X discussion, and use written rules to specify which proactive work you want accepted. Authorization modes, X discussion question.
Which agent last overwhelmed you with unnecessary messages?
The supplied X post asks readers about agents that would not stop talking. Superagent's README responds to that concern with a communication rule: speak when someone must act or can use a result, and act when asked or permitted by a team rule. Use that stated behavior as a criterion when reviewing acknowledgements and task results in your own evaluation. Captured reader question, README communication rule.
Is dsh-superagent an official DeepSeek product?
No. The README calls it a research prototype for reference and explicitly says it is not an official DeepSeek product. It also asks readers to treat the code as research software and review and adapt it before use. The published code differs from the team's internal version and from some designs in the accompanying article. Project disclaimer.
Is DSH Superagent a model or an application running on Harness?
It is application code packaged as a DeepSeek Harness bundle. The deployment guide requires a separately configured model provider and says the profile's default model is used unless evaluation or execution settings select another. That distinction separates installing this repository's orchestration workflow from configuring the model service that supplies inference to the runtime. Application description, model configuration.
How does Superagent differ from DeepSeek Harness?
Harness supplies the surrounding agent runtime and extension system. Superagent is a bundle on that runtime coordinating repository requests, tasks, sessions and delivery. The separation helps explain why a report about Harness search or plugins addresses a different part of the setup from a report tracing a Superagent mention through acceptance, execution and a returned pull request. Runtime and bundle distinction.
How does Superagent decide whether a request is authorized to start work?
The host checks sender identity and the source's policy, including allowed lists and configurable admission settings. An allowed person addressing the agent makes an explicit request; inferred work also depends on accept mode and matching rules. The admission table can grant explicit-request strength in configured scopes, so membership in an allowed list is one part of the policy rather than its entire definition. Authorization and admission rules.
Can a GitHub comment change the agent's permissions?
The authorization document says messages, comments and quoted documents cannot change host-enforced permissions. Subscribed-thread messages can provide context without granting new authority, and each task remains limited by its Mandate. That is the documented distinction between information delivered to an executor and authorization to expand the work it may undertake. Host policy and subscription rules.
Does observe mode prevent every task from executing?
No. Explicit requests work in every accept mode. Observe evaluates inferred candidates and records a positive assessment as would accept without accepting the task; auto accepts a positive assessment of inferred work. The guide recommends starting in observe and inspecting decisions before enabling auto. Read the mode setting together with the source's admission policy when preparing a request. Accept-mode definitions.
Are worker sessions isolated from the rest of the computer?
Workers run with the operator's OS-user access, and the deployment guide says they can execute programs by path and read that user's home directory. Credential wrappers choose the agent's credentials without isolating the process. The guide recommends a dedicated OS account containing only agent credentials, which makes account preparation part of the operational setup alongside the separate Harness profile. Worker access and isolation guidance.
What we have not tested yet
Our direct evidence covers the source install, build and failed test command at commit 8c32a9d, plus a stopped Compose-based attempt. The test tail omits the failed assertion and exception; the image label lab-node:22 does not establish actual runtime or OS versions. The stopped runner requirement is not evidence that the application is malicious or unable to run through Harness. Our lab has not completed a real-service coding task, adversarial prompt-injection assessment, sustained reliability run or throughput study.
The supplied records leave upstream integration of community patches, a supported platform matrix and implementation of the residual notification-query overlap unresolved. The setup transcript supports agent-assisted installation without establishing an exact GLM model version or completed coding task. The fork's behavior is documented by its own README rather than an independent run in our lab. Patch discussion, Windows report, setup transcript, fork README.
Normal cost per completed coding task, correctness across representative tasks and human attention saved are unmeasured here. Argusic's verification cost concerns its recorded run, while the synthetic orchestration experiment measures a different workload. The supplied Devin and Claude Code mentions provide no matched task comparison. Rendered layout, related-link modules and recommendation modules were not tested in this review. For a next evaluation, use a scratch repository, a separate agent identity and a narrow request whose resulting pull request you can inspect. Argusic evaluation, synthetic experiment, comparison discussion, video framing.


