Getting Started with DeepSeek Harness: Exploring the All-Plugin Agent Framework

DeepSeek Harness is an open‑source Agent framework from DeepSeek, currently in developer preview, whose core principle is “everything is a plugin”. The framework treats tools, model adapters, file access, session logs, and even the agent loop itself as interchangeable plugins.

All components—tools, models, and the agent cycle—can be swapped at any time, which is the essence of DeepSeek Harness.

Why Extending Existing Agents Is Painful

When trying to add a custom tool to Claude Code, one must modify configuration and write an MCP server; swapping models in Codex requires changing hard‑coded routing; exploring other agents often leads to tangled source trees with hundreds of files. Existing agent tools weld the core and business capabilities together, offering only limited extension points and requiring official releases for replacements.

Relying solely on official plugins is insufficient because users need capabilities the official set does not anticipate. Forking and modifying the source is also problematic, as upstream updates must be merged repeatedly, inflating maintenance costs.

What Is DeepSeek Harness?

DeepSeek Harness (dsh) provides a Lego‑like base for agents: each capability is a plugin that can be independently added, removed, or replaced.

The foundation is Cordis , a plugin runtime that shares a single ctx (context) object. Plugins register their contributions into this context: ctx.tools: tool registry allowing the model to invoke functions ctx.llm: model adapter handling various large models ctx.agents: agent interface managing active agents

A minimal plugin exports an apply function that receives the ctx and registers tools, services, or event listeners:

// A plugin skeleton: export apply to register capabilities
import type { Context } from '@deepseek-ai/cordis';
export const name = 'my-plugin';
export function apply(ctx: Context) {
  // register your tools, services, event listeners here
}

The assembly of an agent is driven by a cordis.yml configuration file, for example:

# cordis.yml: compose an agent line by line
- name: '@deepseek-ai/dsh-bash-local'   # Bash executor
- name: '@deepseek-ai/dsh-tool-bash'   # Bash tool exposed to the model
- name: my-plugin                     # Your custom plugin

Why the Design Matters

Changing capabilities does not require code changes; swapping the Bash executor for a sandbox version is as simple as editing the corresponding line in cordis.yml.

The framework has no privileged kernel. As the official documentation states, “there is no privileged kernel that needs patching.” Extending Harness is done solely by adding new plugins to the plugin tree.

Plugin registration is reversible: when a plugin is unloaded, all its events, tools, and timers are automatically cleaned up, leaving no residue.

Comparison with Claude Code and Codex

Claude Code remains convenient for “out‑of‑the‑box” use, but for developers who want full control over every component of an agent, Harness offers a rare open‑source, replaceable, and kernel‑free alternative.

Who Should Use It

Developers who want to write custom tools, integrate proprietary models, or connect internal services to an agent.

Technical teams seeking a unified agent configuration managed through a single cordis.yml file.

Architecture enthusiasts interested in studying a concrete “everything is a plugin” implementation.

Series Roadmap

This article is the first of a 14‑part “DeepSeek Harness Beginner’s Handbook”. The series will first guide readers to get the environment running, then teach how to write plugins, and finally dive into deeper internals.

Next up: a 5‑minute walkthrough to launch the Web UI and execute the first task.

Summary

DeepSeek Harness is DeepSeek’s open‑source agent framework built on a plug‑in architecture.

Plugins register capabilities into a shared ctx; cordis.yml assembles the agent.

Compared with Claude Code/Codex, Harness is open‑source, replaceable, and lacks a privileged kernel.

It targets developers and teams that need fine‑grained control over agent components.