TL;DR: DeepSeek Harness (dsh) is DeepSeek’s MIT-licensed agent runtime — the thing that runs an agent, not the model itself. Everything in it (models, tools, sessions, sandboxes, UI) is a swappable plugin, and a custom-provider config points it at any OpenAI-compatible endpoint, including a local Ollama server. It is also explicitly a developer preview with no GitHub releases and a “there will be compatibility-breaking changes” warning in the README.

	DeepSeek Harness (dsh)	OpenCode	OpenClaw
Best for	Plugin-based agent runtime with a local web UI	Terminal-first coding agent	Personal assistant agent with channels (chat apps)
License	MIT	MIT	MIT
Local models	Custom provider → any OpenAI-compatible baseURL	Ollama/any OpenAI-compatible endpoint	OpenAI-compatible endpoints, incl. Ollama
The catch	v0.1 developer preview, breaking changes promised	Narrower scope (coding only)	Heavy config surface, security history

Honest take: dsh is the most architecturally interesting agent runtime to go open source in 2026, and the MIT license is real — but today it is a preview you evaluate, not a daily driver you depend on. If you want a coding agent that works now, OpenCode is less machinery; come back to dsh when it ships an actual tagged release.

DeepSeek open-sourced Harness on August 13, 2026, alongside the V4-Pro-0813 model, and the repository’s growth broke records: as of October 14, 2026 it sits at 249.1k GitHub stars, 30.0k forks, and 21,405 commits. This review covers the v0.1 developer preview — what dsh actually is, whether the license holds up, how to run it against a self-hosted model, and where it is honestly not ready.

Is DeepSeek Harness an LLM evaluation framework?

No — and this is worth clearing up first, because a wave of August 2026 coverage framed it that way. DeepSeek Harness is an agent harness: the runtime layer that sits between a model and the real world, managing tool calls, sessions, permissions, sandboxes, and a web UI. The evaluation connection is indirect: the repository ships a benchmarks/ directory and a BENCHMARK.md, and DeepSeek’s own Terminal-Bench 2.1 result for V4-Pro-0813 (87.9, up from 72.1 for the April preview — DeepSeek’s own numbers, run in dsh’s “minimal” mode, not independently reproduced as of October 2026) credits dsh as the agent framework used in the run.

So dsh is the harness DeepSeek benchmarks with, not a benchmark suite you run models through. If you want a general evaluation framework for a locally served model, EleutherAI’s lm-evaluation-harness remains the standard tool; dsh does not replace it. What dsh competes with is Claude Code, OpenCode, and OpenClaw — agent runtimes.

Is DeepSeek Harness really MIT-licensed?

Yes. The repository at github.com/deepseek-ai/deepseek-harness carries a plain MIT LICENSE file, with third-party dependency licenses enumerated in THIRD_PARTY_NOTICES.md (checked October 14, 2026). There is no open-core split, no paid self-managed edition, and no usage threshold — a cleaner situation than several “open” releases we have covered this year, like OpenViking’s AGPLv3-plus-commercial-edition arrangement (see our OpenViking review).

Two caveats belong next to that clean license:

• There are no GitHub releases or tags. The Releases page is empty; the only version signal is the npm package, which has shipped 0.1.0-rc builds (community trackers observed rc.5 and rc.6 in August 2026). You are always running the tip of a fast-moving master branch with 21,000+ commits.
• The README warns in capital letters that there will be compatibility-breaking changes, and tells you to read SAFETY.md before running it. DeepSeek is being honest about preview status; take them at their word.

What does the plugin architecture actually mean?

Every capability in dsh is an independently mountable plugin — models, tools, skills, sessions, sandboxes, storage, loops, scheduling, and the UI itself. The kernel underneath is Cordis, a plugin framework the README documents with an academic paper reference. In practice this means the harness core does almost nothing by itself; the shipped web UI, the model adapters, and the tool set are all plugins you can replace, and third-party authors publish theirs under the dsh-plugin GitHub topic.

For self-hosters this is the genuinely new part. OpenCode and OpenClaw are applications with extension points; dsh is closer to a kernel with an application built on top as a demonstration. The trade-off is equally real: in a v0.1 preview with promised breaking changes, every plugin interface you build against is provisional.

How do you install dsh?

One command, no clone required:

npx @deepseek-ai/dsh web

The terminal starts a local server and opens the web UI at http://127.0.0.1:3080 (pass --no-open to skip the browser launch). The only prerequisite is Node.js. Building from source uses pnpm:

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

First-run setup happens in the UI: Settings → Models, where the built-in card expects a DeepSeek API key. Built-in third-party provider catalogs also exist — anthropic, openai, moonshotai (Kimi), and zai (GLM) — but OAuth-based providers such as Codex are not supported yet (per the official providers guide, October 2026).

Can dsh run against a local Ollama model?

Yes, through the custom-provider route — the docs don’t name Ollama, but they document exactly the mechanism it needs. dsh’s “Custom model API” accepts any base URL speaking one of three protocols: OpenAI Chat Completions (openai-completions), OpenAI Responses, or Anthropic Messages. Ollama serves an OpenAI-compatible Chat Completions API at http://localhost:11434/v1, so the wiring is a custom provider with that base URL.

The config lands in $DSH_HOME/profiles/web/cordis.patch.yml (the web profile belongs to dsh web). The official example, adapted to a local endpoint:

