DeepSeek just threw that rule out the window.
On August 13, 2026, they open-sourced their agent harness under MIT license. And the architecture is so extreme it almost sounds reckless at first. Everything is a plugin. Not just tools.Yet just model adapters. Everything. The agent loop, session storage, the scheduler, even the web UI. All swappable.Yet hot-reloadable. While the system runs.
This isn't another framework trying to do what Claude Code does but open source. It's asking a completely different question about how we build systems that need to keep running while their own internals get replaced.
What You Need to Know
DeepSeek Harness uses a plugin-first architecture where literally every component is swappable. Models, tools, sessions, sandboxes, storage, loops, UI. Everything.
It's built on Cordis, a meta-framework that implements something called "spatiotemporal composability." Sounds academic but it's what lets components load and unload safely at runtime without leaking memory or corrupting state.
Four runtime modes ship out of the box. Standard gives you the full toolset. Code mode lets the model write orchestration code directly. Minimal strips everything down for benchmarking. Creator mode is your plugin development environment.
Complete traceability through append-only session logs. Every prompt, every reasoning step, every tool call, every piece of context the model sees, recorded. You can resume sessions, fork them, replay them with different configurations.
It launched alongside DeepSeek-V4-Flash for a reason. Agent loops burn through tokens like crazy. 500K+ per task isn't unusual. You can't run that economics on premium models. The pairing matters.
Open source, MIT licensed. Install via npx @deepseek-ai/dsh web or clone from GitHub. But it's developer preview status. Breaking changes are coming.
The competitive angle is unit economics. Not raw capability. Reports suggest 30-100x cheaper per task than Claude Code or Codex. Same success rates, fraction of the cost.
What Actually Is an Agent Harness?
Let's get the terminology straight because the AI industry has settled on a clean mental model here.
Agent = Model + Harness
The model, DeepSeek-V4, Claude Opus, whatever. Is the brain. The weights that predict tokens and generate reasoning.Plus harness is everything else. Tool definitions. Filesystem access. Shell execution. Memory management. Sub-agent orchestration. Loop control. And critically, deciding when to stop.
The model generates the plan.Plus harness decides what tools to give it and when execution ends.
Think of it this way. Claude can generate brilliant code suggestions but it can't actually write files, run tests, commit to git, or manage a multi-step debugging session. That's the harness layer.
And as frontier models converge in raw capability, differentiation increasingly happens here. In the infrastructure surrounding the model. DeepSeek historically shipped models. Building a harness signals their shift from pure model vendor to product company, the same move Anthropic made with Claude Code and OpenAI made with Codex.
The Plugin Philosophy Goes All In
Here's where it gets interesting.
Most frameworks have a plugin system. You can add custom tools, write adapters for different model providers. Pretty standard stuff. But there's always a core. The agent loop, session management, the orchestration layer. That's baked into the framework itself. Those pieces are framework code.
DeepSeek said no to boundary entirely.
In their architecture the agent loop is a plugin. The model adapter is a plugin.Still tool registry is a plugin. Session storage is a plugin. The web interface is a plugin. Sandboxes, schedulers, skills, all plugins.
You can mount, replace, or extend any part of the system through configuration alone. No touching DeepSeek Harness source code. As one developer noted on Hacker News: "It's not that it has a plugin system. It's that it only has a plugin system."
This is either brilliantly modular or maddeningly bare-bones depending on what you're trying to do. There are no "batteries included" in the traditional sense. The entire system composes from plugins.
Why Would You Want This?
The practical benefit shows up when you need to swap model providers without rewriting integration code. Test different agent loop strategies, ReAct vs Plan-and-Execute vs code-first. Replace storage backends from local files to database to cloud. Run multiple agent configurations in parallel with different tool sets. Hot-reload components during development without restarting everything.
Build specialized harnesses by composing only the plugins you need.
Most importantly? You can do all of this while the system is running. Plugins load and unload dynamically. That's the real innovation here.
Cordis: The Engine Making This Possible
The reason DeepSeek Harness can pull off this extreme modularity is Cordis. A meta-framework built on research called "A Programming Paradigm for Spatiotemporal Composability."
That academic title hides something genuinely useful. Cordis solves two hard problems most frameworks just... Don't solve.
Temporal Composability: Can Components Actually Leave?
Imagine you load a plugin that registers an event listener.
events.onLater you unload the plugin. What happens to listener?
In most systems? Nothing. The plugin is "gone" but its listener is still firing. Memory leaks everywhere. State corruption waiting to happen. You've seen this. We've all seen this.
Cordis models this as revertible effects. Every modification carries its cleanup.
ctx.effect => {
registerTool
return () => {
unregisterTool
}
})When the plugin unloads, Cordis runs those cleanup functions in reverse order. LIFO stack. If your plugin opened a database, started a service using that database, then started an agent using that service, the shutdowns happen backwards. Stop agent, stop service, close database.
You don't manage this manually. The framework tracks it.
Spatial Composability: What Does This Component Need?
Traditional code often accesses globals.
global.llm
global.tools
global.sessionsBut then the system doesn't know about those dependencies. Cordis makes dependencies explicit through a context system. Plugins declare what services they need and Cordis resolves them at runtime.
When a dependency disappears—say the Git plugin gets unloaded—everything depending on it stops cleanly.Yet a replacement appears, dependent plugins can restart automatically.
This is what lets you hot-swap components while agents are running. Not as a parlor trick. As a fundamental capability.
Four Runtime Modes Out of the Box
DeepSeek Harness ships with four pre-configured plugin bundles.
Standard Mode is the full coding agent. Filesystem tools, shell access, web search, subagent spawning, Plan mode for complex tasks. Your general-purpose configuration.
Code Mode uses model-generated code to orchestrate multiple rounds of tool calls. Instead of the harness controlling the loop, the model writes Python or JavaScript that calls tools directly. Good for tasks that need complex branching logic.
Minimal Mode strips everything down to just a shell tool and file editor. Designed for benchmarking models in a controlled environment without the harness influencing behavior.
Creator Mode lets you inspect the current runtime, test Cordis plugins in memory, and compose them into new modes. Your plugin development environment.
You launch modes with:
npx @deepseek-ai/dsh webThen select your mode in the UI or pass it via config. Simple.
Complete Traceability: Every Run Gets Recorded
One feature sets DeepSeek Harness apart—everything the model sees gets recorded in an append-only session log.
Not just the final result. Everything. System prompts sent to the model. The model's reasoning traces. Tool calls and their results. Subagent scheduling decisions. Every context injection. Error states and retries.
The Trajectory view in the web UI lets you inspect these records by source. You can resume a session from any point. Fork a session to try different approaches. Search through historical runs. Replay sessions with different models or tools.
This is huge for debugging. When an agent does something unexpected you can see exactly what context it had at each decision point. No more black-box failures where you're just guessing what went wrong.
For researchers it's a gold mine. You can trace how different prompting strategies or tool access patterns affect outcomes. Actually study agent behavior instead of just measuring final results.
Installation and Setup
Getting started is surprisingly straightforward.
Quick Start
npx @deepseek-ai/dsh webThis launches the web UI at http://127.And.And.1:3080. On first run you'll need to provide a DeepSeek API key and select a workspace folder.
Install from Source
git clone https://github.com/deepseek-ai/deepseek-harness.git
cd deepseek-harness
pnpm install
pnpm run build
pnpm dsh webRequirements are Node.js v22 or higher—use nvm to install if you need it—and a DeepSeek API key from platform.deepseek.com.
The harness supports any OpenAI-compatible API endpoint so you can point it at local models, OpenRouter, or other providers. Not locked into DeepSeek's infrastructure.
The Economics: Why Pair a Harness with a Cheap Model?
DeepSeek Harness launched alongside DeepSeek-V4-Flash. A 284B parameter sparse mixture-of-experts model with only 13B active parameters per forward pass. Pricing sits around $And.14/$And.28 per million tokens for input/output. Cache hits cost $And.0028/M.
Why does this pairing matter?
Because agent loops are absurdly token-hungry. A single coding task can burn through 500K+ tokens. You cannot run that economics on a $30/million output flagship model. The math doesn't work. You'll go broke running at scale.
In one benchmark comparison Claude Code cost $And.195 per successful task with a 53.3% pass rate. DeepAgents cost $And.045 per successful task with the same 53.3% pass rate.
Same success rate. 4x cheaper.
The competitive positioning is clear. Claude Code wins on reasoning depth and output quality. Codex wins on ecosystem integration and speed. DeepSeek Harness + V4-Flash wins on unit economics.
If you're running agents at scale—hundreds or thousands of tasks per day—cost per task becomes the dominant factor. That's the wedge DeepSeek is attacking. Not "we're smarter than Claude" but "we're 4x cheaper and good enough."
How DeepSeek Harness Compares to Alternatives
vs Claude Code
Claude Code has the deepest reasoning and most reliable tool execution. Its harness is polished and production-ready. But you're locked into Anthropic's ecosystem and paying premium pricing. You can't swap the model, can't extend the core loop, can't run it locally.
DeepSeek Harness gives you full control and runs anywhere. But it's in developer preview. Expect breaking changes.
vs Codex (OpenAI)
Codex has fast execution, OAuth integration, and the full OpenAI ecosystem behind it. Similar tradeoffs—proprietary, closed harness, premium pricing.
vs LangGraph / LangChain
These are graph-based frameworks where you define nodes and edges. Powerful for complex workflows but heavyweight. You're building flow diagrams, not composing plugins.
DeepSeek's approach is more Unix-philosophy. Small, composable pieces do one thing well.
vs AutoGPT / BabyAGI
Early autonomous agents with hard-coded loops and limited extensibility. DeepSeek Harness is a generation ahead in architecture. Everything those tools did is now a swappable plugin.
Real-World Use Cases
Where does this architecture actually shine?
Multi-Model Experimentation. You're testing which model works best for your use case. With DeepSeek Harness you swap the model plugin and re-run the same task with identical tooling and prompts. Apples-to-apples comparison.
Cost Optimization at Scale. You're running hundreds of agent tasks daily. Start with V4-Flash for cheap execution. When a task fails or needs deeper reasoning, swap to V4-Pro or Claude for that specific run. Route intelligently based on task complexity.
Custom Agent Workflows. You need an agent that searches internal docs, writes code, tests it, and opens a PR. Build custom plugins for your doc search and PR system. Compose them with standard filesystem and shell plugins. No framework forking required.
Research and Benchmarking. You're studying agent behavior. The append-only logs and replay system let you trace exact decision paths. Fork sessions to test "what if the agent had this tool instead?" scenarios.
Plugin Development: Building Your Own
The plugin API is TypeScript-based and relatively clean. Here's a minimal example.
export const name = "my-custom-tool"
export function apply(ctx) {
ctx.command("my-tool <arg>")
.action(async ({ session }, arg) => {
// Your tool logic here
return `Processed: ${arg}`
})
}Plugins can register commands and tools. Subscribe to events. Provide services to other plugins. Declare dependencies on other plugins. Define revertible effects for cleanup.
The official plugin documentation walks through the Context API, service injection, and event system.
One early developer noted: "The learning curve is real if you're used to traditional frameworks. But once you grok the Cordis model, building plugins is surprisingly fast."
Current Limitations and Gotchas
DeepSeek is explicit about this being a developer preview. Compatibility-breaking changes are coming. Here's what you should know.
Not production-ready yet. The core APIs are still evolving. If you build plugins today expect to rewrite parts of them in future releases.
Bare-bones by design. There's no massive plugin marketplace yet. No pre-built integrations with every SaaS tool. You're composing from a smaller set of primitives.
Documentation is sparse. The official docs cover the basics but community guides and examples are still emerging. You'll be reading source code to understand advanced patterns.
Node.js only. The harness runs on Node.js. If your workflow is Python-heavy, integration requires running a separate process or using language bridges.
Learning curve for Cordis. Understanding the effect/coeffect model takes time. If you just want to add a simple tool the conceptual overhead feels heavy.
The Broader Picture: Why This Matters
DeepSeek Harness represents a bet on a specific future for AI agents.
The bet is this. As models commoditize, differentiation moves to the infrastructure layer. And infrastructure needs to be modular, composable, and runtime-flexible. Not monolithic.
Most agent frameworks today are monoliths. They might have a plugin system but the core orchestration is baked in. You're choosing a framework and living with its opinions about how agents should work.
DeepSeek is asking—what if there was no core? What if the orchestration layer itself was just another plugin you could replace?
It's a radically different answer to the same problem. Whether it's the right answer depends on your use case.
If you need something stable and batteries-included today, Claude Code or Codex are safer bets.Plus you're building custom agent infrastructure, care deeply about cost at scale, or want to experiment with novel agent architectures? DeepSeek Harness is worth serious attention.
Getting Started: Your Next Steps
Ready to try it out? Here's what I'd recommend.
Run the quick start with npx @deepseek-ai/dsh web and explore Standard mode with a simple task. Read the Cordis paper because understanding spatiotemporal composability will make everything click. Inspect a session log to see what traceability actually looks like in practice. Build a simple plugin—start with something trivial like a custom greeting command to learn the API. Join the GitHub discussions where architecture questions get answered.
And remember this is early. The plugin ecosystem will grow.And APIs will stabilize. But the core architectural idea—everything as a plugin—is unlikely to change. That's the foundation.
Wrapping Up
DeepSeek Harness tackles agent infrastructure from a completely different angle. By making everything a plugin—including the components most frameworks treat as core—it enables a level of composability and runtime flexibility that's genuinely novel.
Is it the right choice for everyone? No. Production users should wait for API stability. Teams wanting batteries-included should look elsewhere.
But for developers building custom agent systems, researchers studying agent behavior, or anyone who needs agents to run economically at scale? This architecture offers something most alternatives don't. Complete control over every layer of the stack.
The "everything is a plugin" philosophy isn't just marketing. It's a fundamental architectural constraint that forces different tradeoffs. Whether those tradeoffs work for your use case is something you'll need to test yourself.
The harness is open source, MIT licensed, and ready to run. Give it a try. Then come back and tell me what you think.
Sources
- DeepSeek Official - DeepSeek Harness Developer Preview. Https.//deepseek.com/harness/en/
- The New Stack - DeepSeek open sources an agent harness where everything is a plugin. Https.//thenewstack.io/deepseek-harness-open-source-plugins/
- Medium (Data Science in Your Pocket) - What is DeepSeek Harness?. Https.//medium.com/data-science-in-your-pocket/what-is-deepseek-harness-4199d11a1235
- Medium (Dinmay Brahma) - DeepSeek Quietly Built a Different Kind of AI Agent Framework. Https.//medium.com/@dinmaybrahma/deepseek-quietly-built-a-different-kind-of-ai-agent-framework-80e4775103f9
- GitHub - deepseek-ai/deepseek-harness. Https.//github.com/deepseek-ai/deepseek-harness
- GitHub - Cordiverse Paper (Spatiotemporal Composability). Https.//github.com/cordiverse/paper
- VentureBeat - DeepSeek Harness launches as open source rival to Claude Code. Https.//venturebeat.com/technology/deepseek-harness-launches-as-open-source-rival-to-claude-code-alongside-v4-pro-on-api-with-higher-prices
- Reddit r/LocalLLaMA - Deepseek Harness is Up Discussion. Https.//www.reddit.com/r/LocalLLaMA/comments/1vnb66j/deepseek_harness_is_up/
- GitHub - Cordis Meta-Framework: https://github.com/cordiverse/cordis