DeepSeek Releases Harness as Open Source, With Models, Tools, and Agent Loop Built as Plugins

DeepSeek has placed Harness under an open-source license, rendering models, tools, and the Agent Loop replaceable plugins.

DeepSeek's Harness has finally landed.

On August 13, DeepSeek made the DeepSeek Harness developer preview available to developers worldwide. The initial release, v0.1, was accompanied by source code published under the MIT license: https://github.com/deepseek-ai/deepseek-harness

The Web UI can now be launched directly via `npx @deepseek-ai/dsh web`; alternatively, the full project can be pulled from GitHub.

The version number signals a product far from maturity. DeepSeek has acknowledged that considerable refinement remains, with core plugins and foundational interfaces slated for rapid iteration. Even so, the release has settled the question the industry most wanted answered: how DeepSeek would approach its own Harness.

The answer given: everything is a plugin.

Replaceability extends even to the Agent Loop.

Discussion of AI coding has, in recent months, moved from models to harnesses. The same model, embedded in different agent systems, can yield markedly different results. The cause is straightforward: the model predicts the next step, while the harness governs what the model sees, which tools it may invoke, how context is structured, how failures are retried, and when a task is deemed complete.

Mainstream coding agents now support plugins, MCP, or custom tools, yet extensibility has typically been limited to tool and skill layers. DeepSeek Harness extends the plugin boundary to the entire runtime: models, tools, skills, sessions, sandboxes, storage, Agent Loop, scheduling, and UI are all plugin-defined.

Replaceability now spans from a search tool or MCP Server to the agent's looping behavior, sub-agent scheduling, session persistence, and the eventual interface — all without modification to Harness source code.

The architecture rests on the Cordis plugin system. Cordis, as a meta-framework, handles only plugin loading, unloading, and dependency management; agent capabilities are supplied by individual plugins. Coordination occurs through services and events, with configuration governing composition.

Tool invocation has likewise been refactored into an extensible pipeline. Requests pass through hooks, approval, permission checks, sandboxing, and timeout control before execution; afterward, results may be rewritten, recorded, and rendered. Plugins can be inserted at any stage without changes to tools or the Agent Loop.

Code and its sub-calls in PTC mode pass through the same pipeline; approval and sandboxing cannot be circumvented. Standard and programmatic tool calls enter through different paths yet share a common security and observability framework.

DeepSeek Harness is thus positioned as a composable agent runtime foundation, a departure from fixed-function coding agents. The release is aimed, first and foremost, at Harness developers rather than end users seeking a client to begin coding immediately.

The four modes are, in effect, four plugin configurations.

Four runtime modes are offered on a single foundation. No separate systems are maintained; the modes differ chiefly in their default plugin sets.

Standard mode provides a full tool set for conventional agent tasks. PTC mode supports Programmatic Tool Calling, allowing the model to generate code that chains multiple tool calls. Minimal mode retains only shell and file-editing tools, isolating the model for testing in a minimal environment. Creative mode permits the agent to inspect its runtime, experiment with Cordis plugins in memory, and assemble new runtime modes.

Creative mode merits the closest attention. Under conventional harnesses, runtime behavior is predefined by product developers, leaving users to select among fixed configurations. Creative mode instead enables the agent to understand its runtime and, as tasks require, test plugins and assemble capabilities. Configuration, in short, is itself becoming a manipulable object for the agent.

How close this brings the field to an 'agent that reconfigures its own harness' awaits validation by code, examples, and real workloads. What is confirmed: runtime composability has been granted to models, configuration, and framework developers alike.

Multi-Agent Design: Architecturally Novel, Paradigmatically Unchanged

A full multi-agent system is built into DeepSeek Harness. Parent agents may launch sub-agents with fresh contexts via Spawn, or pass on existing sessions through Fork; for more demanding tasks, the model can author JavaScript in situ via the workflow tool, orchestrating parallel or pipelined execution with parallel() and pipeline(), and rotate among fresh agents through Ralph mode.

Among the five standard orchestration patterns, DeepSeek Harness most resembles hierarchical Supervisor–Worker: parent agents decompose, assign, and consolidate tasks while sub-agents execute. It is, more precisely, a hybrid — hierarchical at its core, with parallel, pipeline, and Ralph-loop capabilities.

