How DeepSeek's new open-source harness turns any model into a coding agent

A brand-new open-source project going from zero to over 165,000 GitHub stars in under a week is the kind of number that usually belongs to a viral meme repo, not a piece of developer infrastructure. But that's exactly what happened with DeepSeek's new coding agent harness — and once you understand what it actually does, the hype starts to make a lot more sense.

This isn't another chatbot wrapper or a Claude Code clone with a different logo slapped on it. It's a fundamentally different way of thinking about what a "coding agent" even is. And if you build software with AI tools, it's worth understanding — even if you never switch away from your current setup.

What is DeepSeek Harness, exactly?

DeepSeek Harness (dsh) is an open-source agent harness developed by DeepSeek AI that uses an architecture where everything is a plugin, and is powered by Cordis. You can check out the official DeepSeek Harness repository on GitHub or read the developer preview overview directly from DeepSeek.

Think of it this way: a language model is just the brain. A harness is the body — it's what lets that brain actually read your files, run shell commands, search the web, edit code, and remember what it did five steps ago. A code harness is the product and runtime layer around a model — it decides how the model sees a repository, chooses tools, plans work, runs commands, remembers state, handles failures, and turns real task traces into product and model improvements.

What makes DeepSeek's version different from Claude Code, Codex, or Cursor is the "everything is a plugin" philosophy. DeepSeek open sourced its agent harness under MIT, an extensible runtime where the model adapter, tool registry and agent loop are all swappable plugins. There's no locked-down core you can't touch. The model adapter, the tool registry, the session log, and the agent loop itself are all plugins — and each one is replaceable.

And crucially, none of this ties you to DeepSeek's own models. It's worth stressing that nothing in the harness ties it to DeepSeek's models. The harness works with Anthropic, OpenAI, AWS Bedrock, Microsoft Azure, and Google. You could run it entirely on Claude, GPT, or even a local model through Ollama if you wanted zero API costs beyond your own hardware.

Why does the plugin-first design actually matter?

Most coding agents blur two things together: the reasoning model and the product built around it. That coupling is exactly what DeepSeek is trying to break apart. DeepSeek Harness is built on Cordis's plugin system, where plugins provide every agent capability, including models, tools, skills, sessions, sandboxes, storage, loops, scheduling, and the UI, with Cordis services and events letting the plugins work together.

That matters for a few practical reasons:

You can swap out any layer without forking the whole project. Don't like the default tool registry? Replace it. Want a different session logging format? Plug in your own.

Nothing is hidden. The conversation history is not just an implementation detail — core features like resume, fork, replay, transcripts, telemetry, and the web UI are all based on this single event stream, so adding any new kind of model-visible input means adding a new session event. That means you can actually trace why the agent did something, down to which plugin injected which piece of context.

Security isn't an afterthought. The agent sandboxing is strict, with the local backend wrapping subprocesses in Linux Landlock through a Node addon DeepSeek wrote, macOS Seatbelt, or a Windows ACL restricted-token runner.

There's already an academic backbone to the design too. A recent paper by three researchers from Peking University and DeepSeek explains this in more detail and forms the basis of Cordis and the DeepSeek Harness.

What modes does the harness ship with?

Rather than one rigid experience, DeepSeek ships four distinct presets, and picking the right one changes how the agent behaves entirely.

• Standard mode — gives developers the full coding agent, with filesystem tools, shell access, web search capability, subagents, and a plan mode. This is the one most people will reach for day-to-day.
• Code mode — changes how tools reach the model. Rather than exposing those tools as individual function calls, it generates a TypeScript SDK and lets the model write a program against it, so a sequence that would otherwise take five round trips runs as a single call. If you've ever watched an agent burn through a dozen tool calls just to rename a variable and update three imports, you'll understand why this is a big deal for speed and cost.
• Minimal mode — strips this down to only two tools, bash and str_replace_editor. This is intentionally bare-bones. Use this for model benchmarking or ablation studies where extra tools would confound results — minimal mode is not "worse Standard," it is a controlled environment.
• Creator mode — meant for developers who want to create custom agent presets, it inherits all of the features of the Standard mode and adds runtime inspection, plugin experiments, and preset-authoring guidance.

