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, and within days it accumulated over 149,000 stars. The tagline is direct: Agent = Model + Harness. And the organizing principle is even more direct: everything is a plugin.

That's not marketing copy. Models, tools, skills, sessions, sandboxes, storage, the agent loop itself, scheduling, 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. 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 eight layers:

• Models — inference providers (DeepSeek, Anthropic, OpenAI, Bedrock, Vertex, Azure, OpenAI-compatible endpoints)
• 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
• Storage — persistence layer
• Loops — agent control flow
• Scheduling — task orchestration

Model routing is also a plugin. In Settings, you add a DeepSeek API key and it takes effect on the next request — no restart needed. The installed catalog supports Anthropic and OpenAI via API key, plus Bedrock (AWS credentials), Vertex (ADC project), Azure (api-version), and Codex (OAuth). Custom providers accept any OpenAI-compatible base URL.

Four Runtime Modes

Harness ships with four modes, 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. 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.

Getting Started

The fastest path:

# Via npx (requires Node.js 10+)
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. A Python SDK (deepseek-harness-sdk) is also available and needs Python 3.10+. The bundled runtime requires no system Node.js.

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 eight-layer plugin system and provider-agnostic inference layer are real technical differentiators. The strategic logic is sound: DeepSeek hired a dedicated harness lead months before shipping, 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.