A genuine Swarm remains distant. Control and task allocation reside primarily with the parent agent; mechanisms for autonomous discovery, negotiation, competition, and dynamic task handover among agents are absent.

The multi-agent capabilities of DeepSeek Harness are therefore innovative without constituting a paradigm shift. Spawn, Fork, Pipeline, and Ralph Loop all follow established precedents; the genuine differentiator is that these patterns are implemented as configuration-replaceable plugins, allowing even Claude Code, Codex, or ACP-compatible external agents to be attached behind the same sub-agent interface. The architecture is novel; the orchestration paradigm is not. The design is advanced by open-source harness standards; describing it as a 'new multi-agent architecture' would overstate the case.

Every Trajectory Is Written to a Single Event Stream

A further core design decision is the append-only session log.

All model-visible content — system prompts, reasoning, tool calls and their results, sub-agent scheduling, and each context injection — is written to a single append-only log. Entries can be inspected by source in the Trajectory view; session resumption, forking, retrieval, and replay are all anchored to the same event stream.

The design targets observability first. Failure of an agent task can originate in model judgment, tool output, context injection, scheduling policy, or system prompts; scattered across components, these are difficult to reconstruct. A unified event stream provides a common record for debugging, evaluation, and replay.

Session forking, too, receives a more natural data structure: new branches inherit events preceding the fork point and append fresh context and actions, leaving the original history intact. The property is especially consequential in a plugin-replaceable system, where developers must compare Loop, tool, or scheduling plugins against identical task trajectories.

Differentiation Is Staked on Architectural Openness

On the evidence of this release, the sharpest differentiation of DeepSeek Harness lies at the architectural level, where each layer's capabilities are decomposed into replaceable plugins. No novel multi-agent orchestration algorithm has been introduced; the emphasis is on allowing developers to alter both the tools available to an agent and the rules governing its operation.

An industry expert told InfoQ that, across the full Harness chain, the major directions — tool calling, memory management, and task planning — are essentially fixed, with substantial innovation expected in constituent components. Memory management illustrates the point: accumulated memory requires compression, and conflicting memories demand prompt reconciliation and cleanup lest they distort subsequent agent judgment.

Task planning likewise admits further refinement. Agents need not plan anew on every occasion; recurring problems can reuse established planning paths. Once generated, a plan could be subjected to a 'compilation'-style check: the Plan is first rendered as structured data, then examined for complete exception-handling branches, absence of unexecutable operations, and conformity of every step to permitted scope. The 'compilation' is not compilation proper, but structured validation of the execution plan.

On this reading, harness frameworks are converging; the decisive gap will be the granularity of memory compression, conflict cleanup, path reuse, and Plan validation. The merit of DeepSeek's 'everything is a plugin' principle is that it reserves space for the replacement, combination, and continued experimentation of precisely such local capabilities.

The approach, however, carries visible costs. The deeper the plugin boundary, the more difficult the control of interface stability, dependency management, version compatibility, performance overhead, and debugging complexity. At the v0.1 stage in particular, core plugins and foundational interfaces remain in flux; developers who enter the ecosystem now must absorb substantial migration costs.

Nor does universal replaceability translate automatically into higher task success rates. The architecture's ultimate value rests on the quality of official default plugins, the stability of composition patterns, and the credibility of published evaluations — and on whether third-party developers persist in building for the ecosystem. A plugin system creates room for differentiation; the outcome is delivered by implementation.

That DeepSeek selected the MIT license and released complete source code during developer preview indicates ambitions beyond a closed client for its models. Models, tools, Loop, scheduling, and UI are to be housed in a single composable framework, with external developers invited to extend it in common.

DeepSeek Harness v0.1 is a beginning. The question worth watching is whether 'everything is a plugin' crystallizes into a stable development standard, and whether the project matures into DeepSeek's own coding product or the shared harness beneath a broader field of agent products.

Getting Started

With the Node.js toolchain installed, the Web UI can be started with the following command:

`npx @deepseek-ai/dsh web`

The source may also be obtained directly:

`git clone https://github.com/deepseek-ai/deepseek-harness`