DeepSeek Harness: the open-source agent runtime where everything is a plugin

On August 13 2026, DeepSeek open-sourced something different. Not a new model — a harness. DeepSeek Harness (dsh) is the runtime layer that sits around an AI model and offers a lot of features: file access, terminal commands, tool calling, session memory and a web interface. The project's central formula is simple: Model + Harness = Agent. The model handles thinking; the harness handles everything else.

What makes it interesting isn't the DeepSeek branding — it's that the harness is completely model-agnostic. Under the hood, every capability (the model connector, the tool registry, the agent loop, the sandbox, even the UI) is a swappable Cordis plugin. You can point it at DeepSeek's API, at OpenAI, at Anthropic or at a local Ollama server running on your own hardware. Nothing is locked in.

What it actually does

DeepSeek Harness ships as a local web app. One command starts it:

npx @deepseek-ai/dsh web
# Web UI → http://127.0.0.1:3080

From there you configure a model provider, pick a workspace directory and start prompting. The agent can read and write files, run shell commands, search the web (via a plugin), delegate work to sub-agents and maintain context across a session. It reads AGENTS.md and CLAUDE.md files, supports MCP as a client and can even delegate tasks to Claude Code or Codex binaries if you have them installed.

The whole thing runs on your machine. It serves localhost only — there is no cloud component, no telemetry endpoint, no usage cap.

The plugin architecture

The "everything is a plugin" claim is the architectural core, not marketing. DeepSeek Harness is built on Cordis, a dependency-injection framework designed for spatiotemporal composability. In practice this means:

• Models are plugins. The default adapter (dsh-llm-pi-ai) speaks the OpenAI chat-completions protocol, so any OpenAI-compatible endpoint works.
• Tools are plugins. File editing, terminal access, web search — each is a separate mount.
• Sessions, sandboxes, the scheduler — all plugins.
• The web UI itself is a plugin that can be replaced.

You add, remove or replace any of these at runtime through configuration, without touching the source code. A patch layer (cordis.patch.yml) lets you swap components declaratively.

How it compares to Claude Code and Codex

	DeepSeek Harness	Claude Code	OpenAI Codex	Hermes Agent	OpenCode
License	MIT	Proprietary	Open source	MIT	MIT
Language	Node.js (Cordis)	TypeScript	TypeScript	Python	Go
Model	Any (multi-vendor)	Anthropic only	OpenAI only	Any provider	Any (multi-vendor)
Interface	Web UI + headless	Terminal	Terminal	TUI + messaging gateway	Terminal
Extension	Cordis plugins	Hooks / MCP	Hooks / MCP	Skills + MCP	LSP + MCP
Learning loop	No	No	No	Yes — skill creation, memory	No
Scheduling	No	No	No	Built-in cron	No
Terminal backends	Local only	Local	Local	Local, Docker, SSH, Modal, Daytona…	Local, Docker, SSH
Subagents	Yes	Yes	Yes	Yes (RPC)	Yes
MCP support	Yes	Yes	Yes	Yes	Yes
Maturity	Developer preview	Production	Production	Production (233k+ stars)	Production

The field is growing fast. Claude Code and Codex are finished products tied to their own model providers. Hermes Agent is the most mature open-source option with a self-improving learning loop. OpenCode is a lightweight Go-based alternative that prioritizes terminal-native workflows. DeepSeek Harness sits in the middle — more architecturally ambitious than all of them thanks to Cordis, but earlier in its lifecycle.

Where DeepSeek Harness stands out

The Cordis plugin system is unique among these five tools. Every layer — model connector, tools, execution loop, UI — is a swappable mount. No other agent listed here lets you replace the UI or the scheduler without touching the source code. DeepSeek Harness also ships compatibility bridges for Claude Code (hooks.json) and Codex, positioning itself as a meta-framework rather than a direct replacement.

Where Hermes Agent stands out

Hermes Agent is the only one with a closed learning loop. It creates skills from experience, persists knowledge across sessions and builds a model of who you are. It also runs on seven terminal backends including serverless options (Modal, Daytona) where the agent hibernates when idle. If you need your agent running on a remote VM or talking to you via Telegram while you're away from your desk, Hermes Agent does that out of the box.

Where the others fit

OpenCode is a strong choice if you want a fast, Go-based terminal agent with LSP support and no heavy dependencies. Claude Code and Codex remain the most polished options if you're already locked into their respective ecosystems.

