DeepSeek Harness Explained: An Agent Runtime Where Everything Is a Plugin

Why DeepSeek Harness Went Viral Immediately After Launch

As Agent tools like OpenClaw, Hermes Agent, and Codex gradually matured and stabilized in functionality, developers quietly shifted their expectations toward a higher goal—autonomous loop Agents. An Autonomous Loop Agent refers to an AI system that can independently plan tasks, execute operations, evaluate results, and iteratively improve based on feedback without continuous human intervention. Unlike traditional single-turn conversations or simple command execution, these Agents possess the ability to run continuously, breaking down complex objectives into sub-tasks that they complete step by step with self-correction. This concept emerged from the success of the ReAct (Reasoning + Acting) paradigm—enabling large language models to call external tools while reasoning, forming a closed loop of "think-act-observe." Put simply, what many people truly want is for AI to handle all the work while they just review the results. Although we're still some distance from this ideal, autonomous loop Agents have given people real hope.

It was at precisely this moment that DeepSeek launched DSH (DeepSeek Harness), which went viral immediately upon release. According to Bilibili creator "大叔大," its core philosophy can be summarized in one sentence: Everything is a plugin. Expressed as a formula: Agent = Model + Harness. All Agent capabilities—model, tools, skills, conversations, sandbox, storage, loops, scheduling, and UI—are composed entirely of plugins.

DeepSeek Harness is currently in developer preview, released under the MIT open-source license, with all capabilities freely replaceable and recombinable. It's worth noting that the MIT license is one of the most permissive open-source licenses available, allowing anyone to freely use, modify, distribute, and even commercialize the software—the only requirement being to retain the original copyright notice. Compared to "copyleft" licenses like GPL, the MIT license means enterprises can confidently integrate Harness into commercial products. This signals DeepSeek's strategic intent to maximize community adoption, using ecosystem prosperity to drive usage of their own models.

Soul and Body: Understanding the Core Agent Formula

Many people have likely encountered this pain point: a model converses fluently in a chat window but can't actually get things done—it can't read or write files, execute commands, or work continuously for hours. The reason is simple: a conversational model is just the soul; it lacks a body that can understand its environment and use tools.

This is exactly what the Agent = Model + Harness formula expresses:

• Model (Soul): Responsible for thinking, reasoning, and generating responses—the intelligence core;
• Harness (Body): Provides the Agent with an execution framework for understanding its environment, using tools, and working persistently.

In other words, the model determines how "smart" an Agent is, while the Harness determines whether it can "actually get work done." What DeepSeek Harness aims to do is make this "body" fully modular. This separation also means that the same Harness can be paired with different models (DeepSeek, Claude, GPT, etc.), and the same model can run on different Harnesses, achieving true decoupling.

Everything Is a Plugin: Three Key Design Principles

DeepSeek Harness is built on the Cordis plugin system, with the core philosophy of "everything is a plugin." Cordis is a general-purpose plugin runtime system originating from Koishi (a cross-platform chatbot framework), whose design philosophy is deeply influenced by microkernel operating system principles. In a microkernel architecture, the kernel provides only the most basic process management and inter-process communication mechanisms, with all higher-level functionality running as independent services. Cordis transplants this concept to the application layer, achieving decoupled collaboration between plugins through two core mechanisms—"Services" and "Events." The service mechanism allows plugins to declare which capabilities they provide or depend on, while the event mechanism enables loosely-coupled communication between plugins. There are three key design principles:

Minimal Kernel

The Cordis kernel is only responsible for plugin loading, unloading, and dependency management—it carries none of the Agent's actual capabilities, keeping the kernel minimal and stable. The advantage of this design: any plugin failure won't crash the entire system, and plugins can be dynamically replaced at runtime without restarting the entire Agent.

Plugins Provide All Capabilities

Model invocation, tool integration, skill definitions, conversation management, sandbox execution, storage solutions, loop scheduling, and UI rendering are all provided by independent plugins that collaborate through Cordis's service and event mechanisms.

Configuration Equals Free Composition

Without modifying source code, you can select, replace, or extend any capability at the configuration level, assembling your ideal Agent on demand.

Simply put, it breaks an Agent into a collection of hot-swappable parts—install whatever plugin you need for a capability, swap a plugin to change models, or install a plugin to add new tools.

Core Differences from Traditional Agents

Traditional Agents typically have capabilities hardcoded into the system, while DeepSeek Harness turns every capability into a replaceable plugin. The differences are primarily reflected across four dimensions:

Comparison	Traditional Agent	DeepSeek Harness
Capability Architecture	Capabilities hardcoded in the system; extending requires source code changes	Everything is a plugin; compose directly at the configuration level
Extension Method	Adding features requires redevelopment and recompilation	Select/replace/extend plugins without modifying source code
Runtime Traceability	Process is a black box; difficult to troubleshoot	Every run is traceable; Trajectory view enables replay
Runtime Modes	Usually fixed to a single mode	Four modes (Standard/PTC/Minimal/Creative) switchable on demand

In one sentence: Traditional Agents are "pre-assembled machines," while Harness is "modular DIY." Additionally, it records everything the model sees into conversation logs, supporting recovery, forking, retrieval, and replay, all sharing the same event stream.

