DeepSeek Harness: The Open-Source Agent Runtime Where Everything Is a Plugin

DeepSeek just shipped the missing half of its agent stack. DeepSeek Harness v0.1 is now in developer preview — an open-source agent harness released under the MIT license and built around one idea: everything is a plugin. Models, tools, skills, sessions, sandboxes, filesystems, loops, orchestration, and the UI are all implemented as plugins you can mix, match, replace, and extend. Here's what the harness actually is, how its Cordis-based architecture works, and why "agent = model + harness" matters if you build or self-host agents.

What Is DeepSeek Harness?

DeepSeek Harness (dsh) is an open-source agent harness developed by DeepSeek AI and released under the MIT license. It's the runtime layer that wraps a language model so the model can understand its environment, use tools, and keep working through multi-step, real-world tasks. (GitHub)

DeepSeek frames the split cleanly: the model is the soul of an agent, and the harness is what lets that agent perceive its environment, call tools, and keep going in real settings. In other words, agent = model + harness. A strong model without a harness is just a very expensive autocomplete; the harness is what makes it act. (DeepSeek)

This fills an obvious gap. DeepSeek's V4 models are open-weight, MIT-licensed, and priced well below frontier closed models — but the remaining weakness has been agent reliability, which is fundamentally a harness problem. Harness is DeepSeek's answer, positioned against Anthropic's Claude Code as an open, buildable alternative. (CryptoBriefing)

"Everything Is a Plugin": The Cordis Architecture

The defining design choice is that every agent capability is a plugin. Harness is built on the Cordis meta-framework, and the Cordis kernel handles mounting, unmounting, and dependencies between plugins. The agent's actual capabilities live entirely in those plugins. (DeepSeek)

What counts as a plugin? Nearly everything:

• Models — the LLM backend itself
• Tools — file editing, shell, file and web search
• Skills — reusable capabilities the agent can invoke
• Sessions — conversation and run state
• Sandboxes — isolated execution environments
• Storage / filesystems — where state and artifacts live
• Loops & scheduling — the agent's control flow and subagent scheduling
• UI — even the interface is a plugin

Cordis services and events let these plugins talk to each other. The practical payoff: you can select, swap, or extend any capability in configuration without touching the DeepSeek Harness source code. Want a different sandbox, a custom tool, or a different model backend? Mount a plugin instead of forking the runtime. (DeepSeek)

That's a meaningfully different posture from monolithic agent tools where the loop, tools, and UI are welded together. Here the harness is a thin kernel and a bag of composable parts.

Four Runtime Modes

Harness ships with four preset modes that recombine the same plugins for different jobs: (DeepSeek)

• Standard mode — the full coding agent: file editing, shell, file and web search, skills, planning, goals, subagents, and workflows.
• Code mode — all Standard capabilities, but tools are exposed through a Code Mode SDK so the model can combine multi-step operations in a single TypeScript program instead of many separate tool calls.
• Minimal mode — a stripped, two-tool agent: persistent bash plus a str_replace_editor. This is the mode DeepSeek used for its own official model benchmarking, so it doubles as a clean environment for evaluating a model with minimal scaffolding.
• Creator mode — for building your own presets: inspect the live runtime, test Cordis plugins in memory, and combine them into new modes.

Minimal mode is worth flagging if you read model announcements: DeepSeek ran its published Code Agent benchmarks in "Harness minimal mode," which is why your production numbers depend heavily on the harness and scaffolding you actually use. We covered that caveat in our DeepSeek V4 Flash official API breakdown.

Every Run Is Traceable

The second design principle is observability. Everything the model sees is recorded in an append-only session log — system prompts, reasoning, tool calls and their results, subagent scheduling, and every context injection. (DeepSeek)

A Trajectory view lets you inspect those records by source, and because the log is a single event stream, you can resume, fork, search, and replay any run against the same history. For anyone debugging why an agent went off the rails, an inspectable, replayable event log is the difference between guessing and knowing.

