DeepSeek Harness Turns Every Agent Component into a Swappable Plugin

DeepSeek Harness is officially released.

The AI world these past few days has felt a bit like a festival.

First, Musk released Grok 4.6,

then DeepSeek just launched V4 Pro, and now they've brought out DeepSeek Harness.

Not long after being open-sourced on GitHub, it has already reached 50k stars, which is simply outrageous!

https://github.com/deepseek-ai/deepseek-harness

What is DeepSeek Harness?

Let's first clarify the word "Harness."

A large model itself is only responsible for understanding and generating content. To make it actually do work, you need to connect it to a file system, Shell, search, Skills, sandbox, and session management, and then use an Agent Loop to control it to continuously "think—call tools—check results."

The thing responsible for stringing all of this together is the Harness.

Simply put, the model determines how smart the Agent is, and the Harness determines how the Agent works.

This time, DeepSeek has fully open-sourced this Agent runtime framework under the MIT license. You can use it directly or build your own Agent on top of it.

But the truly interesting part of DeepSeek Harness is not just that it's open source, but its core design:

「Everything is a plugin」

Everything is a plugin.

The "everything" here is not just a promotional slogan. The large model, tools, Skills, sessions, sandbox, file system, Agent Loop, task orchestration, and even the Web UI are all broken down into plugins.

In other words, there is no fixed combination within the framework that you must follow.

You can swap out the model, add or remove tools, reconfigure the Agent's execution loop, or assemble different capabilities for different tasks, without needing to tear down and rewrite the entire framework.

Its underlying layer uses the Cordis meta-framework. Plugins collaborate through services and events, with dependency management handled by the framework; when a plugin is uninstalled, its related capabilities and side effects are also revoked.

If you think of an ordinary Agent as a fully decorated house, where the furniture placement and room usage are basically fixed,

then DeepSeek Harness is more like a set of Lego baseplates.

The model is one piece, tools are another, Skills and the Agent Loop are others. Install what you need, swap out what doesn't fit, and reassemble a set according to your own tasks.

So, DeepSeek Harness is not another fixed-form Coding Agent.

The problem it aims to solve is: how to let developers assemble their own Agents.

After all that talk, let's get it running and take a look.

DeepSeek Harness provides a Web UI, and the installation threshold is not high. Have Node.js ready on your computer, then execute:

npx @deepseek-ai/dsh web

After the command runs, it will start a local web service at the default address:

http://127.0.0.1:3080

Open your browser, and you will see the DeepSeek Harness interface.

However, you can't start chatting right away on the first open; you need to complete two configurations.

In Settings → Models, fill in the model and API Key, then select a local project directory as the Workspace. DeepSeek Harness will read files, modify code, and execute commands in this directory, so don't just pick a directory containing important data right off the bat.

Starting from the source code is also not complicated:

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

After entering the Web UI, you can see that DeepSeek Harness provides four Agent preset modes:

They are not four unrelated Agents, nor are they just a few swapped prompt words.

The underlying layer is still the same Harness, just assembled with different tools, Skills, and runtime capabilities for different tasks.

Standard Mode

This is a general-purpose mode with relatively complete functionality.

Capabilities like file editing, Shell, web search, Skills, task planning, and sub-Agents are basically all equipped. If you don't know which to choose for the first time, just start with this mode.

PTC Mode

PTC mode retains most of the capabilities of Standard mode but changes the way tools are invoked.

When facing consecutive multi-step operations, the model can generate a TypeScript program and combine multiple tool calls through a single run_code, reducing the back-and-forth between the model and tools.

For simple tasks, the difference might not be noticeable, but once the call chain gets long, the difference becomes apparent.

Minimal Mode

Minimal mode only retains two tools: persistent Bash and str_replace_editor.

With fewer tools, the model has fewer choices to make. If the task path is already very clear and you just want the Agent to directly modify the code, this mode is actually more straightforward.

Creative Mode

This mode is more interesting.

Based on Standard mode, it adds Cordis runtime inspection, temporary plugin experimentation, and Agent Preset creation capabilities. The Agent can not only use existing plugins but also explore its own runtime environment, recombine capabilities, and even create new preset modes.

However, it may also run plugin code generated by the model, with higher permissions, making it more suitable for developers who know what they are doing. It is recommended to test it in an isolated project and controlled environment; don't just start messing with important codebases.

Looking at the four modes, you'll find that the focus of DeepSeek Harness is not on letting users choose between a few ready-made Agents.

What it really wants to do is let the same Agent temporarily change its form according to the task.

Assemble one set of plugins for writing code, swap to another for looking up information, and add sub-Agents and orchestration capabilities for complex tasks. The so-called "Everything is a plugin" truly lands here.

The official release also includes many built-in plugins, including models, tools, Skills, sandboxes, and UI:

Currently, DeepSeek Harness is still in the Developer Preview stage, and the official team has clearly warned that incompatible changes may occur later.

So, using it to replace Claude Code or Codex at this stage might be a bit early.

But if you are tinkering with Agents, researching Skills and tool orchestration, or want to build your own AI workflow, this project is indeed worth pulling down to take a look.

Ultimately, the model is only part of the Agent.

The model is responsible for thinking, and the Harness is responsible for getting the work done.

What DeepSeek has open-sourced this time is precisely the latter half.

As for what tricks "Everything is a plugin" can ultimately play out, I'm also quite looking forward to it.

I'll stake a claim here first, and after some hands-on practice later, I'll come back to talk about it.

I am Zhai Xiaonian, see you next time!

Follow the public account "Zhai Xiaonian" to read more shared articles.