DeepSeek Harness has published dsh-superagent-prototype, a research prototype that turns messages from a GitHub repository and, optionally, Feishu into agent tasks. It is not a polished commercial DeepSeek product, nor a general-purpose bot that can safely process every issue as soon as it is installed. To assess it, first understand how it filters requests, grants authority, and isolates execution.
This article follows the official repository, its README, SETUP, and design documents. The repository explicitly describes the project as a reference research prototype that may contain bugs and is not production-ready. Recheck the current documentation before trying it because code and configuration can change.
In Google Trends China data for the past 30 days, “DeepSeek” had a much higher relative index than Python, Claude Code, OpenClaw, and Ollama in the same comparison. Related queries such as “deepseek super agent” and “deepseek superagent” were marked as rising. Trends’ 0–100 index is relative to the selected region and time range; it is not search volume or traffic. This site already covers DeepSeek agents; this article fills the more specific gap around dsh-superagent-prototype: its event model, boundaries, and evaluation.
What it is and what it is not
The package is named dsh-superagent. It is an active-agent prototype: it listens for GitHub events and optionally Feishu messages, evaluates requests against policy, turns accepted requests into Tickets, and assigns them to separate DeepSeek Harness sessions.
“Active” does not mean the agent can choose arbitrary work. The project says it should act only when asked by an allowed person or when a written team rule permits it. For automatic triggers that have not been explicitly authorized, the documentation recommends starting in observe mode, which records what the agent would do without changing the repository.
It is also not a hosted service. Operators must provide the runtime, model or Harness configuration, repository permissions, message entry point, and operations. The prototype cannot replace an organization’s review of identities and permissions.
If you only need to ask coding questions in a chat, DeepSeek Harness or another coding assistant may be simpler. For terminal-based coding interaction, see this site’s DeepSeek-TUI guide. Other multi-step agents may focus on research or execution orchestration; their entry points, authorization, and runtime differ.
How a request becomes executable work
The official domain model separates Source, Trigger, Thread, Eval, Ticket, Mandate, Assignment, Executor, and Channel. In short: a message arrives, the system decides whether to accept it, creates a work item, assigns execution, and returns the result.
|
|
Source and Trigger: distinguish the entry point from the event
A Source is where a message comes from, such as a GitHub repository or an enabled Feishu connection. A Trigger is a specific event produced by that Source. An issue, comment, or chat message may become a Trigger, but a message is not automatically an instruction to execute code.
This distinction helps manage authentication and policy for each entry point. Operators need to determine which repositories, discussions, or conversations are connected, how events are verified, and how duplicate deliveries are handled. Treating every webhook as a trusted command expands the agent’s authority by mistake.
Thread and Eval: group context and decide whether to accept
A Thread organizes related context. An incoming event may be added to a thread already subscribed by a Ticket, or passed to Eval to determine whether it expresses new work. Ignored or currently unavailable events can also be recorded, so casual conversation does not automatically become a task.
The key team decision is who may instruct the agent. The philosophy document describes either an explicit allowlist or a conversation the team has opened to requests. The team must define the actual scope. Support for GitHub or Feishu does not imply that every repository or group member has the same authority.
Ticket and Mandate: keep authorization attached to the task
When Eval accepts new work, it creates a Ticket with a Mandate. The Mandate defines the task’s scope and basis. The executor therefore receives more than an isolated comment: it gets relevant context and policy constraints.
When reviewing the prototype, inspect how Mandates are derived from requests and policy, which events may create Tickets, and how policy changes reach work already in progress. Code generation alone is not enough; reviewers should be able to tell why a request was accepted and whether its authorization constrains the work.
Assignment and Executor: assign each task to a session
Assignment hands a Ticket to an Executor. The repository describes execution through a separate DSH session. This separates work items at the session level and makes their status and results easier to inspect. It does not prove that a full container sandbox or strong security isolation exists. Check the actual DSH configuration and deployment to determine which directories, processes, credentials, and network capabilities are isolated.
The project also documents defaults for profiles, listening ports, and branch prefixes. Defaults are deployment guidance, not guarantees that every environment is safe. Before trying it, check existing DSH configuration, port conflicts, work directories, and the repositories available to that profile.
Channel: return results to the request location
Channel sends execution results back to the Source. The project philosophy aims to reduce progress noise after acknowledging a request, and to speak again when results are ready, a decision is needed, or work cannot continue. Teams should confirm who can see results and whether failure details could expose paths or sensitive data.
Design considerations for GitHub and Feishu
The GitHub entry point can turn repository issues, comments, or agreed events into work requests. Its advantage is that requirements, code changes, and review can stay in one collaboration context. The tradeoff is managing GitHub identities, repository permissions, event origin, and review of agent changes.
Feishu is an optional entry point for requests from team conversations. Chat provides richer natural-language context, but its permission boundary can be ambiguous: who in a group may assign work, whether forwarded messages count as authorization, and whether a message can trigger access to a repository all need explicit policy. Connecting a chatbot should not grant the whole organization access to a code executor.
Start with one entry point, one disposable test repository, a clear requester allowlist, and a known place for results. More entry points mean more identity mapping, deduplication, rejection, and audit paths to verify. Support for an entry point does not prove that production operations are mature.
Why start with observe mode
For automatic triggers or workflows that are not yet trusted, SETUP recommends beginning in observe mode. It lets the team see whether events are recognized and what the agent intends to do, while avoiding execution side effects.
Use harmless examples: a clear task from an allowed person, a request from someone outside the allowlist, an unrelated comment, a duplicate webhook, and a message with no repository context. Check whether expected tasks become Tickets, forbidden requests are only ignored or recorded, and the system can explain its decisions.
Do not treat a recorded plan as proof of safety. It may omit tests, misunderstand permission, or follow malicious repository content. Before execution, review tool permissions, workspace isolation, network and credential access, and human review of code changes.
Configuration and permission review
Because the prototype accesses code repositories, start with least privilege. The official SETUP recommends a dedicated GitHub agent account with only the permissions needed for the task. Keep it separate from a person’s everyday administrator identity, and plan how to revoke and rotate its credentials.
Do not paste model credentials, GitHub login details, or Feishu app secrets into chat or commit them to a repository. SETUP says actions requiring the operator to authenticate or enter an app secret must be performed by the operator in their own terminal or app. Check how the current project stores credentials and file permissions so readable secrets do not end up in a shared workspace.
Review these areas in order:
- Identity: Which GitHub users or Feishu conversations can create tasks? What happens when identity verification fails?
- Repository scope: Which repositories, branches, and organization resources can the agent account access? Can you begin with a test repository?
- Write access: Can the agent push, create branches, or open pull requests? Must people review every change?
- Runtime isolation: Are DSH session directories, processes, and credentials separated? Can a session access other host files?
- Network access: Can the agent contact arbitrary hosts? What code runs during dependency installation and builds?
- Audit: Can you trace a Trigger through Ticket, Assignment, execution, and reply? Do logs preserve secrets?
- Shutdown: How do you stop listeners, revoke GitHub access, disable Feishu, and end running sessions?
Answer these questions before moving from observation to execution. A dedicated account alone does not prove that workspaces and credentials are isolated.
Environment requirements for an initial evaluation
The current repository documentation lists Node.js, pnpm, Git, tmux, Python, GitHub CLI, and a supported DSH as dependencies. Package metadata also requires a recent Node version. Version requirements, alpha dependencies, and installation steps can change; do not copy a fixed command set from an older article and run it blindly.
If you plan to try it, begin with the current README and SETUP, then read the linked philosophy document. SETUP deliberately constrains installation: read the specified documents and run the environment probe first, collect answers, and only then prepare a plan. Do not execute setup until the operator confirms that plan. This helps avoid premature credential access or environment changes.
Minimum checks for a test environment:
- Node, pnpm, Git, tmux, Python,
gh, anddshare available to the intended runtime user. ghis authenticated as the dedicated agent account, not an accidental personal administrator account.- The selected DSH profile does not conflict with existing profiles; ports and work directories follow local policy.
- The target repository is set aside for testing and its contents can be discarded or restored.
- The model service and credential source meet team requirements, with no secrets exposed in messages or logs.
- Keep the optional Feishu integration disabled until identity and app permissions have been reviewed.
If any item is unclear, stay in the documentation or observation phase. Do not expand organizational access or hand personal credentials to the agent just to get it running.
Tasks suitable for evaluation
For a first task, choose something low impact and easy to review: explain a clearly scoped issue in a test repository, improve a small documentation section, or propose a limited patch. Specify allowed files, forbidden directories, required checks, and how to deliver the result.
Do not use production deployment, permission administration, dependency upgrades, or data migration as the first test. Do not let the agent approve or merge its own changes. The goal is to see whether the end-to-end path is understandable, reviewable, and stoppable, not to maximize automation.
After each trial, compare the original request, system decision, Mandate, actual changes, test results, and reply. If execution exceeded the request, fix the policy and boundaries before trying again.
Common questions and troubleshooting
A message did not create a task
Check whether the source is connected and the event reached it, whether the requester matches policy, and whether the message was recognized as new work. Then inspect the relevant Thread or record for an ignored, unavailable, or missing-context result. Do not “fix” acceptance by granting everyone administrator access.
A Ticket exists but did not execute
Check that the Ticket has an actionable Mandate, an Assignment was created, and the Executor and DSH profile are available. Then check runtime dependencies and session logs. Acceptance means the request became a task; it does not mean the runtime is ready.
The agent changed unrelated files
Stop subsequent automated work, preserve logs and the diff, and verify the repository, workspace, context, and allowed paths used by the task. If isolation is inadequate, disable write access or revoke credentials first. Prompt reminders cannot compensate for missing system-level path and permission controls.
Duplicate events created duplicate work
Check Source event IDs, Thread grouping, subscriptions, and whether Tickets refer to the same request. Confirm how this prototype version handles retries and duplicate delivery, then test with disposable events. Do not delete audit records to hide duplicate work.
Results did not return to GitHub or Feishu
Trace the Executor’s final status, Channel binding, and Source reply permissions. Distinguish an unfinished task from a completed task whose notification failed, and inspect the fallback path. Ensure results remain searchable if a reply failure would otherwise lose them.
Walk through the full chain with a simulated request
Before connecting a real repository, create a harmless sample request and check each step. This example explains the design; it is not a supported command or a claim that the project includes a particular test fixture.
|
|
Check that it becomes a Trigger from the correct Source, that the Thread contains the issue title and relevant comments, and that Eval recognizes an authorized work request. If the system can only express an execution Ticket and cannot enforce a read-only task, do not assume natural-language wording makes it read-only; restrict writes at the permission layer.
Next, verify that the Ticket’s Mandate preserves “explain only, do not modify.” Check which Executor receives the Assignment and which paths its session can read or write. When done, confirm the Channel reply includes the conclusion, file references, and failures, without leaking environment variables or local paths.
Record evidence for each stage: event ID, decision, Ticket identifier, policy version, execution session, and final message. If a stage cannot be observed, treat that as a trial risk rather than assuming its internal behavior is correct.
Counterexamples for request boundaries
Test an ambiguous request such as “also fix related things.” Does Eval ask for scope before accepting it? Can the Mandate specify directories, checks, and delivery? If not, the task should wait for clarification instead of allowing the agent to expand its own scope.
Test the same request from an account outside the allowlist. It should be rejected or recorded without assigning an Executor. Use a dedicated repository and fictitious content for rejection-path tests, not real credentials.
Add a comment after a Thread exists and check whether it updates the original Ticket or is mistaken for a new task. Re-deliver the same event and confirm that it does not create two concurrent write tasks against the same workspace.
Keep an evaluation record
Write a brief record of the first evaluation: revision or date, test environment, enabled entry points, allowlist, permission scope, and shutdown method. This lets the team compare behavior after dependency upgrades or prototype changes instead of relying on memory.
For each sample, record input, expected result, observed result, and evidence location. Cover at least these cases:
- An authorized request reaches the right Thread and gets a clear Mandate.
- An unauthorized user cannot assign work, and the rejection is auditable.
- An unrelated message is not promoted to code work.
- Duplicate events do not silently create duplicate write tasks.
- When DSH is unavailable, the Ticket records a traceable failure rather than claiming success.
- A person can independently review the agent’s diff and test output.
- Results remain available after notification failure, without triggering another execution.
- After disabling an entry point or revoking credentials, new events cannot start work.
These results describe only the tested examples in that environment; they do not prove safety for all input. Inspect repository content for prompt injection, malicious build scripts, or hooks that could read credentials. Coding agents should generally treat repository content as untrusted input.
Make pass criteria observable
“The agent understood the request” is difficult to measure. More useful criteria are observable: authorized requests create the expected Ticket; forbidden requests get no Executor; the Mandate matches the authorization; output is traceable to a session; a person can review changes before merging; and an operator can stop the system and revoke access.
Use these as gates before expanding permissions. Any isolation claim you cannot verify is still unverified; do not infer it from a project name or configuration comment.
How it differs from related projects on this site
SuperAgent is a broad label for multi-step task agents, not one unique product name. Long-running agents may focus on local research and execution orchestration; DeepSeek-TUI focuses on terminal coding conversations and tool use. dsh-superagent-prototype focuses on how requests from collaboration tools become policy-controlled execution tasks.
Compare projects by workflow, entry points, execution environment, and maturity rather than model name alone. Two projects may both call coding agents while differing in event triggers, identity rules, session lifecycle, and operational responsibility.
Ask where the team’s bottleneck is. For interactive individual coding, try a terminal tool first. For research and long-task orchestration, evaluate the relevant agent’s runtime model. If you need to connect repository conversations to auditable Tickets, this prototype is worth closer study.
Who should study the prototype
It is suited to developers and platform engineers studying how event-driven coding agents turn team requests into controlled tasks. Its value lies in readable domain concepts, policy entry points, and execution flow, which can inform discussions about permissions, message noise, and human handoffs.
If you need a stable enterprise automation service immediately, or expect an agent to write continuously to a production repository without review, do not assign that role to this prototype. Read the code, inspect dependencies, test in an isolated environment, and fill operational gaps in monitoring, upgrades, backups, and incident response.
Conclusion
The main point of dsh-superagent-prototype is not “DeepSeek has released another autonomous coding product.” It explores a traceable path from external messages through authorization policy and Tickets to separate Harness execution. It is explicitly a research prototype, and operators must decide whether its code and permissions fit their environment.
For further study, read the official README, SETUP, philosophy, and domain model. Observe event decisions in a minimal test repository, review isolation and permissions, then consider limited execution.