- id: llm-pi-ai
  config:
    providers:
      local-ollama:
        apiKeyEnv: OLLAMA_API_KEY
        api: openai-completions
        baseURL: http://localhost:11434/v1
        models:
          - id: qwen3.8:27b

Three details from the docs worth knowing before you fight them:

• Provider IDs are permanent. Rename means create-new-and-delete-old.
• Keys are write-only and stored in $DSH_HOME/.credentials.yaml; the UI shows only a redacted descriptor after saving. Ollama ignores the key value, but the field must exist — set the env var to any placeholder.
• A real problem we hit on paper: MISSING_CREDENTIAL. If the referenced environment variable is unset and no key is stored on the Models page, requests fail with this error. The fix is either export OLLAMA_API_KEY=ollama in the server’s environment or saving a placeholder key in Settings → Models. Adapters re-read config on the next request, so no restart is needed.

The model catalog page can auto-discover models by querying the endpoint’s GET /models, which Ollama answers — if discovery fails, enter the model ID by hand.

Hardware floor for the local backend is the same as for any serious local agent work: a 27B-class model like Qwen3.8-27B (Apache 2.0, Q4_K_M ~16.8GB, ~41 tok/s on an RTX 3090 — setup in our Qwen3.8-27B guide) wants a 24GB card. A used RTX 3090 runs $1,399–$1,450 as of October 2026, and if you’d rather test the workload before buying, a rented 3090 on Vast.ai starts from about $0.07/hr (market pricing, September 2026). For the full GPU-tier math, see runaihome.com’s Strix Halo and local AI hardware guide.

Agentic quality is the honest asterisk: dsh was built and benchmarked around DeepSeek V4-Pro’s tool-calling behavior. A 27B local model will complete multi-step tool loops less reliably than the frontier model the harness was tuned against. The plumbing works; calibrate expectations about the driver.

How does dsh compare to OpenCode and OpenClaw?

All three are MIT-licensed and run against self-hosted endpoints, but they are different shapes of tool:

	dsh v0.1	OpenCode	OpenClaw
Scope	General agent runtime + web UI	Coding agent (terminal)	Personal assistant across chat channels
Architecture	Everything-is-a-plugin (Cordis kernel)	Monolithic app, provider config	Gateway + channel/skill config
Releases	None tagged — rolling master	Tagged releases	Tagged releases
Local model path	Custom provider, 3 protocols	First-class Ollama support	OpenAI-compatible config
Maturity	Developer preview, breaking changes promised	Production-usable	Usable; notable security history

If your goal is “a coding agent on my own model this afternoon,” OpenCode remains the shorter path — our OpenCode self-hosted setup guide covers it. If you want an always-on personal agent, that’s OpenClaw’s territory — along with its security caveats. dsh’s pitch is longer-term: a runtime where the pieces are swappable, from a lab whose models (see our DeepSeek V4-Pro self-hosting guide) are already MIT. For agent coding backends in editors, aicoderscope.com’s Kilo Code vs OpenCode vs Cline comparison is the deeper dive.

When should you NOT use DeepSeek Harness?

• You need stability. No tagged releases plus an explicit breaking-changes warning means any plugin config or automation you build can break on the next npx pull. Pin nothing, promise nothing.
• You want an audited, sandboxed agent today. The README points at SAFETY.md for a reason: the agent reads and edits workspace files and runs commands, gated by a permission policy you should actually read. Agent containment is not a theoretical concern in 2026 — our Kimi K3 containment write-up covers what happens when harnesses meet open network access.
• Your provider needs OAuth. Not supported yet; API-key providers only.
• You’re choosing by star count. 249k stars in two months measures the DeepSeek news cycle, not production readiness. The commit history is real engineering; the version number is still 0.1.

FAQ

Does DeepSeek Harness require a DeepSeek API key? No. The built-in model card expects one, but any custom OpenAI-compatible or Anthropic-compatible endpoint works through the custom-provider flow — including a local Ollama or vLLM server. Nothing in the MIT license or the runtime ties you to DeepSeek’s API.

Is DeepSeek Harness the same thing DeepSeek used for its Terminal-Bench scores? Yes — the V4-Pro-0813 Terminal-Bench 2.1 score of 87.9 (vendor-reported, August 2026) credits dsh in minimal mode as the agent framework. Publishing the harness makes those runs reproducible in principle, but the scores themselves remain DeepSeek’s own numbers.

Can dsh run fully offline? The runtime itself is local (Node.js server, UI at 127.0.0.1:3080), and with a local model endpoint no inference traffic leaves your machine. The initial npx install needs the network, and the docs make no offline guarantee for plugin fetching — if air-gapped operation is a requirement, build from source and audit SAFETY.md and the network behavior first.

Sources

• deepseek-ai/deepseek-harness on GitHub — license, README, install, star/fork counts (accessed October 14, 2026)
• dsh official docs: model providers guide — custom endpoints, protocols, config paths
• dsh official docs: user guide — web UI setup and permissions
• DataNorth: DeepSeek releases V4-Pro-0813 and open sources Harness v0.1 — release date, Terminal-Bench figures
• Blockchain.news (citing DeepLearning.AI): DeepSeek Harness enables reproducible LLM tests — the benchmark-reproducibility angle

What self-hosting actually costs

Real cost breakdowns for self-hosted AI: hardware floors, power, maintenance hours, and the honest comparison against paying for it. No spam, unsubscribe anytime.

Email address Subscribe