Why MIT and Open Source Matter Here

The license choice is strategic. MIT is one of the most permissive open-source licenses — it essentially lets anyone use, modify, and build commercial products on the code, the same license behind foundational tools like React and Node.js. (CryptoBriefing)

That extends DeepSeek's broader pattern: competitive model performance paired with aggressive open-source releases, at a time when OpenAI has moved away from open-source, Anthropic never embraced it, and Meta's Llama ships under a custom, restricted license. An MIT-licensed harness plus MIT-licensed open weights means a team can, in principle, run a capable agent stack end to end without a proprietary vendor in the loop. (CryptoBriefing)

How to Try DeepSeek Harness

Harness is a Node.js project. The fastest path is the hosted Web UI via npx:

npx @deepseek-ai/dsh web

That launches the Web UI, served at http://127.0.0.1:3080 by default. To run from a source checkout instead:

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

DeepSeek also encourages a plugin ecosystem — you tag a plugin repo with the dsh-plugin topic for discoverability, and feedback goes through GitHub Discussions and a Discord community. (GitHub)

One important caveat: Harness is in developer preview and iterating rapidly. DeepSeek warns plainly that there will be compatibility-breaking changes, and core plugins and APIs will keep evolving. Treat v0.1 as something to experiment and build plugins against, not to pin a production system to yet. (GitHub)

Who Should Care

• Agent builders — if you're designing your own agent loop, a plugin-based kernel with swappable tools, sandboxes, and orchestration is a ready-made foundation to extend rather than reinvent.
• Teams running DeepSeek models — Harness is the intended runtime to turn V4-series models into reliable autonomous coding agents, closing the model-plus-runtime gap.
• Self-hosting and sovereignty-minded teams — MIT harness + MIT open weights is a fully open path to running agents without a proprietary vendor lock.
• Anyone comparing agent benchmarks — knowing a score was produced in "minimal mode" tells you how much of the result is model versus scaffolding.

Do This With Your Own AI Workforce

A plugin-based, model-agnostic harness is powerful precisely because it lets you swap the best model into each step without re-architecting — and that's the same bet Eigent makes. Eigent is an open-source, multi-agent "Cowork" desktop app that orchestrates specialized agents across real workflows locally, so you can wire DeepSeek's models (or any other) into concrete jobs instead of stitching a runtime together by hand. If you want to see that in practice on agentic coding tasks, look at how Eigent handles reviewing GitHub PRs, or download Eigent to build your own AI workforce.

Frequently Asked Questions

What is DeepSeek Harness?

DeepSeek Harness (dsh) is an open-source, MIT-licensed agent harness from DeepSeek AI. It's the runtime layer that wraps a language model with tools, sandboxes, sessions, and orchestration so the model can act as an autonomous agent on multi-step tasks. It launched in developer preview as v0.1.

What is the Cordis meta-framework?

Cordis is the plugin system Harness is built on. Its kernel manages mounting, unmounting, and dependencies between plugins, while every agent capability — models, tools, skills, sandboxes, storage, loops, scheduling, and the UI — lives in a plugin that can be swapped or extended through configuration.

Is DeepSeek Harness free and open source?

Yes. DeepSeek open-sourced the codebase under the MIT license, one of the most permissive open-source licenses, which allows commercial use, modification, and redistribution.

What are the four runtime modes?

Standard (the full toolset), Code (tools exposed through a Code Mode SDK so the model orchestrates multi-step operations in one TypeScript program), Minimal (a two-tool bash-plus-editor agent used for benchmarking), and Creator (for inspecting the runtime and building custom presets).

Is DeepSeek Harness ready for production?

Not yet. It's in developer preview and iterating rapidly, and DeepSeek explicitly warns of compatibility-breaking changes. It's best used now for experimentation and building plugins rather than pinning a production system to it.