DeepSeek Open-Sources Agent Framework Harness: A Plugin-First Infrastructure for Intelligent Agents

DeepSeek Open-Sources Harness: From Model Capabilities to Agent Infrastructure

Hot on the heels of making waves in the large language model space, DeepSeek has made another bold move. According to breaking news from Bilibili tech channels, DeepSeek officially open-sourced its Agent framework DeepSeek Harness (Developer Preview) late in the evening, released under the permissive MIT license.

The significance of this move goes far beyond "yet another open-source project." For a long time, DeepSeek's public identity has been anchored in model capabilities. Harness marks a substantive step toward Agent infrastructure — a deeper, more ecologically valuable layer of the stack. As raw model capabilities become increasingly commoditized, whoever can provide the best runtime environment for intelligent agents will hold the competitive advantage in the next phase of the AI race.

For developers, the MIT license means maximum freedom — you can freely modify, commercialize, and redistribute the code, which also lowers the barrier to community participation and ecosystem building.

The Core Design Philosophy of Harness: Everything Is a Plugin

Harness's standout design principle can be summed up in one phrase: "Everything is a plugin."

Under this philosophy, models, tools, skills, painting (memory), sandboxes, storage, scheduling, and UI are no longer hardcoded, monolithic modules — they are all composed from plugins. This means every component can be freely swapped out or recombined. Developers can replace a model or an entire toolchain without tearing down the whole architecture, enabling a truly "LEGO-style" approach to building intelligent agents.

A Composable Architecture Built on the Cordis Plugin System

The entire framework is built on top of the Cordis plugin system. You might not have noticed, but the Harness framework itself "is only responsible for plugin loading and dependency management" — all concrete functional components are pluggable Cordis plugins.

This "minimal core, externalized capabilities" design philosophy follows in the footsteps of successful paradigms like the Linux kernel with drivers, or VS Code with extensions. The official documentation claims that Cordis offers "spatiotemporal composability" — meaning plugins can be freely assembled not just spatially, but also dynamically loaded and unloaded at runtime (the temporal dimension). This provides the underlying foundation for runtime flexibility and experimentation.

Cordis is an IoC (Inversion of Control) container and plugin management framework for the JavaScript/TypeScript ecosystem, originally proven at scale within Koishi (a cross-platform chatbot framework). Its core idea is to decompose all functional units of an application into independent "Services," with the framework centrally managing their lifecycle and dependencies. In the concept of "spatiotemporal composability," the "spatial" dimension means plugins can declare dependencies on demand and combine freely to form different feature sets; the "temporal" dimension means plugins support hot-swapping at runtime — loading a new plugin or unloading an old one requires no process restart, and side effects are automatically cleaned up. This is especially critical for an Agent framework: developers can dynamically switch model providers, swap tool sets, or inject debugging plugins without interrupting the service, dramatically reducing iteration costs.

Four Run Modes: Covering Everything from Production to Experimentation

Harness provides four distinct run modes, covering scenarios from serious production use to free-form exploration:

• Standard Mode: Provides the model with a full toolset, suited for conventional agent task execution.
• PTC Mode: Lets the model compose multi-turn tool calls by writing code — essentially a "code as orchestration" approach, ideal for complex toolchain collaboration.
• Minimal Mode: Retains only the bare essentials, primarily for running benchmarks, eliminating noise for pure capability evaluation.
• Creative Mode: Allows experimenting with plugins in memory and composing entirely new run modes on the fly — the most experimental option available.

The existence of "Creative Mode" signals that Harness doesn't just want to be an execution framework — it aspires to be an experimental playground for agent capabilities. Developers can rapidly validate new plugin combinations in memory without restarting or refactoring, which is extremely valuable for exploring the boundaries of Agent behavior.

PTC Mode (Programmatic Tool Calling) represents an important conceptual shift in the Agent orchestration space in recent years: rather than having a model call predefined tools one turn at a time, you let the model directly generate executable code that strings together the logic for multiple tool calls. This aligns with OpenAI's Code Interpreter and the academic PAL (Program-Aided Language Model) direction. The advantage is that code is itself a structured orchestration language — it natively supports loops, conditionals, and variable passing, enabling far more complex collaborative logic than single tool calls, while also making it easier for humans to inspect and debug the model's "intent."

Full Traceability: The Append-Only Painting Log Mechanism

Harness has also invested significantly in observability. The framework emphasizes that every run leaves a trace: everything the model sees — including system prompts, chain-of-thought (CoT), tool calls, and sub-Agent scheduling — is written to an append-only "painting log."

This log supports four key capabilities — resume, fork, retrieval, and replay — which are critically important for Agent development:

• Resume: Tasks can continue from a breakpoint after interruption, avoiding redundant compute costs.
• Fork: Branch off from a decision point into multiple paths, making it easy to compare the outcomes of different strategies.
• Retrieval & Replay: Fully reproduce the agent's reasoning process, greatly simplifying debugging and auditing.

For large model agents that are notorious for being "black boxes," this kind of traceable, replayable, and transparent design is a key piece of the puzzle for real-world engineering deployments.

"Append-only" is a classic design principle from database and distributed systems, with representative implementations including Apache Kafka's log storage and Event Sourcing architectures. Its core advantage: write operations never overwrite historical records, so the log is inherently immutable and maintains a complete timeline. Applying this principle to an Agent logging system means that even if a task crashes halfway through, the already-recorded context is never lost or corrupted. The "fork" capability is conceptually very similar to Git's branching mechanism — starting from the same historical node, you can spawn multiple independent execution traces for A/B comparison of different prompt strategies, tool call orderings, or sub-Agent selections. This is foundational infrastructure for Agent system tuning and behavioral research.

Getting Started and Current Stage Assessment

The barrier to entry is quite low. According to the announcement, you just need Node.js installed and can launch the Web UI with a single npx command — a familiar experience for frontend and full-stack developers.

That said, it's important to be clear-eyed: Harness is still in developer preview. The official documentation explicitly warns that breaking changes are coming. This means the current API and architecture are not yet stable, making it better suited for exploration, research, and feedback rather than direct production use.

Ecosystem Building: The Key Variable for Harness's Success

The success or failure of a "everything is a plugin" architecture ultimately depends on whether the plugin ecosystem flourishes. Even the most elegant core framework can't build real competitive advantage without a rich supply of plugins. DeepSeek clearly understands this, and has publicly expressed the hope that "the plugin ecosystem grows quickly."

For the broader open-source community, a company renowned for its model capabilities entering the Agent infrastructure space will undoubtedly spark more discussion and follow-on development. Whether Harness can leverage DeepSeek's brand influence and the openness of the MIT license to rapidly accumulate a plugin ecosystem is the most important thing to watch going forward.