awesome-deepseek-harness-plugins

Awesome DeepSeek Harness Plugins

English | 简体中文

A curated index of plugins, starters, tools, and primary resources for DeepSeek Harness (DSH).

DeepSeek Harness is DeepSeek AI's open-source, plugin-first agent harness: models, tools, skills, sessions, sandboxes, filesystems, loops, orchestration, and UI can all be composed as plugins.

Developer preview — DSH is changing quickly and may introduce breaking changes. This independent community list is not endorsed by DeepSeek AI or walkinglabs. Review source code and pin a DSH version/commit before installing any third-party plugin. 中文说明

flowchart LR
  User["Developer / User"] --> Web["DSH Web UI or CLI"]
  Web --> Runtime["DeepSeek Harness runtime"]
  Runtime --> Agent["Agent loop"]
  Agent --> Model["Model provider"]
  Agent --> Tools["Tools & skills"]
  Runtime -. loads .-> Plugins["Plugins"]
  Plugins --> Tools
  Plugins --> UI["Web UI extensions"]
  Plugins --> State["Sessions, settings & services"]

  classDef core fill:#0b65c2,color:#fff,stroke:#084c94;
  classDef plugin fill:#e6f4ff,color:#083b66,stroke:#4fa3e3;
  class Runtime,Agent core;
  class Plugins,UI,State plugin;

Quick Tutorial — Install DSH and Write Your First Plugin

1. Install and run DeepSeek Harness

Install a current Node.js release, then run:

npx @deepseek-ai/dsh web

Open http://127.0.0.1:3080. In Settings → Models, add a DeepSeek API key; then select a workspace before starting a session. The official Web UI guide explains the next steps.

2. Create a minimal plugin from source

Plugin development currently starts from an official DSH checkout:

git clone https://github.com/deepseek-ai/deepseek-harness.git
cd deepseek-harness
pnpm install
pnpm run build
mkdir -p scratch-plugin/src

Create scratch-plugin/src/hello-plugin.ts:

import type { Context } from '@deepseek-ai/cordis'

export const name = 'hello-plugin'

export function apply(ctx: Context) {
  console.log('[hello-plugin] loaded')
}

Then create scratch-plugin/cordis.yml. Replace the path with the absolute path printed by pwd in the DSH checkout:

- insert:
    - id: hello
      name: '/absolute/path/to/deepseek-harness/scratch-plugin/src/hello-plugin.ts'

Run the development overlay:

pnpm dsh web --patch ./scratch-plugin/cordis.yml

When DSH starts, the terminal should show [hello-plugin] loaded. This is the smallest valid DSH plugin: export apply(ctx) and register capabilities through the Cordis context. To add an agent-callable tool, declare export const inject = ['tools'] and register it with the documented DSH tool API. Follow the official first plugin and tool-plugin tutorials for the complete, current API.

3. How the plugin mechanism works

flowchart TD
  Overlay["cordis.yml overlay"] -->|loads| Module["Plugin module"]
  Module --> Contract["name · inject · apply(ctx, config)"]
  Contract --> Inject["inject: wait for required services"]
  Contract --> Config["Config schema: validate settings and defaults"]
  Contract --> Apply["apply: register capabilities"]
  Apply --> Capabilities["Tools · commands · events · UI · services"]
  Capabilities --> Runtime["Cordis / DSH runtime"]
  Runtime --> Effects["Lifecycle-managed effects"]
  Effects --> Cleanup["Unload or HMR: registrations are cleaned up"]

DSH is built on Cordis, a runtime composition framework. A plugin is not merely an npm dependency: it is a module that DSH loads into a live context. The plugin declares a name, optionally declares inject dependencies such as ['tools'], and exports apply(ctx, config). Cordis waits until injected services are ready, validates any exported Config schema and defaults, then invokes apply.

Inside apply, the plugin can register a tool for the agent, a human command, a settings schema, event listeners, Web UI components, or a service for other plugins. Registrations are lifecycle-managed effects: on unload or hot replacement after a config edit, Cordis removes old registrations automatically. Use ctx.effect() only when your plugin owns a resource needing explicit cleanup, such as a timer or network connection. See the official configuration guide, service guide, and capability seams.

4. What this awesome list includes

flowchart TB
  Discover["GitHub discovery\n(recent public candidates)"] --> Verify["Source-level DSH verification"]
  Verify -->|"Manifest/package + documented DSH seam"| Plugin["Verified DSH plugin"]
  Verify -->|"Explicit, inspectable DSH integration"| Resource["Client, launcher, example, or dev resource"]
  Verify -->|"Topic/name/claim only"| Exclude["Excluded\n(not a DSH plugin)"]
  Plugin --> List["Plugin categories in this list"]
  Resource --> List
  List --> Daily["Daily review\nOnly real changes are committed"]

