DeepSeek Harness 速通：一切皆插件，Agent 在运行中插拔自己

After the official release of DeepSeek V4 Pro yesterday, the long-teased Agent product from DeepSeek has finally arrived.

Its name is DeepSeek Harness.

The philosophy is clear: everything is a plugin.

Possibly the fastest ever—by the time I finished writing this, it had hit 37,000 stars on GitHub.

Honestly, after trying it out, going through the developer docs thoroughly, and using a few plugins, I think this is a genuinely special product.

It’s bound to be polarizing: those who like it will say it’s the future; those who don’t will say it’s too rough, has no user experience, and no one can figure out how to use it.

So in this post I want to try to talk through a few questions: what is DeepSeek Harness as I understand it? Why use a very engineering name like DeepSeek Harness instead of DeepSeek Code? And how the hell is this thing supposed to be used?

Let’s start with how to understand DeepSeek Harness.

DeepSeek put a very important formula on its official site:

Agent = Model + Harness.

This formula was proposed by LangChain when they talked about Agent Harness. A good Agent must be made up of both a Harness and a model. If you’re not familiar with Harness, you can check out an explainer I wrote earlier: “Read This One Article to Understand What the Viral Harness Engineering Actually Is.”

The Claude Code, Codex, and Workbuddy you use are all essentially Harnesses. They need to be paired with models like Claude Fable 5 or GPT 5.6-Sol; otherwise they’re just empty shells.

A Harness is actually quite complex—it contains a lot of parts.

Tools, the Skills system, sessions, sandbox, storage, the Agent loop, scheduling, sub-agents, workflows, and so on.

In the past, all of these were wrapped up inside a shell named after a piece of software, like Codex.

Almost everything mentioned above is prebuilt by the vendor. We’re mostly using a software service the vendor keeps providing—a product—while all those internals are hidden in the back end. Ordinary users can’t see them and don’t need to know about them.

The only things ordinary users actually customise and manage are Skills, MCP, and the like. Everything else is packaged by Codex; you can’t change it, and you wouldn’t bother changing it anyway.

In DeepSeek Harness, all of these things—every single one—are packaged as plugins. That means you can customise all of them.

It’s like the modular phones we used to play with: every hardware part could be swapped out by us.

DeepSeek Harness is similar. There is only one true core, a kernel called Cordis. Its author joined DeepSeek, and this time they even published an 88-page paper.

The kernel does one very restrained thing: it only handles plugin loading, unloading, and dependency management. It doesn’t care about anything else.

The killer feature is that you can swap plugins while the Agent is running without crashing its state.

The core is based on two properties:

Temporal composability—when a plugin is unloaded, can the side effects it produced be fully undone?

Spatial composability—if a plugin depends on other plugins, can it dynamically re-resolve its dependencies when those plugins appear, disappear, or change?

Once you look at these two properties, you’ll get it.

The whole point of the Cordis kernel is to let an Agent keep developing, installing, and uninstalling plugins for itself while running—constantly plugging and unplugging to add or remove its own capabilities, forming a kind of self-evolution.

That is the underlying mechanism of DeepSeek Harness.

So it’s less of an Agent product and more of a research demonstration: it ships with more than 100 first-party plugins to show off the Cordis kernel.

This is also the idea DeepSeek keeps emphasizing:

Everything is a plugin.

So now you know why DeepSeek calls it Harness instead of Code or Build, and why this release is also called a developer preview.

Because what they’ve built is not an Agent product; it’s infrastructure—a Harness system.

It needs developers from all over the world to come in, plug and unplug, and build all kinds of plugins, enriching the entire DeepSeek Harness ecosystem, forming a new-era platform while completing Agent self-evolution.

That’s why the whole community is split into heated debate.

One side says the idea is amazing and this is the future; the other side says who would actually use this—why would I bother plugging and unplugging for no reason.

Every new thing brings controversy, but it doesn’t matter. I think the best way for everyone is to just try it.

Official site is here:

https://www.deepseek.com/harness/

Install command:

npx @deepseek-ai/dsh web

If you can’t understand it or don’t know how to run it, just throw this command at any local Agent product you have and let it handle the installation.

Once installed, it will pop up a local URL.

npx @deepseek-ai/dsh web

Just copy it into your browser and open it.

The first run will ask you to fill in your DeepSeek API key. Go get one from the official site and remember to top up a little money.

API platform official site:

https://platform.deepseek.com/

After pasting it in, you can enter the homepage.

It’s a standard web UI, but even the interface itself is a UI plugin.

So you can freely change this UI as well.

For example, @黑哥小黑子 (blake), a friend in the group, casually made a skin plugin...

For models, you can choose between two: Flash and Pro.

You can also choose thinking effort.

One thing to note about the models: DeepSeek has officially announced a price increase.

And it’s not a small one. To be honest, the increase is a bit outrageous.

V4 Pro’s cache-hit price has gone up 12x directly.

The peak output price has reached an absurd 27 yuan.

With this price-to-performance ratio combined with DeepSeek V4 Pro’s capabilities, I think it has lost a lot of its former appeal as a price killer. I predicted around 2x before, but the peak-time increase is way too aggressive—starting at 3x.

Let me show you how current mainstream model prices compare.

Actually, it can no longer pull much of a gap over GLM or Qwen 3.8 Max.

Not to mention GLM-5.3 should be coming soon, with prices likely staying the same and capabilities basically being open-source SOTA again. Then in terms of API-only cost-effectiveness, DeepSeek V4 Pro may not beat GLM anymore.

