DeepSeek Super Agent: How It Works, Setup Guide, and Practical Examples

DeepSeek Super Agent brings coding tasks into the conversations where development work already happens. A developer can mention an agent account in a GitHub issue, describe a change, and receive a pull request in the original discussion.

The public project, dsh-superagent-prototype, runs on DeepSeek Harness. Each deployment serves one GitHub repository, with an optional Feishu integration for chat requests. DeepSeek describes the release as a research prototype and explains that parts of its broader design remain unimplemented.

This guide explains its architecture, walks through a GitHub-first setup, and provides a practical task you can reproduce in a demonstration repository.

What Is DeepSeek Super Agent?

DeepSeek Super Agent is a repository automation system that combines incoming messages, authorization rules, coding sessions, and delivery tracking.

Its components have different responsibilities:

DeepSeek Harness uses a plugin architecture, while the Super Agent package supplies a workflow for handling repository work. The published Super Agent package is MIT-licensed and marked private, so the documented installation builds it from source.

A useful evaluation question is whether this workflow reduces the effort required to turn team requests into reviewed changes.

How Does DeepSeek Super Agent Work?

The system separates deciding whether work should begin from carrying out that work.

A simplified request flow looks like this:

The official domain model uses several terms:

• Trigger: An incoming event, such as a comment.
• Eval: The assessment of whether that event should start work.
• Mandate: The authorization and scope attached to accepted work.
• Ticket: The record of that work.
• Assignment: The connection between a Ticket and its executor.

These records allow the system to track why a task began, which conversation it belongs to, and what the worker is authorized to do.

Router and worker responsibilities

The main session routes requests. Worker sessions inspect the relevant sources, make technical decisions, implement changes, and verify their work.

Teams can customize communication rules, ticket scope, and delivery requirements. Workers also read the repository’s AGENTS.md, making it a useful place to document project commands and conventions. 

What “proactive” means

Super Agent supports three acceptance modes:

Authorized explicit requests can execute in every mode, including observe.

For example, an allowed developer mentioning the agent with a concrete request can start a task while proactive behavior remains under observation. The host enforces authorization rules; messages and quoted documents cannot grant themselves additional permissions. 

Before Installation: Prepare the Environment

For an initial evaluation, use a demonstration repository and a dedicated agent account.

The published requirements include:

You also need a configured model provider and a GitHub repository the agent can access.

Plan the execution environment before connecting credentials. The published router and worker presets run commands with full access as their operating-system user. Account wrappers select credentials, and separate task directories organize work; they do not provide operating-system isolation. The deployment guide recommends a dedicated OS account for isolation. 

How to Install DeepSeek Super Agent

Option 1: Use the guided setup

The repository recommends asking an existing coding agent:

Read SETUP.md in this repository and set up dsh-superagent with me.

The setup procedure collects the repository, account, allowed users, checkout location, and delivery preferences. It then presents a plan before execution. Login and secret-entry steps remain with the operator.

This route is useful when you want assistance configuring the complete environment. 

Option 2: Follow the manual installation

The following sequence is for a fresh installation. Check the current repository documentation before upgrading an existing deployment.

Step 1: Install Harness and build the bundle

The deployment guide currently pins this Harness version:

npm install -g @deepseek-ai/dsh@0.2.1-rc.3

Download and build Super Agent:

git clone https://github.com/deepseek-ai/dsh-superagent-prototype.git dsh-superagent
cd dsh-superagent
pnpm install
pnpm build

Create its dedicated profile and install the local bundle:

dsh superagent --from-default-profile web --dump-config > /dev/null
dsh plugin --profile superagent add "link:$PWD"

Run the profile-creation command only for a new installation. Reusing it can replace an existing profile and remove its machine configuration.

Step 2: Configure the agent’s GitHub identity

Give a dedicated GitHub user account write access to the demonstration repository. The published prototype requires a user account because it reads that account’s notifications.

Create a GitHub CLI wrapper with its own configuration directory:

mkdir -p "$HOME/.local/bin"