The list distinguishes verified DSH plugins from useful but non-plugin resources such as launchers, clients, and ecosystem directories. See the full inclusion policy for the evidence required before a new entry is added.

5. One runtime, different compositions

DSH profiles are plugin compositions rather than separately maintained products. The official base bundle includes model adapters, tools, persistence, sandbox and approval policy, settings, credentials, and telemetry; Web and headless bundles add different entry surfaces. An agent preset can then give a session a different capability set.

flowchart TB
  Base["dsh-base\nmodels · tools · persistence · sandbox\napproval · settings · telemetry"]
  Base --> WebProfile["Web profile\nbrowser application"]
  Base --> HeadlessProfile["Headless profile\none-shot runner"]
  Base --> Preset["Agent preset\nper-session capability composition"]
  Preset --> Loop["Agent loop"]
  Preset --> Toolset["Toolset"]
  Preset --> Providers["LLM / filesystem / subagent providers"]
  Preset --> Policy["Permission & sandbox policy"]

This makes a “mode” primarily a selected plugin graph and policy set. It does not guarantee that every composition is stable or suitable for every task; DSH is still a developer preview.

6. Tool calls use one guarded execution pipeline

flowchart LR
  Call["Model emits tool call"] --> LoggedCall["Log tool/call"]
  LoggedCall --> Pre["tools/pre-execute\nhooks · permission · sandbox"]
  Pre --> Ask{"Approval needed?"}
  Ask -->|approved| Guards["Monotonic guards"]
  Ask -->|denied / unavailable| Denied["Skip tool body"]
  Guards --> Execute["tools/execute\ntimeout · retry · metrics"]
  Execute --> Body["Tool execute()"]
  Body --> Post["tools/post-execute\naccept · block · replace"]
  Denied --> Post
  Post --> Result["Finalize & log tool/result"]
  Result --> UI["UI result card"]
  Result --> Next["Next model request"]

Plugins can insert policy, observability, timeout, or result-handling behavior at documented stages without editing the Agent Loop. The official pipeline also routes Code Mode's dispatched sub-calls through this same path, preserving the approval, sandbox, and logging boundaries.

7. Agent turns, steps, and the append-only session log

sequenceDiagram
  participant U as User
  participant A as Agent loop
  participant P as Prompt assembler
  participant M as Model
  participant T as Tool pipeline
  participant L as Append-only session log
  U->>A: followup(message)
  A->>L: turn/start + user/message
  A->>P: assemble prompt sections + tool schemas
  P->>M: request
  M-->>L: assistant/chunk*
  M-->>L: assistant/message
  M->>T: tool/call*
  T-->>L: tool/result*
  A->>L: step/end
  alt more input or tool results are owed
    A->>P: next step
  else no pending work
    A->>L: turn/end
  end

The session log is the model-context source of truth: durable events record turns, messages, tool calls/results, and raw stream chunks. Forking, resuming, replay, transcripts, telemetry, and persistence derive from that stream; model-visible content must be reconstructable from it.

8. Multi-agent and workflow extension points

flowchart TB
  Parent["Parent agent\nplans, delegates, aggregates"] --> Subagent["Subagent capability seam"]
  Subagent --> Fresh["Fresh child agent"]
  Subagent --> Fork["Forked / continued session"]
  Subagent --> External["External product provider\n(e.g. ACP-backed)"]
  Parent --> Workflow["Workflow capability"]
  Workflow --> Parallel["Parallel branches"]
  Workflow --> Pipeline["Pipeline stages"]
  Workflow --> Background["Background work"]
  Fresh --> Events["subagent/* + session/event"]
  Fork --> Events
  External --> Events
  Workflow --> Events
  Events["Durable session events + live agent events"] --> Inspect["UI, trajectory, replay, telemetry"]

DSH provides a hierarchy-oriented delegation surface and workflow components; providers behind the subagent seam can vary. The key architectural point is replaceability and shared observability, not a claim that DSH has invented a new multi-agent paradigm.

Contents

• Start Here — Official DSH Resources
• Install and Discover Plugins
• Productivity & Agent Workflow
• Context, Memory & Observability
• Tools, Integrations & Automation
• Design & Creative Tools
• Browser, Computer Use & Remote Execution
• Interfaces & Web UI
• Developer Tooling
• Utilities
• Creative & Personal
• Games & Play
• Launchers & Clients
• Ecosystem Indexes
• Contributing
• License

Start Here — Official DSH Resources