For users who want to run their model locally, Hermes Agent is the best pick if you want a mature agent that learns and runs anywhere. DeepSeek Harness is the best pick if you want maximum architectural flexibility and don't mind being an early adopter. OpenCode is the best pick if you want a lightweight, fast terminal agent without the overhead.

Advantages

• Fully open source (MIT). You can inspect every line, modify it and self-host without restrictions.
• Model-agnostic. Works with DeepSeek, OpenAI, Anthropic, Google or any OpenAI-compatible endpoint — including local models via Ollama.
• Plugin architecture. Every layer is swappable. If you don't like how it handles files, replace the file plugin. If you want a different UI, mount another one.
• Local-first. No cloud dependency. The harness serves localhost only.
• MCP support. Connects to the broader Model Context Protocol ecosystem.
• Multi-model workflows. Route heavy reasoning to a cloud model and confidential tasks to a local one within the same session.

Disadvantages

• Developer preview (v0.1.0-rc.5). DeepSeek explicitly warns about compatibility-breaking changes. The session format carries no stability guarantee.
• Not production-ready. Suitable for evaluation and internal experiments, not as your only tool for critical work.
• Limited platform support. The web UI works everywhere, but persistent terminals (PTY) need POSIX — Windows support is partial.
• No terminal UI. Only a web interface and a headless mode exist today. No TUI.
• Young ecosystem. The plugin catalog is growing but still small compared to mature frameworks.
• Requires Node.js (^22.19 or >=24). Odd-numbered releases like Node 23 are not supported.

Configure it with local models via Ollama

The whole point of a local-first harness is pairing it with models that run on your own hardware. Here's how to point DeepSeek Harness at a local Ollama server.

1. Start Ollama

Make sure Ollama is running and you have pulled at least one model:

ollama pull qwen3:8b

2. Start DeepSeek Harness

npx @deepseek-ai/dsh web

Open http://127.0.0.1:3080 in your browser.

3. Add a custom model provider

Open Settings → Models and click Add a custom provider. Fill in:

Field	Value
Provider name	Ollama Local
Base URL	http://localhost:11434/v1
API type	OpenAI-compatible

If the endpoint doesn't support model listing, add your model ID manually (e.g. qwen3:8b).

4. Handle compatibility

Ollama's OpenAI-compatible endpoint is not 100% identical to OpenAI's. You may need to toggle compatibility switches depending on your model:

• compat.supportsDeveloperRole: false — Ollama doesn't support the developer role that some agents send. Set this if requests fail with a role error.
• compat.maxTokensField: max_tokens — Ollama uses max_tokens instead of the newer field name.

These can be set in ~/.dsh/settings.yaml under the provider configuration:

llm-pi-ai:
  providers:
    ollama-local:
      baseURL: http://localhost:11434/v1
      apiKeyEnv: OLLAMA_API_KEY
      compat:
        supportsDeveloperRole: false
        maxTokensField: max_tokens
      models:
        - id: qwen3:8b
          input: [text]

5. Select the model

Back in the web UI, open the model picker and select your Ollama model. It becomes the default for new sessions.

Configuration reference

All configuration lives under ~/.dsh:

Path	Purpose
settings.yaml	Global settings: default model, provider config, permissions
.credentials.yaml	API keys (write-only, never returned to the browser)
cordis.patch.yml	Plugin mount/unmount overrides
profiles/	Per-profile directories (web, headless, custom)

Useful diagnostic commands:

dsh web --dump-config              # Show the full composition tree with override sources
dsh web --dump-default-config      # Show bundle-layer defaults only
dsh web --port 8080                # Use a different port

The bottom line

DeepSeek Harness is the most architecturally ambitious open-source agent framework released in 2026. The "everything is a plugin" design on top of Cordis gives it a flexibility ceiling that closed tools like Claude Code can't match — you can swap the model, the tools, the execution loop and the UI without forking the project.

But it's a developer preview. The APIs will change, the plugin ecosystem is young and the session format is unstable. If you're evaluating agent frameworks for internal use, it's well worth trying — especially paired with local models where its privacy and cost advantages shine. If you need something battle-tested for production today, Claude Code or Codex are safer choices.

For local-first users specifically, the combination of MIT license, model-agnostic design and localhost-only serving makes DeepSeek Harness one of the most interesting options for building private, self-hosted agent workflows. Pair it with Ollama and a capable local model and you have a full agent stack that never phones home.