Behind this architectural difference lies an industry trend in the Agent space—moving from the "framework era" to the "runtime era." Early tools like LangChain and AutoGen were "frameworks" that provided programming abstractions for building Agents, but developers still needed to write substantial glue code. Starting in the second half of 2024, the industry gradually shifted toward the "runtime" concept—providing an out-of-the-box execution environment where developers assemble Agents through configuration rather than coding. The driving forces behind this shift include improved LLM capabilities that allow more orchestration logic to be handled by the model itself, and the maturation of sandbox isolation technologies (such as Docker containers, WebAssembly, and cloud sandbox services like E2B) that provide infrastructure guarantees for Agents to safely execute code.

Four Runtime Modes Explained

DeepSeek Harness offers four runtime modes by scenario, covering everything from daily coding to experimental exploration:

1. Standard Mode: A fully-featured coding Agent including file editing, Shell, file and web search, Skills, plan goals, sub-agents, and workflows;
2. PTC Mode: Lets the model compose multiple tool calls in a single TypeScript program, accomplishing complex operations in one shot;
3. Minimal Mode: Retains only persistent Bash and file editing tools, for model benchmarking in minimized environments;
4. Creative Mode: Create custom Agent Presets, inspect the runtime, experiment with Cordis plugins, and craft new modes.

Among these, PTC (Programmatic Tool Composition) mode deserves special attention. In traditional Agent frameworks, the model can only call one tool at a time, then waits for the result before deciding the next step—this serial "ping-pong" interaction introduces significant latency overhead since each tool call requires a full round of LLM inference. PTC mode takes a completely different approach: the model directly generates a TypeScript program that composes multiple tool calls, including conditional branches, loops, variable passing, and other programming logic, which is then executed all at once in a sandbox environment. TypeScript was likely chosen over Python as the orchestration language because its static type system can catch more errors before execution and it's naturally compatible with the Node.js ecosystem. This design essentially upgrades the Agent from "conversational orchestration" to "programmatic orchestration," with particularly notable efficiency improvements when handling batch file operations, multi-step API calls, and other complex tasks.

Every Run Is Fully Traceable

Traceability is a major highlight of DeepSeek Harness. Everything the model sees is written to an append-only conversation log, including system prompts, chain-of-thought, tool calls and results, sub-Agent scheduling, and every context injection.

This "append-only log" design actually draws from the Event Sourcing pattern in distributed systems. In event sourcing, the system doesn't store snapshots of the current state but instead records the sequence of all events that caused state changes—the current state can be precisely reconstructed by replaying these events. This pattern is widely used in financial systems, version control (like Git's commit chain), and database WAL (Write-Ahead Log). Bringing it into Agent systems yields three major benefits: first, complete reproducibility—any Agent run can be precisely restored by replaying the log; second, forking support—new execution branches can be created from any historical point to try different strategies without affecting the original path; third, auditability—all decision processes have complete records, which is critical for compliance requirements in enterprise applications.

In the Trajectory view, you can browse these records filtered by source; operations like recovery, forking, retrieval, and replay all share the same event stream. The Trajectory view is essentially a visual frontend for this event stream, allowing developers to step through Agent behavior replay much like a debugger's step-through execution. This is extremely important for debugging and understanding Agent behavior paths—it transforms what was previously a black-box Agent execution process into a fully transparent, reproducible workflow.

Quick Start: Experience It with a Single Command

For users who want to quickly try DeepSeek Harness, installation is very simple:

1. First install Node.js;
2. Enter a single command in your terminal and press Enter:

npx @deepseek-ai/dsh web

Here, npx is a package execution tool bundled with Node.js that automatically downloads and runs a specified package from the npm registry without requiring prior global installation. The web parameter launches Web UI mode, opening a browser-accessible interface locally. The Web UI launches with one click—extremely convenient.

If you want the full source code for secondary development, you can git clone the harness project from DeepSeek's repository and follow the repository instructions to complete installation.

In the installed interface, the left side is the settings page showing installed plugins and their enabled status, where you can toggle, replace, and combine capabilities at any time; the right side is the Trajectory view, reconstructing the complete execution process from conversation logs. The official team also provides a demo video under one minute long—when watching, focus on three things: how the model calls tools, how conversation logs are recorded, and how the Trajectory view reconstructs the entire execution process.

Summary

DeepSeek Harness represents a new approach to Agent architecture—moving from monolithic machines to modular assembly. It lowers the barrier to extending and replacing capabilities while making Agent execution transparent and controllable through comprehensive logging and replay mechanisms. For developers looking to customize Agents and explore autonomous loop workflows, this is an open-source tool worth trying.

From a broader perspective, the emergence of Harness also foreshadows a potential shift in the Agent ecosystem toward an "app store" model—where community developers contribute various functional plugins and users compose them on demand to get customized Agent capabilities. Whether this model succeeds depends on the richness of the plugin ecosystem and community activity, and the choice of MIT license undoubtedly lays a solid foundation for this.

Key takeaways from this article:

• DeepSeek Harness is an Agent runtime where "everything is a plugin";
• The kernel is minimal—Cordis handles only plugin loading and dependency management;
• The core difference from traditional Agents is replaceable capabilities and traceable execution;
• Four runtime modes are available: Standard, PTC, Minimal, and Creative;
• A single npx command gets you started immediately.