DeepSeek Harness Deep Dive: DeepSeek's Agent Is Here — But It Released an "Agent-Assembly Runtime," Not Another Codex

The most direct answer first: the agent product DeepSeek released on August 13, 2026 is called DeepSeek Harness (DSH) — an agent runtime open-sourced under MIT, currently a developer preview (v0.1). Its official definition is a one-line formula: "Model + Harness = Agent" — the model decides what to generate next, and the Harness gives the agent the ability to understand its environment, use tools, and keep working in real scenarios. In other words, DeepSeek did not hand you a ready-to-use closed coding tool the way OpenAI shipped Codex or Anthropic shipped Claude Code; it gave you the entire execution nervous system "outside the model" — and open-sourced it. This site calls it "DeepSeek's agent release," but its more accurate identity is: an open-source piece of infrastructure for assembling any number of agents. Every fact in this article is as of August 14, 2026; this is a just-shipped, fast-iterating product, and details will change.

One note on our fact discipline before we dive in. This article relies on DeepSeek's official Harness page, the official GitHub repository (deepseek-ai/deepseek-harness), the official architecture document, and the official model-provider guide. First-hand experience items (for example, "internal testers built ~300 plugins in a few days" or a specific same-model comparison) come from third-party first-touch reports and are labeled as such. Anything vendor-reported that has not been independently replicated — especially V4 Pro's agent benchmarks — is relayed with skepticism attached. We won't invent numbers to make the story read better, which is the same discipline this site has followed across its DeepSeek coverage.

1. What "DeepSeek's Agent" Actually Is

First, clear up a likely misconception. The industry had been hearing that DeepSeek was "preparing a fully autonomous AI agent by end of 2026" — an earlier research thread on this site recorded exactly that direction. But what actually landed on August 13 is more foundational, and in a sense more radical, than "one fully autonomous agent": DeepSeek didn't release a single product so much as open-source the entire factory for building agents.

Cross-checking the official page and multiple reports, here are the key facts about DeepSeek Harness:

Item	Detail
Product	DeepSeek Harness (DSH), a black-whale logo distinct from the blue-whale model branding
Released	Night of August 13, 2026, as a developer preview (v0.1), iterating rapidly
License	MIT; GitHub: deepseek-ai/deepseek-harness
Positioning	An agent runtime positioned against Anthropic Claude Code / Claude Cowork and OpenAI Codex
Core formula	Model + Harness = Agent
Team	Led by Cui Tianyi (a former Jane Street quantitative trader who joined DeepSeek in March 2026); project internally greenlit in May
Quick start	npx @deepseek-ai/dsh web, default http://127.0.0.1:3080, requires Node 22.19+ or 24+
Repo traction	~27.5k stars on launch day, ~39k a few days later (third-party page figures)

A caveat: the "~39k stars" figure comes from a page scrape at a specific moment; it will keep moving, so treat it as evidence that the project is genuinely hot rather than as a precise datum. The team-lead and project-timeline details come from multiple press reports of DeepSeek researchers' public statements — corroborated across sources but not a formal official announcement.

A more important piece of context: DeepSeek had already telegraphed this in the V4 Flash changelog, which said the GA version of DeepSeek-V4-Flash was benchmarked using "DeepSeek Harness minimal mode (coming soon) as its framework." In other words, Harness wasn't born out of thin air — it was already the internal harness used for agent benchmarking, and this release simply open-sourced the whole framework. That is very consistent with DeepSeek's style: let documentation speak, run things internally first, then hand them out.

2. Features: What a Local Agent Workbench Can Do

Once it's running, DeepSeek Harness is a local agent workbench on your own machine: project management, long-horizon task collaboration, multi-agent orchestration, context management, web search, and Skills, all included. It ships with a Web UI — a left sidebar of sessions and workspaces, a conversation pane, model switching, three reasoning levels (Off / High / Max), and access-permission controls.

Broken down by module, its feature set looks roughly like this:

• Full coding-agent capabilities: file editing, shell execution, file and web retrieval, Skills, planning, goals, sub-agents, and workflows. This part is aligned with Claude Code / Codex.
• Multi-agent orchestration: one process can run "writing," "coding," and "research" agents simultaneously, each with its own scoped toolset, without cross-contamination.
• Append-only session logs: system prompts, chain-of-thought, tool calls and results, sub-agent dispatch, and every context injection all land in a single event stream. A trajectory view lets you inspect by source; resume, fork, retrieve, and replay share that same event stream. This is one of the biggest differentiators from most rivals.
• MCP support: the official repo ships an MCP client bridge plugin that connects to external MCP servers (stdio or streamable-http), registering their tools as mcp__server__tool, with auto-reconnect and exponential backoff. A community MCP server (@deepseek-harness/mcp) targets DeepSeek V4 specifically and works from MCP-aware desktop clients such as Claude Desktop, Cline, Roo Code, and Cherry Studio.
• Third-party models: roughly 40 model vendors pre-configured by default (a third-party first-touch figure; the official docs name DeepSeek, Anthropic, OpenAI, Google, plus credential-based Bedrock, Vertex, Azure, and Codex), and you can add arbitrary custom providers.
• Security and permissions: tool execution runs through a gated pipeline (tools/pre-execute → execute → post-execute) where plugins can attach approval rules, permissions, sandboxing, timeouts, retries, and telemetry; programmatic tool calls cannot bypass these checks.

A necessary reality check: taken one by one, nearly every capability above has a counterpart in Claude Code, Codex, OpenClaw, or Grok Build. File editing, shell, retrieval, Skills, sub-agents, plan mode, and MCP were not invented by DeepSeek. What actually separates DSH from them is architectural — the subject of sections 3 and 4 — not the feature checklist.

3. Framework: The Cordis Plugin System and "Everything Is a Plugin"

The core design principle of DeepSeek Harness is a single sentence: "Everything is a plugin." It is built on a plugin system called Cordis (GitHub: cordiverse/cordis). Cordis is itself a meta-framework — it only handles plugin loading, unloading, and dependency management, and provides no business capabilities of its own. Every capability inside DSH is a plugin mounted on Cordis: model adapters, the tool registry, the session log, the sandbox, storage, scheduling, the UI, and even the agent loop itself.

Two consequences follow, and they're special. First, there is no privileged kernel to patch. To extend DSH you don't modify source or open a special extension point — you "mount a new plugin next to another plugin." All registrations are reversible side effects, automatically undone when the plugin unloads. Second, the model itself is demoted to a swappable plugin. You can keep the same session, tool, and permission system and swap only the model adapter; or you can hold the model fixed and compare different context-management strategies. That's a fundamentally different philosophy from the vertically integrated "model + product" approach of Claude Code or Codex.

At the implementation level, a running dsh is a plugin tree assembled by stacking layers at startup:

Concept	Role
Profile	A named assembly stored in the Harness home; lists the bundles to stack and holds your cordis.patch.yml. web and headless ship as templates.
Bundle	A distribution format for Cordis config plus mounting code; upper layers can always patch it.
dsh-base	The first layer of every profile: model adapters, tools, persistence, sandbox and approval policies, settings, credentials, telemetry.
Patch layers	Profile patch → home-level patch → any --patch overlay, stacked in order.

You can inspect the resulting tree with dsh --profile web --dump-config. Core packages contribute services (ctx keys) to that tree: core/session handles the append-only SessionEvent log, core/tools handles the scoped tool registry and the gated execution pipeline, core/agent and core/agent-loop handle the Agent interface and the default driver, core/system-prompt assembles prompt fragments and tool schemas, and llm/llm provides the message/streaming vocabulary and an adapter seam.