cat > "$HOME/.local/bin/gh-agent" <<'EOF'
#!/bin/sh
GH_CONFIG_DIR="$HOME/.config/gh-agent" exec gh "$@"
EOF

chmod +x "$HOME/.local/bin/gh-agent"

Authenticate as the agent account:

"$HOME/.local/bin/gh-agent" auth login
"$HOME/.local/bin/gh-agent" api user --jq .login

Check that the final command returns the intended agent username.

Step 3: Configure the profile

Use the repository’s example to configure:

~/.dsh/profiles/superagent/cordis.patch.yml

Its basic structure is:

- id: webserver
  config:
    host: 127.0.0.1
    port: 3082

- id: dsh-superagent
  config:
    stateDir: /absolute/path/to/superagent-state

Replace the state directory with a real absolute path on the agent’s machine. Follow the example’s instructions when applying it to the newly created profile. 

Step 4: Start the service

Run these commands from the Super Agent checkout:

scripts/dsh-superagent start
scripts/dsh-superagent status

The control script starts the dedicated profile through tmux. It reports runtime health and outstanding setup requirements.

Open the local address printed during startup.

Configure Models, Sources, and Execution

Connect a model provider

In the Harness Web UI:

1. Open Settings → Models.
2. Enter your DeepSeek API key in the DeepSeek provider card.
3. Save the configuration.
4. Select an available model.

Harness also documents third-party providers and custom API endpoints. With a custom endpoint, its configured protocol must match the service it calls.

A provider appearing in the interface does not establish that a particular model performs well on your repository. Evaluate its tool use and task completion with representative work. 

Configure the Superagent panel

Open Superagent in the sidebar, then use its Settings groups:

For a first trial, one concurrent worker makes behavior easier to inspect. Keep merging with a human while evaluating the results. These are rollout recommendations, rather than performance requirements. 

Prepare a repository checkout for each task

The prepare command runs before a Ticket’s first Assignment. Without one, the worker begins in an empty directory.

A worktree-based setup lets each Ticket work on a separate branch. The following follows the official execution pattern; replace /absolute/path/to/repo with your local clone:

git -C /absolute/path/to/repo fetch --no-tags \
  "https://github.com/$DSH_SUPERAGENT_GITHUB_REPOSITORY.git" \
  "${DSH_SUPERAGENT_GITHUB_PR_HEAD:-HEAD}:refs/dsh-superagent/$DSH_SUPERAGENT_TICKET" &&
git -C /absolute/path/to/repo worktree add \
  -b "agent/$DSH_SUPERAGENT_NAME" \
  "$DSH_SUPERAGENT_DIR" \
  "refs/dsh-superagent/$DSH_SUPERAGENT_TICKET"

The runtime supplies the Ticket variables. Verify the clone path and authentication before submitting work.

Define a useful delivery standard

A team can add requirements such as:

Keep changes within the requested scope.

Use the repository's existing validation commands.

In each pull request, explain the behavior changed,
the verification performed, and any remaining limitation.

Leave merging to a human reviewer.

Adapt this text to your project. A frontend repository may require browser evidence, while a library may prioritize compatibility checks and executable examples.

Practical Example: Fix an API Cost Calculator

Consider a calculator that mistakenly treats a token price of zero as missing.

The bug could come from a validation condition such as:

if (!inputRate || !outputRate) {
  throw new Error("Missing token price");
}

JavaScript treats 0 as falsy, so a legitimate zero-priced rate fails validation.

This is a useful tutorial task because its scope and expected behavior are easy to review.

1. Submit a concrete request

From an allowed GitHub account, create a new issue or comment:

@YOUR_AGENT_ACCOUNT

Fix the API token-cost calculator so input and output
rates of 0 are accepted.

Reject missing, negative, and non-finite rates.

Add regression coverage for:
- zero input price
- zero output price
- both prices equal to zero

Use the existing test runner.

Open a pull request with before-and-after examples.
Keep the published model prices unchanged.
Leave merging to a human.

2. Follow the task through the panel

Inspect the incoming event, its assessment, the resulting Ticket, and the worker’s progress. The panel provides separate Trigger, Eval, and Execution views, including states that require an answer or review.