In DeepSeek Harness, you’re not locked into DeepSeek models.

It supports adding model providers from the catalog, and also custom providers, Base URLs, protocols, and model lists. Later you can connect other vendors’ models freely.

For example, you can absolutely use GLM inside DeepSeek Harness.

Then go back to the homepage, click “Choose Workspace,” and add a project directory. This becomes the project file scope your Agent can operate on.

Next is the most special part, and the one ordinary users find hardest to understand—the part that confuses everyone: the four modes.

I think once you know about the Cordis kernel, you shouldn’t mistake these for DeepSeek Harness’s real modes.

They are just a few template presets—pure templates for out-of-the-box convenience.

Let me briefly explain the differences between the four modes.

1. Standard mode

If you’re a first-time user or don’t know the underlying mechanisms well, trust me—just pick Standard mode. It has full code-Agent capabilities, including file reading and editing, Shell, file search, web search, Skills, planning, goals, background tasks, sub-agents, workflows, and more. All these plugins are preconfigured for you.

2. PTC mode

PTC mode has all the capabilities of Standard mode.

The difference is in how tools are presented.

In Standard mode, the model typically makes one tool call, gets the result, then decides the next step. PTC mode gives the model a Code Mode SDK, letting it write a TypeScript program that combines multiple tool operations in a single run_code.

What used to take maybe five model round-trips—reading, searching, filtering, parallel calls, and result consolidation—can now be compressed into one program execution. This reduces back-and-forth chatter between the model and tools, suits structured, multi-step, parallel tasks, and saves tokens.

But this requires the model to have stable enough code-planning ability, and debugging is quite hard. Beginners don’t need to touch it; just use Standard mode.

Turn on PTC when you hit lots of repetitive tool round-trips, or when you want to test DeepSeek models’ programmatic tool-calling ability.

3. Minimal mode

Minimal mode gives the model only two core tools: a persistent Bash and a file editor.

It also fixes the system prompt to a very simple line: “You are a helpful software engineering assistant,” removing context compression and a bunch of extra abilities.

This mode is mainly for benchmarking models in the smallest environment.

For example, it’s great when you want to compare two models’ bare-Agent abilities.

But don’t use it for daily work, or you’ll find it basically unusable...

4. Creation mode

This is the most special part of DeepSeek Harness.

Creation mode has all the capabilities of Standard mode, and can also inspect its own running Cordis environment, experiment with plugins in memory, and help you create new Agents and plugins.

In other words, it lets an Agent modify itself directly.

For example, you can tell it:

“Build me a mode that can only read code and not modify files, dedicated to security auditing.”

Or tell it:

“Build me a research Agent that connects to internal company search, always uses a specific model, and has three dedicated Skills.”

You can even let the Agent inspect its existing plugins and capabilities first. If you find it lacks a plugin, you can create one on the spot and mount it onto the currently running process.

To use an analogy: the Agent realises it doesn’t have a wrench, so it builds one on the spot, plugs it onto its hand, and continues working with it.

This is the core feature of the entire DeepSeek Harness, and the best demonstration of the Cordis kernel.

Another developer-friendly and quite special thing about DeepSeek Harness is that they designed the session as an append-only event log.

The system prompts the model sees, user messages, reasoning content, tool calls and results, permission changes, context injections, compression, and sub-agent scheduling all become events in the log.

The history seen by the model in the next turn is also re-derived from this log.

This is genuinely meaningful and valuable.

After many Agents fail, you can only see task failure or infinite loops; you have no idea at which step it started going off track.

The trace view in the Harness lets you inspect every run by source. For developers, this means observability, auditability, and reproducibility, making it great for research.

All the official first-party plugins can be seen in the plugins section of the settings page. You don’t need to understand them; just use them directly.

If you feel something is missing, you can build it yourself in Creation mode.

Alongside DeepSeek Harness, a community plugin entry also launched.

There are many third-party plugins developed by the community.

I looked through them, and there are some good ones I think are worth recommending. They can greatly improve your experience.

1. dsh-at-file

https://github.com/omdsh-dev/dsh-at-file

Once installed, you can just type @ in the input box to reference files. Very convenient.

2. dsh-genui

https://github.com/omdsh-dev/dsh-genui

Lets the model render charts, tables, forms, diffs, Mermaid diagrams, interactive panels, and more directly in replies. Very useful.

3. dsh-automation

https://github.com/titanwings/dsh-automation

Adds automation capabilities to DeepSeek Harness. It’s a must-have, though the interaction design is a bit problematic = =

4. DSH-better-sidebar

https://github.com/omdsh-dev/DSH-better-sidebar

Adds a VS Code-like workbench to DSH: file management, code editing, a real terminal, Git, diffs, embedded browser, background tasks, and sub-agent status all packed into the sidebar. It makes DeepSeek Harness more capable and easier to use.

5. ModLens

https://github.com/liustack/modlens

Gives the text-only DeepSeek models visual capabilities. After configuring the vision channel, you can paste images directly into the conversation and the model can read them. A must-have.

Anyway, I’ll leave the other interesting parts of this Harness for you to explore.

Finally, I still want to say this.

DeepSeek Harness is a very interesting system, and the idea of plugging and unplugging plugins is great. But from a product perspective, it’s really not friendly to ordinary users.

Too many developer terms, too high a barrier to entry, too few features, and a poor user experience—every step can drive ordinary users away.

But DeepSeek is probably a team that places more emphasis on research and exploration.

As their slogan says:

Explore the unknown.

Go, DeepSeek.