DeepSeek Harness Isn't a Codex Clone—It's a New Kind of Agent Runtime

DeepSeek just dropped its first agent product, and it's not what most people expected. Called DeepSeek Harness, it landed quietly—a mention in the V4 Flash changelog, a beta invite here and there—but the implications are big. This isn't just another Codex rival. It's a different way to think about what an agent is.

I got early access to the internal beta. After poking around, building a custom agent preset, and testing it against third-party harnesses, I'm convinced: DeepSeek Harness is less a finished product and more a runtime for assembling your own agents. That's both its power and its challenge.

What Is DeepSeek Harness?

At first glance, it looks like any local agent workbench. Left sidebar, session list, a chat window, model picker. You can switch workspaces, choose from three reasoning levels (Off, High, Max), and control what Harness can access. Nothing revolutionary there.

But then you notice the "Agent Presets." Instead of the usual task modes—coding, writing, research—Harness gives you four presets: minimal, standard, code, and cordis. Minimal is stripped down: no compression, no search, no skills, no sub-agents. Standard is for everyday coding and project analysis. Code handles heavy parallel processing and multi-step automation. And cordis? That's the meta one—it's for building new presets and plugins.

Each preset is essentially a bundle of tools, prompts, and capabilities. You can copy one and tweak it, or use cordis to have the agent itself create a new preset. That's a different mindset from "pick a task, get a canned agent."

Everything Is a Plugin

The headline feature is plugin architecture. DeepSeek calls it "Everything is a plugin," and they mean it. In the beta repo, users had already contributed around 300 plugins in just a few days. Some are cosmetic—changing the UI, adding a desktop pet. Others are deep. One plugin implements cross-session long-term memory plus background self-evolution, all without a vector database. It uses local files, layered context injection, and periodic LLM self-review to compress temporary experience into lasting knowledge.

That's not your typical plugin system. In VS Code, plugins add features to the editor. In Chrome, they extend the browser. Here, plugins can replace the model adapter, the tools, the storage layer, even the entire interface. The docs describe how every component—model, tool, strategy, prompt, memory, UI region—can be swapped or combined via plugins.

Plugins Go Deeper Than You'd Expect

Think about a conventional agent plugin: it might add a button that triggers a headline generator. A DeepSeek Harness writing plugin could do all of that and more: register a tool the model can call autonomously, replace the system prompt and writing rules, bring in custom skills, add web search or external MCP connections, store article drafts and long-term preferences, inject a writing panel into the UI, and restrict which shell, file, or network tools the agent is allowed to use. That's not a feature add-on; it's redefining what the agent can be.

Pi Agent is probably the closest comparison—it lets you extend a coding agent's tools and behavior. But Harness goes further, making the entire agent product recomposable from plugins.

Testing Harness Against the Competition

To see how much the harness matters, I ran the same Three.js sandboarding game task on DeepSeek V4 Flash in three different environments: DeepSeek Harness, Reasonix (a third-party harness popular with DeepSeek users), and OpenAI's Codex.

The results were striking. In Harness, the game was smooth and polished. The player starts sliding, passes through gates, and reaches an oasis. Minimal bugs. With V4 Pro in Harness, the visuals got fancier but the gameplay felt more abstract—sun and sand looked nicer, but the pyramids didn't quite read as pyramids.

Reasonix, despite being touted as the best third-party DeepSeek harness, produced a game that was playable but visually crude. The pyramids, characters, and sky looked unfinished—more like a prototype than a 3D game.

Codex with the same V4 Flash model? Interesting. In one run, it scanned the local folder, found a copy of a 3D library from another project, and used that as a reference without copying it. The result was cleaner and brighter, but not as immersive as Harness's output. In a second run, starting from an empty workspace, it built something simpler—classic Codex style.

One case doesn't prove Harness is better at everything. But it does show that when the model is identical, the harness—its tools, prompts, context management, and execution strategy—can dramatically change the final output.

Under the Hood: Event Logging and Intent-First Execution

Digging into the docs, several technical decisions stand out. First, Harness records an entire event stream for every turn—not just the final message. It logs turn starts, step starts, the exact model used, system prompts, tool definitions, and raw streaming output. Even when context compression kicks in, the original history isn't deleted; it's just hidden from the model via replacement events. That means you can replay or audit exactly what happened.

Second, the agent loop is "intent first, side effects second." The model can write TypeScript that orchestrates multiple tool calls, but intermediate data stays in the runtime environment. Only the final result enters the model's context. This reduces token bloat and keeps the agent focused.

Third, the front end itself is a second plugin tree. The UI isn't a fixed page with backend plugins bolted on. When the app starts, it loads a set of UI plugins that register components into standard mount points—sidebar, chat area, input box, settings. So the interface itself is recomposable.

What This Means for the Future of Agents

DeepSeek's main product has always been the model. But Harness signals a shift: they're now building the execution layer that sits on top of the model. And by making everything a plugin, they're positioning the agent as infrastructure, not a one-size-fits-all app.

Codex tries to deliver a ready-to-use agent. Harness gives you a kit to assemble your own. You can have a writing agent, a coding agent, and a research agent running in the same process, each with different tools and instructions, without spinning up separate services.

That's a meaningful change. Instead of choosing between "the best agent product," you can now build the agent that fits your workflow. The model is just one component. The agent itself—its identity, tools, rules, and memory—can be configured, replaced, and recomposed.

DeepSeek Harness might be late to the agent party, but it's offering something different: a platform where the agent is not a product but a medium. That could change how we think about AI agents altogether.