Independent guide · developer preview

DeepSeek Harness, mapped for builders

A practical, source-linked briefing on the plugin-first agent runtime: what the harness does, why trace logs matter, which modes exist, and how to try the official preview without treating it as a black box.

Open sourceOfficial project is MIT licensed.
Plugin-firstCapabilities mount as composable plugins.
Traceable runsSession logs make runs inspectable.
Illustrated DeepSeek Harness trajectory panel showing plugin runtime and session events
Trace view, simplifiedOriginal visual based on public Harness concepts.

What DeepSeek Harness is

DeepSeek Harness is the open-source agent harness around DeepSeek's agent product direction. The public preview frames the architecture around one rule: every capability is a plugin. That means the model adapter, tools, skills, session store, sandbox, scheduler, loop and user interface can be selected, swapped or recomposed through configuration instead of being hard-wired into one agent shell.

For builders, the important idea is not only extensibility. A harness is the operational layer that lets a model act in a real environment: it decides what tools exist, what context enters the run, how actions are logged, which safety boundaries apply, and how a user can resume, fork, search or replay a session. The model sets the ceiling; the harness determines whether that capability survives contact with files, terminals, long tasks, errors and product feedback.

This page is an independent guide. It summarizes the public preview, points to the official sources at the end, and keeps recommendations grounded in what is currently visible from DeepSeek's own page and repository.

Architecture

A harness is the layer around the model

Read the system as a set of replaceable capability slots. Each slot changes what the agent can perceive, do, remember, replay and recover from.

Kernel

Cordis-style plugin mounting

The official preview points to Cordis as the plugin system that manages mounting, unmounting and dependencies.

Tools

Typed action surfaces

Tools become reviewable interfaces with permission boundaries, arguments, observations and traceable outcomes.

Sessions

Append-only run records

Prompts, tool calls, observations, context injections and subagent scheduling can be inspected from one event stream.

Storage

State that can be resumed

Harness work is long-running. Durable session state lets a user pause, fork, replay and compare runs instead of losing context.

Sandbox

Environment boundaries

The harness defines what the agent may touch, how risky actions are gated, and how outputs become evidence rather than guesses.

UI

Runtime you can inspect

Developer preview UI is not decoration. It is where configuration, trajectory inspection and plugin composition become usable.

Traceability

Every run should leave a trail

When an agent touches real work, a result is not enough. Builders need to see how the run moved from prompt to tool call to observation to next action.

Try the preview

Install Node.js, then use the official preview command.

npx @deepseek-ai/dsh web
git clone https://github.com/deepseek-ai/deepseek-harness
Open quick-start notes
prompt
Intent enters the run

The harness decides what context and capability surface should be available.

mount
Plugins become active

Models, tools, skills, sessions, storage and UI can be composed for the job.

observe
Tool output becomes evidence

The next model step can use structured observations rather than memory of what might have happened.

replay
The session can be inspected

Resume, fork, search and replay work because the event stream is the shared source of truth.

Runtime modes

Pick the smallest surface that still fits the work

The official preview describes Standard, Code, Minimal and Creator modes. The right choice depends on whether you need breadth, orchestration, benchmarking or preset authoring.

Builder path

Evaluate it like infrastructure, not a prompt pack

A harness changes failure modes. Test the runtime around the model: trace quality, permission gates, recovery, composition and user feedback loops.

1

Run the Web UI

Confirm the preview launches locally and note which capabilities are enabled by default.

2

Inspect a trace

Check whether prompts, tool calls, observations and context injections can be understood after the fact.

3

Swap a capability

Try a small plugin or mode change before judging the architecture by the default surface.

4

Replay a real task

Use a work sample with files, errors and recovery. That is where harness design becomes visible.

FAQ

Short answers for developers

Use these as quick orientation before reading the official repository and docs.

Is this the official DeepSeek site?

No. This is an independent guide. Official source links are listed below so readers can verify the project directly.

What does “everything is a plugin” mean?

It means agent capabilities are mounted and composed through a plugin system: models, tools, skills, sessions, sandboxes, storage, loops, scheduling and UI.

Why does traceability matter?

Agent runs are multi-step. Traceability lets builders inspect what the model saw, which tools ran, what returned, and why a later step happened.

Which mode should I start with?

Start with Standard mode for exploration, Minimal mode for cleaner benchmarks, Code mode for orchestrated tool rounds, and Creator mode when you are shaping presets or plugins.

Source notes

Official and community sources used

This guide keeps external links in source notes rather than using them as conversion paths.