In DSH, "events are the extension points," in three categories: session events (persistent facts appended to the log), agent events (live interception points carrying the running Agent, for observing or intervening in in-flight work), and capability events (attaching policies and adapters to seams like fs/*, tools/*, telemetry/* without import cycles). A turn flows like this: turn/start → claim input → assemble prompt and tool schemas → agent/pre-step (listeners may rewrite or reject) → step/start → derive model history from the log → agent/request → llm/stream → assistant/chunk → tool/call → tools/pre-execute / execute / post-execute → tool/result → step/end → agent/turn-stopping → turn/end.

The official architecture doc also emphasizes an invariant: "model-visible ⇔ recorded" — anything that reaches a model request must be reconstructible from the session log. Context compression uses replacement events and never deletes original history. That's genuinely valuable for debugging, auditing, and replaying an agent's every step, and it explains why the docs treat the session log as "the source."

4. The Four Run Modes and the Preset System

DSH ships with four built-in "agent presets." The official definition is crisp: a preset is the plugin assembly a session's agent runs on — its tools, prompts, and capabilities. By analogy: the model is the brain, a Skill is the operations manual, tools/plugins are the software and permissions, and an agent preset is "job position + work environment."

Mode	Description
Standard	A fully featured coding agent: file editing, Shell, file/web retrieval, Skills, planning, goals, sub-agents, workflows. The daily default.
Code / PTC	Everything in Standard, plus a Code Mode SDK that lets the model write a single TypeScript program to combine multi-step operations — intermediate data stays in the runtime, only final results enter context.
Minimal	Only two tools: persistent bash and str_replace_editor. Used for benchmarking models in a minimal environment — DeepSeek officially says the GA V4 Flash was tested in this mode.
Creation	For building custom presets/plugins: runtime inspection, in-memory Cordis plugin experimentation, loading/unloading components on demand.

Presets compose on two levels: the Profile decides how the dsh process runs (Web/Headless, bundle list, patch layering), and the Agent Preset decides what a session's agent sees (tools, prompts, capabilities), with a resolution order of agent → preset → global. You can copy a preset, change its tools/prompts/capabilities, and save it as your own — that's what "a preset is a job position plus a work environment" means in practice.

One very "DeepSeek" detail: in Creation mode, the agent itself can operate the Cordis runtime — inspect the environment and load or unload plugins in real time. So DSH's self-extension isn't only a developer editing config files; the model is allowed, under controlled conditions, to alter its own runtime assembly. That's aggressive for a v0.1, but it's the natural extension of the "agent as infrastructure" thesis. Just remember this is a developer preview, and DeepSeek has explicitly warned of compatibility-breaking changes ahead.

5. Innovation, Honestly Sorted: Genuinely New vs. Re-Wrapped

This section needs your full attention, because "DeepSeek shipped an agent" can easily be told as "yet another Claude Code alternative." Look closer, and DSH's novelty is unevenly distributed: a few things are genuinely new, a few are just cleaner packaging of things that already existed. We list them explicitly and mark each one's novelty judgment.

Genuinely new (worth a paragraph of its own, in this site's view):

• Making the entire agent product a recomposable plugin tree, not "a product + a plugin API." This is the core difference. Claude Code / Codex plugins are essentially tool/service add-ons (hook up a browser, a Notion workspace, a code search). DSH makes the model adapter, tool registry, session log, agent loop, and UI themselves replaceable plugins. A third-party first-touch review put it well: "Codex tries to deliver a ready-to-use agent; DeepSeek Harness is more like a runtime for assembling agents." That's not a degree difference; it's a product-form difference.
• Append-only full event stream plus the "model-visible ⇔ recorded" invariant. Most agent tools only store final conversation messages; DSH writes turn/start, step/start, the actual model used, system prompts, tool definitions, and raw streamed output to disk, and context compression uses replacement events that never delete history. Resume, fork, retrieve, and replay share one event stream. For auditing, debugging, and reproducing agent behavior, that's a real new capability.
• Open-sourcing the agent infrastructure, not just model weights. DeepSeek has long open-sourced models (V4 Pro is MIT weights too); this time it open-sourced "the entire execution system outside the model." When a model vendor open-sources the Harness layer, it hands the "developer entry point" to the community. The third-party line "DeepSeek open-sources everything so we don't have to live under Anthropic's rule" targets exactly this.
• A model-operable runtime (Creation mode). Letting the agent itself load/unload plugins and inspect the environment is nearly unseen in mainstream coding agents — a "meta-capability" unique to DSH.

Re-wrapped (incremental, not innovation):

• MCP client bridge, Skills, sub-agents, plan mode, web search, terminal — Claude Code and Codex already had these; DSH just re-implements them as plugins.
• The preset system ("job position + work environment") is close in spirit to Claude Code's subagents and Codex's AGENTS.md personas — cleaner packaging, not an invention.
• The four run modes are product decisions, not technical breakthroughs.

Parts that must be flagged "unverified / not yet independently replicated":

• V4 Pro's agent benchmarks. DeepSeek reports DeepSWE jumping from 12.8 (Preview) to 62.7, Terminal-Bench 2.1 to 87.9, CyberGym to 83.3. But note: some of those agent results were measured in Harness minimal mode — they don't measure pure model ability, but "model performance inside DSH's execution environment." The vendor's own harness is baked into the score, so these are not clean third-party replications. Until they show up on neutral arenas like LMSYS, treat DeepSeek's self-reported numbers as "reported but not verified."
• "Internal testers built ~300 plugins in a few days" and a single same-model test (V4 Flash driving DSH / Reasonix / Codex to build the same Three.js game, with DSH judged best) are third-party first-touch anecdotes. The reviewer himself says one case can't prove DSH wins on all tasks. Reference, not conclusion.
• ~40 default model vendors comes from a third-party first-touch report; the official docs name only a few. Go by the actual model catalog after install.

And an honest weakness: third-party first-touch testing found DSH could take over half an hour on a coding task — slow for a company "known for speed" — and in that same test V4 Pro took longer yet produced worse results than V4 Flash. The v0.1 execution pipeline is not yet tuned to its ideal state. Before making it a production mainstay, stress-test it yourself on medium-size tasks.

6. Pricing and Access: Harness Is Free; the Models It Drives Are Not

An easily missed but crucial fact: DeepSeek Harness itself is free — MIT-licensed, runs locally, no subscription, and no DeepSeek account required. It only calls whatever models you configure. So "what does it cost to use DSH" is really "which model do you drive it with." That's a completely different business model from Claude Code (Anthropic subscription or API credit) and Codex (OpenAI credit): DeepSeek gives the software layer away and earns on the model layer.

And the model layer is in a delicate window. When DeepSeek V4 Pro GA (DeepSeek-V4-Pro-0813) went live in the early hours of August 13, the official API price was unchanged from the Preview — no increase yet: ¥3/M input (cache miss), ¥6/M output, ~¥0.025/M cache hit; V4 Flash sits at ¥1/¥2/¥0.02. But the same day DeepSeek published a new rate card that takes effect August 17, 2026 at 00:00 Beijing time, introducing peak/off-peak pricing:

Model	Period	Input (miss) ¥/M	Cache hit ¥/M	Output ¥/M
V4 Pro	Off-peak	4.5	0.15	13.5
	Peak	9.0	0.30	27.0
V4 Flash	Off-peak	1.5	0.05	4.5
	Peak	3.0	0.10	9.0

Peak hours are 9:00–12:00 and 14:00–18:00 Beijing time; all other hours are off-peak. In practice, V4 Pro's output price goes from ¥6 to ¥13.5 off-peak (+125%), and its cache-hit price from ¥0.025 to ¥0.15 (+500%); V4 Flash output goes from ¥2 to ¥4.5 off-peak (+125%). So the "¥3/¥6" in this article is the last window at the old rate — after August 17, even off-peak prices are more than double today's, and peak is worse.

Two practical implications for this site's readers. First, if you want to lock in window pricing, move fast — but don't hoard tokens, because relay prices will follow official increases on their own schedules, and you'll need to check each vendor's notice. Second, after the hike, going through a relay gets relatively more attractive: official peak/off-peak pricing creates a time-of-day spread, while some relays resell at flat low prices or host the open DeepSeek weights on domestic clusters (SiliconFlow is the clearest example), widening the gap versus official pricing. More on that in the next section.

7. How to Connect It to a Relay: Env Vars, Web UI, settings.yaml, and Model IDs

Because DSH is model-agnostic, connecting a relay is one sentence: point DSH at the relay's OpenAI-compatible (or Anthropic-compatible) endpoint, and let it use the relay's key and model ID. Here are the three officially supported configuration paths, plus the model-ID cheat sheet this site has verified.

Path 1: Environment variables (fastest, for scripts/SDK/CLI)

export DEEPSEEK_API_KEY=sk-your-relay-key
export DEEPSEEK_BASE_URL=https://your-relay.example.com/v1
export DSH_MODEL=deepseek-v4-pro   # or deepseek-v4-flash
export DSH_SYSTEM_PROMPT='You are a helpful software engineer.'

DEEPSEEK_BASE_URL points at the relay's OpenAI-compatible address (usually ending in /v1). DSH_MODEL's precedence is: CLI --model flag > environment variable > default deepseek-v4-flash. In the SDK, you specify provider="deepseek-official" and model="...".

Path 2: Add a custom provider in the Web UI

In "Add Custom Provider" you fill in four things:

• Provider ID: lowercase and permanent — requests, sessions, and credential references all use it; renaming means creating a new provider.
• Base URL: the relay address, e.g. https://relay.example.com/v1.
• API protocol: choose openai-completions (or another OpenAI-compatible protocol).
• Credentials + at least one model: an API key, or apiKeyEnv referencing an environment variable.

"Get Available Models" calls the OpenAI-compatible GET /models endpoint; if the relay doesn't expose it, enter the model ID manually. Two common errors: MISSING_CREDENTIAL (store a key on the model page) and UNKNOWN_MODEL (add a model that actually exists).

Path 3: settings.yaml (good for config-in-repo)

# $DSH_HOME/settings.yaml
llm-pi-ai:
  apiKeyEnv: GATEWAY_API_KEY
  api: openai-completions
  baseURL: https://relay.example.com/v1
  models:
    - id: deepseek-v4-pro

Each route can only use one wire protocol; OpenAI-compatible implementations require an API key or Authorization header, so for a local no-auth service use apiKeyEnv to reference a placeholder credential. If you use DeepSeek official rather than a relay, the official base URLs are: OpenAI-compatible and Responses API both at https://api.deepseek.com, and Anthropic-compatible at https://api.deepseek.com/anthropic. In other words, to point Claude Code straight at DeepSeek V4 Pro, set the base URL to /anthropic; to point Codex at it, use the Responses API. Relays usually implement only the OpenAI-compatible protocol, so confirm before you choose.

Model-ID cheat sheet: which eggstriker-reviewed relays already sell them

Since DeepSeek didn't change the model IDs this time (still deepseek-v4-pro and deepseek-v4-flash), any relay that forwards the official API should transparently serve the 0813 weights. Among this site's reviewed vendors, the ones explicitly listing deepseek-v4-pro and/or deepseek-v4-flash include:

• DeepSeek official (platform.deepseek.com, direct from mainland China, ¥3/¥6 window pricing until Aug 17)
• SiliconFlow (硅基流动): self-hosts the open weights; V4-Flash ¥1/¥2, V4-Pro ¥12/¥24 (cache ¥1.00); domestic direct, no proxy needed
• 302AI, 4SAPI, OpenRouter, CloseAI, AIHubMix, FlowBar, UiUiAPI, DuckCoding, TokenRiver: all list deepseek-v4-pro + deepseek-v4-flash
• RunAPI: lists deepseek-v4-pro; YKH.AI: lists deepseek-v4-flash

One honest reminder: those model IDs are what each platform listed when this site last verified it — they do not guarantee every vendor has synced the latest 0813 weights, and prices may already differ from this article's numbers. DeepSeek-side IDs are stable, so the risk is low; but after the official August 17 price change, whether and how much each relay follows is something you should check in their console before selecting. Aggregators like OpenRouter sometimes prefix model names with the vendor (e.g. deepseek/deepseek-v4-pro), so follow the target platform's actual listing.

Finally, a minimal end-to-end flow: run npx @deepseek-ai/dsh web locally (Node 22.19+ or 24+); in the Web UI add a custom provider with your relay's /v1 base URL, openai-completions protocol, and model ID deepseek-v4-pro; open a Standard session and ask it to do a small task (e.g. "read the README and summarize") to confirm tool calls and billing work before going to real work. The whole flow needs no DeepSeek account — you pay only the relay.

8. Conclusion: The Real Signal of That Night, and the Traps

Read together with the same-night V4 Pro GA, DeepSeek Harness's launch sends a clear signal.

Signal one: model-lab competition is moving from "better models" to "better harnesses." Raw model intelligence still matters, but V4 Pro's agent benchmarks are now officially measured inside DeepSeek's own harness — when a model vendor starts open-sourcing the execution environment too, it's betting on the full "model + execution system" delivery chain. The field is crowded: OpenAI Agents SDK, Claude Agent SDK, LangGraph, OpenClaw, Grok Build. DSH's differentiation isn't features; it's that the entire chain is re-installable.

Signal two: DeepSeek wants the developer entry point above the model. The model is upstream; the harness sits closer to the user. Whoever owns the harness owns the defaults for "which model, how context is organized, how tools are called." By open-sourcing that layer, DeepSeek is effectively inviting developers to assemble their own agents on DeepSeek's base — the opposite ecosystem strategy from Claude Code and Codex.

But the traps deserve repeating. First, v0.1 is a developer preview with explicitly promised breaking changes — don't migrate production wholesale yet. Second, the official agent benchmarks have the harness baked in; don't take "DeepSeek crushes Fable 5" headlines seriously until third parties replicate. Third, third-party testing found it slow (30+ minutes on a coding task); efficiency isn't tuned. Fourth, the official August 17 price increase is certain — use the window price if you want it, but verify relay prices vendor by vendor.