Creator mode is where things get genuinely fun — it's the mode that lets the agent help build its own extensions, which is the same self-improving loop that made tools like Pi popular earlier this year.

Can you call Claude Code or Codex as subagents?

This is the feature that turns DeepSeek Harness from "another coding CLI" into something more like an orchestration layer. Because the model adapter is just a plugin and Standard mode ships with subagent support baked in, you're not locked into using DeepSeek's own models to do the actual coding work. This is a deliberate contrast with Claude Code and Codex, which are optimised for their vendors' models — the harness software runs locally and is fully open source, and can be pointed at local model servers such as Ollama or any OpenAI-compatible endpoint on your network.

The community has run with this idea fast. A growing ecosystem of compatibility plugins already exists that let the harness interoperate directly with other coding agents — turning your coding agent into a broader design engine that generates prototypes, landing pages, dashboards, slides, images and video, working across Claude Code, Codex, Cursor, DeepSeek Harness, OpenCode and 20+ CLIs via bring-your-own-key setups. In practice, this means you can use the harness as your orchestrator — the thing that plans, delegates, and checks work — while still calling out to Claude Code or Codex to actually execute a task where they might perform better.

How do you install and run DeepSeek Harness?

Getting it running locally is refreshingly simple. Head over to the official GitHub repository for the source and the latest setup notes, or check the Developer docs for a guided walkthrough.

Quick start (via npm):

1. Install Node.js if you don't already have it.
2. Run npx @deepseek-ai/dsh web. The command starts the Web UI at http://127.0.0.1:3080 by default and opens it in the default browser for a local launch.
3. If you're on an SSH launch, it'll only print the host URL since the SSH client or editor owns the local forwarded address — pass --no-open to run the server without opening a browser.

Building from source (for more control):

Clone the repo with git clone https://github.com/deepseek-ai/deepseek-harness.git, then cd deepseek-harness, run pnpm install, pnpm run build, and finally pnpm dsh web.

Once it's running, you pick a project folder, choose your mode, and the agent gets to work — editing files, running commands, and asking for approval before anything destructive.

How do you build your own plugin?

This is where the "everything is a plugin" pitch really pays off. Since tools, skills, session handling, and even the model adapter are all just plugins registered through Cordis, you don't need to fork the entire codebase to add a capability — you write a plugin and mount it. There's already a code-audited, progressive guide to building production-grade DeepSeek Harness plugins floating around the community, and the curated plugin directory is a good place to see real examples before writing your own.

A simple starting plugin idea: something that watches for file edits and automatically runs a linter or type-checker in the background. That pattern already exists in the wild — community plugins already handle things like auto type-check and lint diagnostics, where after the model edits code, tsc runs in the background and a code_check tool reports what broke. Studying how plugins like that are structured is the fastest way to learn the pattern before building something custom.

If you want the more official route, DeepSeek links out to a full plugin ecosystem directly from their site — View on GitHub, Developer docs, Community plugins, and the Cordis paper are all linked from the official harness page.

Should this replace Claude Code as your daily driver?

Honestly? Not yet, and DeepSeek isn't pretending otherwise. DeepSeek Harness is currently in developer preview and is iterating rapidly — there will be compatibility-breaking changes. That's a real warning, not boilerplate. Expect rough edges, breaking updates, and documentation that lags behind the code for a while.

But the design is the interesting part, not the current polish. A tool that treats the model, the tools, the sandbox, and even the UI as interchangeable pieces is a fundamentally more flexible foundation than a sealed product like Claude Code or Codex — even if those tools currently offer a smoother out-of-the-box experience. If you're the kind of developer who likes tinkering with your workflow, swapping models mid-project, or building custom tooling around your agent, this is worth setting up on a side project this weekend.

If you'd rather wait for the rough edges to smooth out, that's a completely reasonable call too. Just don't be surprised when this ecosystem looks very different — and probably a lot more mature — in another few months.