DeepSeek Harness Opens the Agent Framework It Used to Benchmark Its Own Models

DeepSeek Harness (dsh) just dropped into public developer preview, and it's fully open-source under the MIT license. This is the same framework DeepSeek used internally to run its own coding-agent benchmarks for DeepSeek-V4-Flash, and now anyone can build on top of it. The core philosophy is simple but radical: everything is a plugin.

What problem does this solve?

Building a production-ready AI agent today means stitching together a model, a tool-calling loop, memory, sandboxes, file systems, and a UI, and then hardcoding the seams between them. Swap your model provider, and you're rewriting glue code. Add a new tool, and you're patching the orchestration layer. DeepSeek Harness is designed to eliminate that problem entirely by treating every one of those components as an interchangeable plugin.

A harness lets an agent understand its environment, use tools, and keep working in real-world settings. The framing here is deliberate: the team's mission is explicit: Model + Harness = Agent. Everything except the model itself, including tooling, memory, agent loop, desktop integration, and feedback systems, belongs to the Harness.

The Cordis kernel: the engine underneath

DeepSeek Harness is an open-source agent harness developed by DeepSeek AI. It uses an architecture where everything is a plugin, and is powered by Cordis, whose design is described in A Programming Paradigm for Spatiotemporal Composability.

Cordis is a TypeScript meta-framework built around the idea that software components should be composable both in space (which plugins are active) and in time (when they are mounted or unmounted). Think of it like a dependency-injection container, but one where plugins can be hot-swapped at runtime without restarting the process. The Cordis kernel manages plugin mounting, unmounting, and dependencies. Agent capabilities live in the plugins.

Plugins provide every agent capability, including models, tools, skills, sessions, sandboxes, storage, loops, scheduling, and the UI. Cordis services and events let the plugins work together. Developers can select, swap, or extend any capability in configuration without changing the DeepSeek Harness source code.

Four runtime modes out of the box

DeepSeek Harness ships with four pre-built operating modes, each targeting a different use case:

• Standard mode: Full coding agent with file editing, shell, file and web search, skills, planning, goals, subagents, and workflows.
• Code mode: Uses model-generated code to orchestrate multiple rounds of tool calls. The model writes TypeScript programs that compose multi-step tool operations in a single pass.
• Minimal mode: Keeps only a shell tool and a file editor for benchmarking models in a minimal environment. This is the mode DeepSeek used for its own V4-Flash benchmark runs.
• Creator mode: Lets you inspect the current runtime, test Cordis plugins in memory, and combine them into new modes. This is where you author your own custom agent presets.

Full traceability, built in

One of the more underrated features is the trajectory system. Everything the model sees is recorded in an append-only session log: system prompts, reasoning traces, tool calls and results, subagent scheduling, and every context injection. You can inspect, resume, fork, search, and replay sessions, all operating on the same event stream. For anyone debugging a multi-step agent that silently went off the rails three tool calls ago, this is a big deal.

Model-agnostic by design

Despite being built by DeepSeek, the harness is not locked to DeepSeek models. The provider configuration supports Anthropic, OpenAI, Bedrock, Vertex, Azure, and any OpenAI-compatible endpoint. You point it at a base URL, give it an API key, and it works. The model picker in the Web UI lets you switch models between sessions without restarting the server.

Getting started in under a minute

The fastest path is a single npx command. Install Node.js, then run:

npx @deepseek-ai/dsh web

The command starts the Web UI, served at http://127.0.0.1:3080 by default. From there, open Settings, add your API key, pick a workspace directory, and send your first task. If you want to build plugins or inspect the internals, clone from source:

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

There is also a Python SDK for programmatic access, documented alongside the main developer docs.

A community ecosystem is already forming

Even before the official release, a community plugin ecosystem had started to emerge. Plugins already exist for persistent memory with knowledge graphs, SQLite-backed storage, and local-first agent memory. There is also a local-first AI workbench for DSH plugins, combining agent sessions, project files, data analysis, web research, MCP, and Office artifacts in an Electron desktop app. You can discover community plugins by browsing the dsh-plugin topic on GitHub.

What to watch for

DeepSeek Harness is currently in developer preview and is iterating rapidly. There will be compatibility-breaking changes. This is not a stable production dependency yet. The plugin APIs will shift, and anything you build on top of it today should be treated as experimental. That said, the MIT license and the open plugin ecosystem mean the community can move fast alongside DeepSeek's own iteration.

The deeper story here is that this is not just a wrapper, it's a co-design effort where the harness and the model evolve together. The model and the harness evolve together, and official benchmark scores are a measure of the pair, not the model alone. That means the harness is a first-class product at DeepSeek, not an afterthought, and the benchmark numbers you see for future DeepSeek models will be produced with this exact framework.