DSH Superagent Autonomous Proactive Coding Suite

DSH Superagent Autonomous Proactive Coding Suite

Official Core
@deepseek-ai/dsh-superagent-prototype·v0.9.1-prototype·core

DSH Superagent is an open-source proactive coding agent prototype engineered by DeepSeek for DeepSeek Harness. Operating under a minimal human attention principle, it continuously monitors GitHub and Feishu event streams, autonomously launching isolated workspace sessions to inspect repositories, execute code modifications, submit pull requests, and deliver concise updates through an interactive human-in-the-loop dashboard.

Superagent · DeepSeek · Proactive Coding · Code Review · Task Scheduling

GitHubNPM
Installation & Integration
bash
manager:
$ pnpm add @deepseek-ai/dsh-superagent-prototype

Introduction

In modern software engineering, deploying autonomous agents directly inside code repositories represents a major frontier for development velocity. However, current agentic frameworks frequently suffer from noise overload: uncoordinated models flood team communication channels with trivial progress logs or generate speculative, unvetted pull requests that consume disproportionate human review bandwidth. Addressing the fundamental tradeoff between agent autonomy and team attention, DeepSeek open-sourced DSH Superagent, an experimental proactive coding agent research prototype.

Engineered as a core extension bundle for the DeepSeek Harness agent runtime, DSH Superagent implements the foundational design principles articulated in DeepSeek’s research on autonomous super-agent systems. The architecture anchors on a single guiding philosophy: consume as little human attention as possible while delivering maximum engineering value. The system never acts unprompted without authorization. Instead, it monitors event triggers from GitHub and enterprise messaging platforms like Feishu. When an allowed team member requests assistance, the scheduler launches an isolated execution session to analyze repository context, write tests, modify code, and submit pull requests, speaking only when human action or critical architectural decisions are strictly required.

Core Features

Minimal-Distraction Proactive Decision and Admission Engine

DSH Superagent incorporates an admission and triage pipeline centered on the MasterAssessor module. When external triggers arrive, the engine validates user permissions against explicit allowlists and evaluates task feasibility before initializing runtime resources. During active code execution, the agent remains entirely silent, eliminating intermediate status updates. It re-engages the team only when a production-ready pull request is delivered, when an unrecoverable environment failure occurs, or when a fundamental design decision requires human guidance, posting concise questions directly to the originating discussion.

Strongly Typed Domain Model and Transactional Engine

The architecture replaces ad-hoc shell scripting with a robust domain model comprising Triggers, Threads, Decisions, Tickets, and Assignments. The core Engine executes state transitions synchronously within strict atomic transaction boundaries backed by a local store. Each active ticket receives a partitioned working directory on disk, ensuring isolated git operations. If worker processes experience interruption or network partitioning, the underlying effects queue and transaction log guarantee clean recovery without duplicating requests or corrupting repository state.

Unified Source Plugin Architecture and Enterprise Messaging Bridge

To integrate seamlessly into existing development workflows, DSH Superagent abstracts event ingestion behind a modular Source plugin architecture, providing native adapters for GitHub and Feishu. The GitHub Source monitors issues, pull request review comments, and commit status checks, posting structured diff comments as a repository collaborator. The Feishu plugin allows developers to dispatch tickets directly from group chats via bot mentions, converting complex terminal workflows into structured conversational interactions while managing outgoing rate limits through a unified Outbox port.

Minimalist Human-in-the-Loop Web Panel and Hot Reloading

The frontend dashboard discards cluttered metrics and graphs in favor of an actionable task interface designed to surface only items requiring human judgment. Pending decisions and blocker questions are prioritized at the top of the interface, while healthy autonomous background runs occupy zero screen real estate. Operationally, the runtime supports hot configuration patching via volatile settings, allowing operators to update model provider configurations, adjust admission prompts, or modify access lists without restarting long-running host processes.

Quick Start

Cross-Platform Dependencies and Environment Setup

Running DSH Superagent requires Node.js version 20 or higher alongside the pnpm package manager. Configure terminal network proxies if required for outbound API calls:

bash
# Configure terminal network proxies for macOS and Linux
export http_proxy=http://127.0.0.1:7890
export https_proxy=http://127.0.0.1:7890

# Verify runtime prerequisites
node -v
pnpm -v
powershell
# Configure terminal proxy in Windows PowerShell
$env:http_proxy = "http://127.0.0.1:7890"
$env:https_proxy = "http://127.0.0.1:7890"

Repository Cloning and Dependency Installation

Clone the official repository from GitHub and install project dependencies:

bash
# Clone the repository and navigate into the workspace
git clone https://github.com/deepseek-ai/dsh-superagent-prototype.git
cd dsh-superagent-prototype

# Install dependencies and execute comprehensive type checks and tests
pnpm install
pnpm check

Guided Agent Setup and Service Startup

DSH Superagent includes an interactive setup protocol designed to be executed alongside an autonomous coding assistant:

bash
# Launch the DeepSeek Harness runtime with superagent mounted
pnpm start

# Prompt your coding assistant to read SETUP.md and complete configuration
# The assistant will guide you step by step through GitHub and Feishu credentials
powershell
# Launch development mode on Windows with configuration hot reloading
pnpm dev

Validating Webhooks and Ticket Processing

Once running, verify that incoming repository events trigger autonomous ticket creation:

bash
# Mention the bot in an issue on your connected repository
# Example: @superagent Please generate comprehensive unit tests for the auth module

# Verify local dashboard and API health endpoints
curl -s http://localhost:3000/api/health

Frequently Asked Questions

Why does the agent fail to respond when mentioned in a repository issue?

The silence indicates that DSH Superagent’s strict admission policy has filtered the event. To prevent unauthorized resource consumption and accidental repository mutations, the engine rejects triggers from accounts not explicitly enumerated in the team’s allowlist. Inspect your configuration settings to ensure the author’s GitHub username or messaging handle is present in the permitted list. Additionally, verify that the event payload directly mentions the configured bot identity, as passive ambient discussions are intentionally ignored to prevent noise.

How do I resolve Git authentication or push failures during pull request creation?

When an executor completes local code edits but fails to push changes to the remote repository, the issue typically stems from expired access tokens or missing network proxy settings inside worker shells. Ensure that the personal access token configured in your settings has repository write and pull request creation scopes. In network-restricted environments, verify that HTTP and HTTPS proxy variables are exported in the host supervisor environment so that spawned Git subcommands can traverse outbound proxies.

Can I adjust model providers or admission prompt guidelines without restarting the service?

DSH Superagent natively supports live configuration reloading through volatile settings patches. When you modify model endpoints or prompt templates in the web dashboard, the settings observer updates parameters in place without dropping active worker sessions. If you only need to adjust admission strictness, updating the Markdown prompt files immediately influences the next evaluation cycle, enabling rapid policy tuning during ongoing team sprints.

How does the agent handle ambiguous requirements or conflicting architectural patterns?

Rather than generating speculative code that risks architectural regression, DSH Superagent stops by impact rather than effort. When encountering missing specifications or conflicting conventions, the executor generates a structured question card and suspends the ticket. Team members can answer directly within the pull request thread or management dashboard, allowing the agent to ingest the clarification and resume execution without restarting from scratch.