mrkeyoor.comAsk

deepseek-ai/dsh-superagent-prototypetested 18 Nov 2026commit 8c32a9d

dsh-superagent-prototype review

Use dsh-superagent-prototype to study or adapt repository task routing if you can manage its accounts, processes and OS permissions.

  • Safety failed
  • Install 11 s
1,196/1,197passed, run exited non-zero
  • Build 16 s
  • 235 packages
Dev Toolsevaluationupdated 19 Nov 2026
+205 / 2dstars / 7d

dsh-superagent-prototype is MIT-licensed research code packaged as a DeepSeek Harness bundle for one GitHub repository. It listens to GitHub and optional Feishu events, turns authorized requests into tasks with their own sessions and directories, and returns results to the original conversation. The README explicitly says it is not an official DeepSeek product.

Verdict

Use dsh-superagent-prototype to study or adapt repository task routing if you can manage its accounts, processes and OS permissions. Our source run installed and built successfully, then failed its test command with 1,196 passes and one failure. Skip it if you require supported unattended delivery or a worker security sandbox.

dsh-superagent-prototype infographic: turns authorized GitHub requests into agent work, plus our test result and who it suits
Tested 18 November 2026: 1,196 of 1,197 source tests passed, 1 failed. Before that: source install 11 s, build 16 s.

We ran it

Lab card: what happened when we ran dsh-superagent-prototype
Lab card from our sandbox run
Screenshot of dsh-superagent-prototype (github.com/deepseek-ai/dsh-superagent-prototype)
github.com/deepseek-ai/dsh-superagent-prototype
Install✓ · 11s235 packages · 133 MB
Build✓ · 16s
Tests✗ · 68s1196 passed · 1 failed of 1197 (vitest)
Repo216 files~30,359 lines of source · 2.6 MB · 0 CI workflows · tests dir

Answers from our run

Does dsh-superagent-prototype build from source?

Dependencies installed in 11 seconds (235 packages), and the build succeeded in 16 seconds. We cloned commit 8c32a9d into a clean Debian container with 3 CPUs and no project-specific setup.

Do dsh-superagent-prototype's tests pass?

No. The project's own test command finished in 68 seconds and reported 1196 passed, 1 failed (vitest).

Who should not use dsh-superagent-prototype?

Teams requiring an OS security sandbox around workers.

What are the alternatives to dsh-superagent-prototype?

jwangkun/dsh-superagent, Devin, Claude Code. Use dsh-superagent-prototype to study or adapt repository task routing if you can manage its accounts, processes and OS permissions.

Setup4/5Our source checkout installed in 11 s and built in 16 s with 235 dependencies, but we did not run a README task.Editor’s note: The source install took 11 seconds and the build took 16 seconds; the separate deployment attempt stopped at its runner's Compose prerequisite, leaving complete operational setup unassessed.
Docs3/5The 2,243-character README has no usage instructions or examples of its own and points to separate documentation, which we did not assess.Editor’s note: The supplied English guides cover accounts, authorization, execution and upgrades; the evidence does not assess all documented configurations.
Community5/5Last push on 2026-11-03 and 23,843 stars.Editor’s note: Detailed operator reproductions and local patches are supplied, but the sample does not measure support responsiveness or sustained adoption.
Maturity1/5No tagged GitHub release, repository created 2026-10-31 and its test suite did not pass in our sandbox (1,196 of 1,197 passed).Editor’s note: The README labels the project research code and our test command failed; the evidence does not assess sustained real-service reliability.

How we score

Discussed on

  1. hnDeepSeek open-sources dsh-superagent, a coding agent largely built by agents11 points
  2. hnDeepSeek put the architecture for their always-on autonomous agent on GitHub7 points
  3. hnDeepSeek Harness Superagent Prototype3 points

Who it’s for

Agent developers studying repository request intake, authorization and task delivery.
Harness operators prepared to maintain a dedicated profile, agent GitHub account and local clone for worktrees.
Developers evaluating the reported notification and process-detection patches on a scratch repository.

Who it’s NOT for

Teams requiring an OS security sandbox around workers.
Organizations requiring supported production software or dependable unattended delivery.
Operators expecting the documented github.com user-account workflow to accommodate GitHub Enterprise Server or a GitHub App identity.
Native Windows operators expecting the documented service operations to work unchanged.

Setup reality

Our November 18, 2026 source run at commit 8c32a9d installed dependencies in 11 seconds and built in 16 seconds. Tests failed after 68 seconds with exit 1: 1,196 passed and 1 failed out of 1,197. The sandbox recorded 235 dependencies using 133 MB, with 3 CPUs and 8 GB RAM configured.

Useful operation requires a configured Harness model provider, a separate profile, a dedicated GitHub user with repository write access, its own CLI login and a local clone for worktrees. Account creation, login and secret entry are operator actions. Feishu is optional.

Our November 19 hands-on attempt failed its runner's Compose-file prerequisite, and teardown recorded ok. Its deployment summary contradicts that failed step; the body preserves both records.

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.

Alternatives

ProjectWhat it isPick it when
jwangkun/dsh-superagentA fork whose README documents shared-account requests and restoration of host environment settings after setup checks.Assess this fork when using one GitHub account or sharing a Harness profile is central to your workflow.
DevinA Reddit participant suggests Devin as a paid alternative with a similar integration idea.Investigate it when deciding whether to pay for a service instead of operating this research bundle.
Claude CodeThe supplied video frames Superagent through a comparison with Claude Code.Compare the repository-event workflow with the coding workflow you already use.

What people are saying

  1. [velocity-scout] deepseek-ai/dsh-superagent-prototype

Sources

  1. Upstream authorization: admission, permissions and accept modes
  2. Project README and research disclaimer
  3. Deployment prerequisites, accounts and worker permissions
  4. Discussion #11700: process detection and lost GitHub mentions
  5. RoyDevCh's reproduction and shared-account demonstration
  6. jwangkun/dsh-superagent fork README
  7. Argusic's mock-service evaluation
  8. Agent-assisted setup video transcript

More dev tools reviews