# What Is DeepSeek-Harness? A Complete Introduction

> Source: <https://findharness.com/blog/what-is-deepseek-harness>
> Published: 2026-08-18 01:37:37+00:00

# What is DeepSeek-Harness? A Complete Introduction

DeepSeek-Harness (dsh) is DeepSeek's open-source agent harness where every feature — tools, commands, skills, MCP — is a plugin. Here's how it works.

DeepSeek-Harness, commonly shortened to **dsh**, is an open-source agent harness built by DeepSeek AI. Its defining idea is "everything is a plugin": the CLI, the web UI, tool access, slash commands, skills, and even MCP server connections are all implemented as plugins on top of a general-purpose plugin framework called [Cordis](https://github.com/cordiverse/cordis). There is no separate manifest format for each capability type — one plugin mechanism covers all of them.

dsh is currently in **developer preview** (version `0.1.0-rc.5`

at the time of writing). The project's own README is explicit about what that means: expect compatibility-breaking changes as the framework iterates.

["Everything is a plugin" — what that actually means](#everything-is-a-plugin--what-that-actually-means)

Most agent tools split their extensibility into separate systems: one format for tools, another for slash commands, another for skills, another for MCP configuration. dsh collapses all of that into a single concept. A plugin is just a JS/TS module that exports an `apply(ctx, config)`

function, and depending on what it registers on `ctx`

, it can become any of the following:

| You want to add... | The plugin registers... |
|---|---|
| A tool the model can call | `ctx.tools.register()` |
A slash command (`/xxx` ) for the UI | `ctx.commands` |
| A skill (injected prompt + tool) | a prompt section plus a tool, injected on invocation |
| An MCP server's tools | one plugin per MCP server, discovering and registering its tools via `ctx.tools.register()` |
| A hook into agent/tool lifecycle events | a listener on extension points like `agent/pre-step` or `tools/pre-execute` |
| A new LLM provider | a `LlmAdapter` registered via `ctx.llm.registerAdapter()` |
| A background/cron job | `ctx.jobs` |

Notably, dsh ships official bridge plugins — `dsh-hooks-claude-code`

and `dsh-hooks-codex`

— that translate an existing Claude Code or Codex `hooks.json`

into dsh's own hook extension points, so hook configs from those ecosystems can be reused rather than rewritten.

If you've used a harness where skills, commands, and MCP connections each need their own config file, this is the biggest conceptual shift: in dsh, they're all just code that calls `ctx`

.

[Installing dsh](#installing-dsh)

The fastest way to try it is to run it straight from npm, no clone required:

```
npx @deepseek-ai/dsh web
```

This starts the web UI, listening by default on `http://127.0.0.1:3080`

.

If you want to work from source instead — useful if you're developing your own plugin against the latest framework code — clone and build the repo directly:

```
git clone https://github.com/deepseek-ai/deepseek-harness.git
cd deepseek-harness
pnpm install
pnpm run build
pnpm dsh web
```

[Profiles: how dsh keeps configurations separate](#profiles-how-dsh-keeps-configurations-separate)

A **profile** is a named, runnable configuration — a directory under `$DSH_HOME/profiles/<name>`

(with `$DSH_HOME`

defaulting to `~/.dsh`

) that lists which plugin bundles are active and in what order. You start dsh against a specific profile:

```
dsh --profile <name>
```

`dsh web`

is actually shorthand for `--profile web`

, and `dsh --profile headless "<task text>"`

runs a one-shot task with no UI at all. Profiles are how you keep, say, a minimal headless automation setup separate from a plugin-loaded web UI setup, without them stepping on each other's configuration.

Plugins are added to a profile with:

```
dsh plugin --profile <name> add <specifier>
```

We cover this command — and the npm/GitHub/local-path sources it accepts — in detail in [How to Install DeepSeek-Harness Plugins](/blog/how-to-install-dsh-plugins).

[The plugin ecosystem today](#the-plugin-ecosystem-today)

Here's the part that matters if you're trying to find plugins worth installing: **DeepSeek AI does not run an official plugin marketplace or registry.** The only first-party discovery mechanism is a convention — plugin authors are encouraged to tag their GitHub repository with the topic [ dsh-plugin](https://github.com/topics/dsh-plugin) so it can be found by search. There's no central review process and no official list.

Into that gap, the community has built its own directories. The most actively maintained one is [ awesome-dsh-plugin/awesome-dsh-plugin](https://github.com/awesome-dsh-plugin/awesome-dsh-plugin), a curated, hand-reviewed list that currently tracks

**365 plugins across 11 categories**— UI Enhancements, Tools & Capabilities, Workflow & Automation, Memory, Development & Runtime, and more.

That's exactly the gap FindHarness exists to close. We index those community-discovered plugins with real GitHub metadata — stars, license, last-push date, and full READMEs — so you can browse, search, and compare them like a proper catalog instead of scrolling a single giant README. Start with [/plugins](/plugins) to search the full list, or [/categories](/categories) to browse by what a plugin actually does.

[Where to go next](#where-to-go-next)

- Ready to install something:
[How to Install DeepSeek-Harness Plugins (2026 Guide)](/blog/how-to-install-dsh-plugins)covers the exact`dsh plugin add`

syntax, every supported source, and the security tradeoffs of installing from GitHub. - Want recommendations first:
[10 Best DeepSeek-Harness Plugins in 2026](/blog/best-deepseek-harness-plugins)ranks real, installable plugins by GitHub stars across categories. - Building your own plugin:
[How DeepSeek-Harness Plugins Work Under the Hood](/blog/dsh-plugin-development-primer)walks through the`apply(ctx, config)`

contract and how to get a plugin discovered.