• DeepSeek Harness - Official source repository; the primary reference for releases, issues, and compatibility.
• Documentation guide - Official documentation portal supplied by the DSH project.
• Run DSH - Start the local Web UI with npx @deepseek-ai/dsh web.
• Architecture - How the plugin-first DSH runtime is structured.
• Capability seams - Extension boundaries for DSH capabilities.
• Cordis primer - Introduction to the underlying composability framework.
• Development guide - Build DSH from source and contribute upstream.
• Defensive patterns - Official guidance for safer extensions.
• Testing - DSH testing approaches.
• Examples - Official headless, JSON-RPC, MCP-memory, scheduled-web, and Cordis examples.
• DeepSeek Harness Discussions - Official feedback and community forum.
• DeepSeek Harness Discord - Community chat linked by the official repository.

Install and Discover Plugins

• dsh-plugin-index - In-DSH plugin index that trusts only the dsh.bundle.patch field in package.json: 10,000+ verified third-party plugins, one-click install, plus a companion website. Verified against the DSH developer preview (2026-10).
• GitHub topic: dsh-plugin - The official recommended GitHub topic for DSH plugin repositories.
• Plugin registry - A lightweight repository-plugin console and make-dsh-plugin development guide.
• Plugin workshop - Community plugin-marketplace and registry workshop.

Curation policy

The dsh-plugin topic, a dsh- repository name, or a README claim alone is not enough for an entry in this list. Every new plugin must meet the source-level verification policy in INCLUSION_POLICY.md: a real DSH plugin manifest/package or a verifiable, official DSH extension seam. Discovery runs daily over projects from the previous 48 hours; candidates also undergo static security triage of scripts, dependencies, entrypoints, workflows, and sensitive operations. Only candidates that pass both checks are added. This is not a complete security audit or a compatibility guarantee.

Productivity & Agent Workflow

