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

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

On August 13, 2026, DeepSeek released Harness v0.1 as a developer preview, publishing the full source under the MIT license. The project ships as dsh at deepseek-ai/deepseek-harness on GitHub, where it gathered a large following fast — treat any star count you see quoted as a moving snapshot, not a stable fact. The organizing principle is direct: everything is a plugin.

That's not marketing copy. Models, tools, skills, sessions, sandboxes, storage, the agent loop itself, and the web UI are all Cordis plugins that can be swapped, replaced, or extended from configuration — without touching Harness source code. Most agent frameworks expose a few hook points and call it extensible. Harness has no privileged core. Every component is replaceable.

Why This Matters More Than the Model Announcement

DeepSeek shipped Harness alongside the general-availability release of DeepSeek-V4-Pro, their updated flagship model built for agentic workloads. The model benchmarks are notable — Terminal-Bench 2.1 at 87.9, DeepSWE at 62.7, Toolathlon-Verified at 74.1 — but they're self-reported. The harness is the more interesting half of the announcement, and it's the part that lasts regardless of which model sits behind it.

The agent infrastructure space is crowded. Claude Code is the best-known closed option; OpenCode, Aider, and others cover the open-source side — a comparison we have run elsewhere. But most of them are monolithic: the agent loop, tool registry, and session store are baked into the core, and "extensibility" means patching the source. Harness flips that. The extension path is: mount a plugin, configure it, done.

# Install and launch the Web UI
npx @deepseek-ai/dsh web

# Starts at http://127.0.0.1:3080
# Add a model API key in Settings → Models

The Architecture: Cordis Under the Hood

Harness runs on Cordis, a meta-framework designed around what its authors describe as "spatiotemporal composability." The kernel handles plugin mounting, unmounting, and dependency resolution. Capabilities live in the plugins, not in a privileged core.

This is a meaningful architectural difference. In most agent frameworks, the agent loop is the thing you can't replace — it's the fixed pipeline that everything else plugs into. In Harness, the agent loop is itself a plugin. You can swap it for a different control flow, a different scheduling strategy, or a custom orchestrator without rebuilding anything.

The plugin boundaries cover seven layers, per the project docs and independent rundowns:

• Models — inference providers
• Tools — file editing, shell access, web search, custom tool definitions
• Skills — higher-level task capabilities
• Sessions — append-only log of every context injection
• Sandboxes — execution isolation (the same isolation problem sandboxed training environments solve for agent evaluation)
• Storage — persistence layer
• Loops — agent control flow

Model routing is also a plugin, configured from the Web UI's Settings.

The Plugin-Swap Thought Experiment

Take the "no privileged core" claim seriously for a moment and walk one swap per layer using only the list above. Swap the model provider: same loop, same tools, different inference bill. Swap the loop: same tools, different control flow — the agent's behavior changes while nothing else moves. Swap the sandbox: same agent, different blast radius. Each swap is a configuration change, not a rebuild, and each one tests the claim independently. If any layer resists swapping without touching the core, that layer is where the privilege actually lives. The experiment is hypothetical — this article reports the architecture, it does not test it — but it converts a slogan into a checklist you can run the day you install dsh.

Four Runtime Modes

Harness ships with four modes (independently described here), each loading a different default plugin set:

Standard is the full coding agent — file editing, shell, file and web search, skills, planning, goals, subagents, and workflows. This is what most people will start with.

Code Mode exposes the same tools through a Code Mode SDK, letting the model combine multi-step operations in a single TypeScript program rather than going turn-by-turn.

Minimal strips everything down to two tools — persistent bash and str_replace_editor — for benchmarking models in a bare environment.

Creator Mode adds runtime inspection, in-memory plugin experiments, and preset-authoring guidance for people building their own plugin ecosystem.

Every Run Is Traceable

One of Harness's sharper claims is its session log. Everything the model sees is written to an append-only log: system prompts, reasoning, tool calls and results, subagent scheduling, and every context injection — resumable, forkable, searchable, and replayable. The Trajectory view lets you inspect those records by source.

Resume, fork, search, and replay all operate on the same event stream. Most agent frameworks log tool calls. Recording every context injection — including the prompts and reasoning the model processed — is the kind of observability that debugging agent behavior actually requires.

What the Session Log Buys You

Map the four verbs to debugging questions. Resume answers "can I continue yesterday's run without replaying the cost?" Fork answers "can I try a different strategy from step 40 without losing the first 39?" Search answers "where did the model first see the poisoned output?" Replay answers "does the same trajectory reproduce the failure?" Those map directly onto the recorded event types — prompts, reasoning, tool calls, injections. An append-only log is not a feature; it is the precondition for every postmortem an agent team will ever run.

Getting Started

The fastest path:

# Via npx (requires Node.js 22+)
npx @deepseek-ai/dsh web

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

The Web UI starts at http://127.0.0.1:3080. Source builds require Node.js 22+, per the repo's engines field. A Python SDK is also available.

It's a Preview, Not a Product

The critical caveat: v0.1 is a developer preview. DeepSeek explicitly warns of compatibility-breaking changes ahead. The plugin APIs and contracts will iterate. This is infrastructure for teams that want to experiment with composable agent architecture, not a production-ready Claude Code replacement.

That said, the architecture is genuine. The multi-layer plugin system and provider-agnostic inference layer are real technical differentiators. The strategic logic is sound: DeepSeek released it under MIT and is actively courting plugin developers to build on the platform.

If you've been evaluating agent frameworks and hitting walls with monolithic architectures, Harness is worth a serious look. Just remember it's early, pin your versions, and be prepared for breaking changes. The vision is solid — the stability isn't there yet.

Related

• When AI Agents Start a Turf War — What happens when multiple Claude agents fight over the same codebase.
• Needle 2: A 14MB Model That Calls Tools on Any Device — Edge-native tool calling that runs entirely offline.

Sources

• DeepSeek: deepseek-ai/deepseek-harness (GitHub)
• DeepSeek: deepseek-harness package.json (engines)
• DeepSeek: deepseek-harness architecture documentation
• DataNorth: DeepSeek releases V4-Pro-0813 and open sources Harness v0.1
• OpenLLMStack: DeepSeek-V4-Pro-0813: specs, benchmarks and pricing