3. Check the expected behavior

For rates expressed in dollars per million tokens:

Cost =
  input_tokens / 1,000,000 × input_rate
  + output_tokens / 1,000,000 × output_rate

Example acceptance cases:

These are illustrative test values.

Review whether the implementation distinguishes zero from missing values, preserves valid existing behavior, and supplies evidence for its checks.

4. Continue with focused feedback

A review comment could say:

Also reject an empty string as a missing rate.
Keep numeric zero valid, and add one regression case.

The prototype supports delivering follow-up discussion to the Ticket’s executor, subject to its existing scope and authorization. 

DeepSeek Super Agent vs. Claude Code vs. GitHub Copilot

All three can participate in coding workflows. Their deployment and operating models deserve closer attention than unsupported claims about which is “smarter.”

The Claude Code entries follow Anthropic’s overview and GitHub Actions documentation. The Copilot entries reflect GitHub’s current cloud-agent guide.

For evaluation:

• Try Super Agent when your objective is to study or customize persistent repository task intake.
• Consider Claude Code when developers want coding assistance across several working surfaces.
• Consider Copilot in the cloud when your team wants to delegate repository work through GitHub with a hosted execution option.

These are workflow-based recommendations. Code quality, completion time, and cost require a controlled evaluation on your own tasks.

How Much Does DeepSeek Super Agent Cost?

The prototype’s MIT license allows use and modification. Operating it can still incur expenses.

Budget for:

• Model inference during assessment and execution.
• Search or other paid tools used during tasks.
• The machine or server running the service.
• Human setup, review, and maintenance time.

DeepSeek’s API pricing distinguishes input, output, cache usage, and applicable pricing periods. Consult the current rates when estimating a deployment. 

A useful evaluation metric is:

Cost per accepted change =
  total trial operating cost / accepted useful changes

Also record review time. A cheap task that requires extensive correction may provide little practical value.

Troubleshooting

Start with:

scripts/dsh-superagent status

The service script distinguishes these conditions:

Codes 2 and 3 require configuration or component attention; repeatedly restarting does not resolve their underlying cause. 

If a mention produces no task, inspect the Source, allowed-user list, and processing state. For GitHub, post a new comment when testing: adding a mention by editing an existing issue body is not received through the documented notification workflow. 

How to Evaluate Your First Deployment

Begin with three bounded tasks: one documentation correction, one reproducible bug, and one small feature with clear acceptance criteria.

Record whether each task:

1. Started from the intended request.
2. Stayed within scope.
3. Produced a correct, reviewable change.
4. Reported verification accurately.
5. Reduced human effort after review and correction.

Expand access or proactive rules only when the observed behavior supports doing so. This follows the project’s stated approach of starting narrowly and reducing unnecessary interruptions.

Build Real-Time AI Applications with Tencent RTC Agent Skills

Coding agents become more useful when they have guidance for the specific technologies your application uses. For developers building communication or voice AI features, Tencent RTC Agent Skills provides workflows for project inspection, supported SDK integrations, feature development, and troubleshooting grounded in official Tencent RTC documentation.

A practical starting point is a Web voice AI assistant using Tencent RTC Conversational AI, with DeepSeek as its language model. The skills can guide supported coding agents through the relevant integration steps and help answer questions about APIs, configuration, error codes, and product limits. Explore the supported workflows.

Run the installer inside your project directory:

npx -y @tencent-rtc/trtc-agent-skills@latest add

Then describe the task:

Help me build a Web voice AI assistant with Tencent RTC
Conversational AI and DeepSeek as the language model.

Inspect my existing project, identify the integration steps,
keep credentials on the server, and guide me through
verifying a basic voice conversation.

The published installer supports Claude Code, Codex, Cursor, and CodeBuddy. For a DeepSeek Super Agent deployment, verify skill loading and tool compatibility in DeepSeek Harness separately before incorporating these workflows.

Explore Tencent RTC Agent Skills to start with a supported development environment and an integration task relevant to your application.