• dsh-autocompose - Find and compose DSH plugins from a task description, then open an independent chat environment or install the plan into the current profile. Compatible with DSH 0.2.0-rc.2.
• dsh-file-claim - File claim/release protection for parallel DSH sessions in one workspace, with stale-heartbeat takeover and a pending three-way-merge area.
• dsh-worktree - Permanent Codex-style Git worktrees, agent tools, /worktree, and per-repository manifests.
• dsh-at-file - Codex-style @file mentions that search a workspace and attach file contents to prompts.
• dsh-open-in-vscode - Open a DSH workspace directly in VS Code from the Web UI.
• dsh-plannotator - Anchored plan annotations and structured agent feedback.
• dsh-product-subagent-console - Conversation-level multi-agent workbench for editable task planning, real child-session observation, plan-versus-runtime comparison, and evidence-backed recovery previews; tested with DSH 0.1.1-rc.2.
• dsh-crew - Dispatch DSH workers from Claude Code or Codex with in-host sessions, live progress, workspace locks, and recursion guards; external CLI workers are an explicit opt-in and use their documented always-approve modes.
• dsh-daily-progress - Daily-progress workflow plugin.
• dsh-revive - Resume interrupted sessions with a command, tool, and browser control.
• dsh-book2skill - Five-stage book-to-skill workflow with human approval gates.
• dsh-loop - Scheduled loops with a /loop command, tool, and activity bar.
• dsh-automation - Run coding tasks in fresh agent sessions on a schedule.
• dsh-agent-teams - AgentTeams integration for DSH.
• jev-dsh-decision - Decision-engine bundle that registers DSH tools and skills; with a user-configured TYPESAFE_API_KEY, minimal task state is sent to the documented TypeSafe API for structured decision results.
• dsh-jev - Decision layer for DSH’s pre-step, tool-assessment, observation, skill, and model-routing seams; defaults to local mock/shadow behavior, while explicit live mode sends redacted task state to TypeSafe and can request approval or withhold a call.
• Deepseek-harness-MELOS - Builder-to-reviewer relay workflow with DSH tools, agent rings, and a host panel; invokes its bundled Python core as a local child process.
• dsh-interconnect - Cross-instance message and event handoff service plus tools.
• dsh-team-rooms - Persistent, cross-session multi-agent team rooms with members, a message bus, a shared task board, approval-gated handoffs, and a timeline that survives restarts; installs via the dsh.bundle manifest (npm dsh-team-rooms), maintained on the dsh-v0.1.5-rc.2 host line.
• dsh-autotier - Automatic strong/cheap model-tier routing: intent-gated tier landing on the agent/request waterfall, plan-mode handoff, deterministic high-risk guards, and TTL escalation fallback; installs via the dsh.bundle manifest (npm dsh-autotier), maintained on the dsh-v0.1.5-rc.2 host line.
• dsh-turn-rewind - Restore conversation and workspace state through a persistent change ledger.
• dsh-undo - Context undo/redo around the last completed agent step.
• dsh-openbiliclaw - OpenBiliClaw client integration with recommendation and agent-bridge tools.
• dsh-chat-import - Import full-fidelity conversation histories from 13 coding agents (Claude Code / Codex / ChatGPT / Cursor / Gemini / Reasonix / opencode / ZCode / Grok Build / OpenClaw / Pi / Hermes / Kimi) as resumable DeepSeek Harness sessions, with reverse export/sync back to Claude Code.
• dsh-routed-subagent - Run a one-shot subagent fully mounted on any agent preset from any session, with per-call model/provider override, model pre-check, and external CLI engines (codex / claude / codebuddy) with background jobs, live progress, kill, and continuable sessions.
• dsh-fork-to-preset - Fork any session into a different agent preset from the conversation header: a preset picker creates a new child session mounted on the chosen preset, inheriting the source session's completed turns.
• experts-management - Expert manager: manage ntd-format experts and expert teams (plugin.json + Agent MD + skill sets), browse and install from a built-in market of 50+ experts, and run tasks in an expert persona via /expert- without consuming model directory tokens; installs via the dsh.bundle manifest (npm @weibaohui/experts-management).
• dsh-continue - Auto-resume for interrupted DSH agent sessions: an ordered rule table routes by failure type (rate limit, quota, auth, context overflow, crashed orphan) into backoff retry, model switch, resume after compaction, or stop-loss notification, with a visual rule editor and activity log; installs via the dsh.bundle manifest (npm @weibaohui/dsh-continue).
• dsh-tasks - Scheduled tasks: run a prompt on cron schedules, each run opens a new agent session to do the work, with workspace binding, manual run, session auto-naming, and a fullscreen task management page; installs via the dsh.bundle manifest (npm @weibaohui/dsh-tasks).
• dsh-smart-title - Smart session titles for DSH: after each conversation turn an independent auxiliary LLM call summarizes the full user+assistant transcript into a title that follows the session's real topic instead of echoing the first message; the first message is titled instantly, failed built-in titles auto-retry on later turns, manual renames are never overwritten, and subagent/fork sessions are skipped; installs via the dsh.bundle manifest (npm @weibaohui/dsh-smart-title).
• dsh-process - Process management: brings ntd-style processes (multi-stage, multi-step agent workflow templates) into the dsh web UI — browse, edit, validate, import/export and AI-generate processes; the built-in library is read-only while the personal library is writable with live file sync, and agents read the library through process_* tools and advance work stage by stage; installs via the dsh.bundle manifest (npm @weibaohui/dsh-process).
• dsh-auto-review - Second-model auto-review on the approval answerer chain: a read-only reviewer subagent returns structured allow/deny verdicts with reasons, fail-closed by default. Declares compatibility with DSH 0.1.6-alpha.2.
• dsh-background-agents - Durable background child agents on the official subagent seam: start from any session, watch progress in the Web UI sidebar, message and interrupt any time, with per-child tool scoping, persona and delegation-depth caps. Declares compatibility with DSH 0.1.6-alpha.2.
• dsh-checkpoint-rewind - Claude Code /rewind for DeepSeek Harness: git-first workspace snapshots before every mutating tool execution, turn-boundary session forks, and a one-shot /rewind command that restores files and forks the session back to a checkpoint. Declares compatibility with DSH 0.1.6-alpha.2.
• dsh-defend - Detects prompt-injection, jailbreak, and secret-leak patterns on the agent/pre-step, tools/pre-execute, and tools/post-execute seams with allow/ask/block tiers, sanitized defend/detection audit events, a defend_report tool, and a destructive-delete command guard. Declares compatibility with DSH 0.1.6-alpha.2.
• dsh-doublecheck - Engineering-discipline guard: requirements grill before the first edit, red/green test-evidence gates, forked adversary review, and a delivery report with a per-dimension verification workflow. Declares compatibility with DSH 0.1.6-alpha.2.
• dsh-permission-rules - Claude Code-style declarative permission rules: ordered allow/deny/ask YAML rules matching tool names, arguments, workspace paths, and agent identity on the tools/pre-execute waterfall, with full session-log audit, dry-run mode, and hot reload. Declares compatibility with DSH 0.1.6-alpha.2.
• dsh-laya - Laya typed decisions (noul yes/no, choice, score) as a first-class Cordis service plus the model-visible laya_ask and laya_plan tools; it installs and downloads nothing and talks to a laya-mcp serve sidecar you start yourself.
• dsh-flow - Execution flow chart: renders the current session's execution as a vertical node flow (turns, user, assistant, tools, approvals, retries, compaction), appended in real time over SSE with auto-follow scrolling, so the chart draws wherever the session executes. Installs via the dsh.bundle manifest (npm @weibaohui/dsh-flow).
• dsh-favorites - S