DeepSeek Harness just open-sourced a different way to build AI agents. Instead of one fixed coding assistant, DeepSeek released the scaffolding underneath it.
Every piece is swappable. The model, tools, sandbox, session store, and agent loop all exist as plugins.
These plugins mount into a shared runtime called Cordis. As a result, developers can reconfigure an agent without touching its source code.
Image Source: DeepSeek Harness plugin
The Challenge with Fixed Agent Frameworks
Most coding agents bundle tools, memory, planning, and sub-agent logic into one rigid shell. Consequently, changing one piece often breaks another.
For instance, swapping the model provider means editing core logic. Changing the sandboxing strategy causes the same problem.
Overall, this tight coupling makes agents hard to extend. It also makes safe experimentation difficult.
DeepSeek Harness takes the opposite approach. Its kernel, Cordis, contains no agent capabilities at all.
Instead, Cordis only handles plugin registration, dependency resolution, and lifecycle management. Every real capability lives in a plugin, from file editing to the UI.
Therefore, replacing the model backend doesn’t touch the planning plugin. Likewise, swapping the tool plugin doesn’t affect the UI.
Four Runtime Modes for Four Different Jobs
Rather than forcing one setup on every use case, DeepSeek Harness ships four preset runtime modes. Switching between them is a configuration choice, not a reinstall.
| Mode | What it loads | Best for |
|---|---|---|
| Standard | Full toolset — file editing, shell access, web search, skills, planning, goals, subagents, and workflows | General-purpose coding agents |
| Code (PTC) | Standard mode, exposed through a TypeScript SDK so the model writes one program instead of many tool calls | Complex, multi-step tool workflows |
| Minimal | Just a shell tool and a file editor | Benchmarking models in a lean environment |
| Creator | Standard mode plus runtime inspection, in-memory plugin experiments, and preset authoring | Building and testing new plugin combinations |
Code mode solves a real, recurring problem. Normally, checking fifty files for a TODO comment takes fifty round-trips.
In Code mode, however, the model writes one short TypeScript program. That program loops through the files itself.
Only the final result goes back to the model. Consequently, fifty round-trips collapse into one execution.
Creator mode, meanwhile, turns the harness into its own development environment. It exposes runtime inspection and live plugin authoring.
As a result, a developer can ask the agent to build a new plugin. For instance, it could create a small game window in the UI corner.
The agent then inspects the environment and writes the code. Finally, it packages the plugin and mounts it into the running session.
Full Traceability Through the Trajectory View in DeepSeek Harness
Debugging an agent from raw console output is painful. To address this, DeepSeek Harness uses an append-only session log.
A simple runtime rule enforces it: whatever the model sees gets logged. For example, that includes system prompts, chain-of-thought, tool calls, and context injections.
This log powers the Trajectory view. It lets developers inspect exactly how a run unfolded, step by step.
Beyond viewing, trajectories can be:
- Resumed — pick a run back up where it left off
- Forked — branch a run at any point to try a different path
- Searched — find specific steps or patterns across past runs
- Replayed — walk through an episode exactly as it happened
Together, these features turn debugging from guesswork into direct inspection.
Deep Customization, Down to the Runtime Itself inside DeepSeek Harness
Capabilities compose through configuration, not code changes. Therefore, developers can replace or extend nearly anything without patching the framework.
The repository backs this up structurally. Dozens of standalone plugin packages cover sessions, sandboxing, MCP support, and the LLM layer.
Others cover planning, scheduling, skills, subagents, terminal access, and workflows. Each one stays independently swappable.
Subagents, in particular, aren’t locked to DeepSeek’s own models. Instead, the harness can delegate a subtask to another vendor’s agent.
In that case, it acts purely as the orchestration layer. Furthermore, a set of cordis_* tools lets the agent write and mount new plugins at runtime.
In other words, agents could extend their own capabilities on the fly.
Open-Source Plugins, Python SDK, and a Web UI
DeepSeek released the whole project under the MIT license. It includes roughly 500,000 lines of TypeScript plus a small C core.
The ecosystem is already sizable. For instance, the project drew over 200,000 GitHub stars within its first weeks.
Tens of thousands of forks followed. Meanwhile, community plugins keep growing.
Python developers get a dedicated Python SDK alongside the TypeScript core. Getting started doesn’t even require the CLI:
bash
npx @deepseek-ai/dsh web
That command launches the Web UI locally. Model configuration and runtime-mode selection sit right in the interface.
As a result, switching between Standard, Code, Minimal, and Creator modes needs no config files. Pointing the harness at another model provider works the same way.
Real Sandboxing, Not a Simulation
Running an agent that edits files and runs shell commands carries real risk. So, DeepSeek Harness uses actual OS-level isolation, not a simulation.
On Linux, that means bwrap and Landlock. While On macOS, it uses Seatbelt. On Windows, restricted ACL tokens do the job.
Notably, the design fails closed. If sandboxing can’t be established, the harness won’t run unrestricted.
That said, DeepSeek Harness is explicitly a developer preview. The README states plainly that breaking changes are coming.
Furthermore, the project hasn’t yet had a full security audit. For production coding work today, more mature agents remain safer.
However, for teams building agent infrastructure, it offers something rarer. It’s a working, open reference for a fully plugin-based design.
Broader Implications of DeepSeek Harness
The everything-is-a-plugin design points toward a few larger shifts:
- Agent infrastructure separate from the model. Decoupling the harness and model makes swapping either one easier.
- Observability as a first-class feature. Append-only logs and trajectory views raise the bar for debuggable agents.
- Self-extending agents. Runtime plugin authoring hints at agents that adapt their own toolset.
Conclusion
DeepSeek Harness reframes the agent-framework question. Instead of asking which fixed toolset to ship, it asks what happens when nearly nothing is fixed.
It’s built on Cordis’s plugin architecture. On top of that, it offers four runtime modes and full trajectory tracing.
It also ships with Python SDK and Web UI support. Ultimately, that gives developers a composable foundation, even while the project remains a work in progress.
Ready to bring intelligent AI capabilities closer to your users? Your journey starts at Webkul.
Be the first to comment.