DeepSeek Harness Isn't a Codex Clone—It's an Agent Operating System

The Quiet Launch That Shifts the Agent Battle

DeepSeek just dropped its first Agent product, DeepSeek Harness. The announcement was easy to miss—buried in the V4 Flash release notes was a single line about using Harness in minimal mode for benchmarking. But this is a big deal. For months, the AI world has been fixated on model benchmarks and reasoning scores. DeepSeek is now moving downstream, into the layer where models get turned into actual work.

I got early access to Harness before the public release, and after a week of poking around, I can say this: calling it a “DeepSeek version of Codex” misses the point. It’s more like a runtime for building agents. And that distinction could change how we think about AI tools.

What Harness Looks Like on the Surface

First impressions are familiar. Left sidebar, new session buttons, workspace folders—the standard layout of any local agent tool. But the details diverge fast. Instead of generic “coding” or “office” modes, Harness ships with something called Agent Presets. These aren't just UI skins; they're complete configurations that define what an agent can see and do.

There are four built-in presets: minimal, standard, code, and cordis. Minimal strips out compression, search, skills, and sub-agents—it's for quick tweaks. Standard handles everyday coding and bug fixes. Code mode is for heavy parallel searches and multi-step automation. Cordis is the meta one—it's for building new presets and plugins.

You can switch between them with a slash command, just like you'd type /help in a chat app. But the real power is in the settings panel, where you can inspect exactly what each preset includes: system prompts, tool lists, context compression rules, multi-agent capability. It's all there.

The Plugin System That Goes Deeper

Here's where Harness gets interesting. The docs say “Everything is a plugin.” That's not marketing fluff. In the beta repo, users have already built around 300 plugins in just a few days. Some are cosmetic—one modifies the entire UI, another adds a desktop pet. But others are profound.

One plugin implements long-term memory across sessions and background self-evolution. It doesn't use a vector database or RAG. Instead, it persists to local files, injects layered context, and has the LLM periodically review its own work history to compress temporary experiences into lasting knowledge. That's a fundamentally different approach to memory.

Another plugin adds ads to the interface—because why not? The point is that plugins can touch the agent's brain, its tools, its rules, and its UI. In VS Code or Chrome, plugins extend a fixed product. In Harness, plugins redefine the product itself.

Why I Built My Own Writing Agent

To test this, I created a custom Agent Preset for writing. The preset is just a folder of configuration files—system prompts, tool lists, context compression rules, and a multi-agent setup. I added a skill that tells the agent how to structure long-form articles, and another that handles headline generation.

The process was surprisingly intuitive. I could have used the cordis preset to have the agent build it for me, but I wanted to see the internals. What struck me was how much control you have. You can restrict which shell commands the agent can run, which files it can access, whether it can search the web. You can even replace the system prompt entirely.

This is a stark contrast to Codex, where you get a polished, opinionated experience. Harness gives you the raw materials and says, “You figure out what your agent should be.”

Same Model, Different Results: A Three.js Test

To see if Harness actually changes outcomes, I ran the same task—building a Three.js sandboarding game—using the same DeepSeek V4 Flash model in three different environments: Harness, Reasonix (a popular third-party agent), and Codex.

In Harness, the result was near-flawless. The player moves smoothly, passes through gates, and reaches an oasis. In Reasonix, the same model produced a game that was playable but visually crude—rough pyramids, blocky characters, and a general lack of polish. Codex, when starting from a clean workspace, did better but still felt less immersive than Harness's version.

Interestingly, when I let Codex see a previous Harness project as reference, it used that as a prototype and got closer to the Harness quality. That says a lot about context handling.

This is a single test, so I won't overclaim. But it suggests that the agent framework—tools, prompts, context organization—can materially affect what a model produces. The model is just one part of the equation.

Under the Hood: Event Logs and Replayable Sessions

What separates Harness from other agents is its underlying architecture. Instead of just saving chat messages, it records a full event stream: every turn, every step, the exact model used, the system prompt, tool definitions, raw streaming output. Even when context compression kicks in, the original history isn't deleted—it just changes what the model sees on the surface.

This is huge for debugging and reproducibility. You can replay a session and see exactly what tools were called, in what order, and what the model saw at each step. It's like having a black box recorder for your AI assistant.

There's also a clever “intent-first” agent loop. The model writes TypeScript to orchestrate multiple tool calls, but intermediate data stays in the runtime environment. Only the final result enters the model's context. That reduces token bloat and lets the agent handle complex workflows without losing track.

Why This Matters for the Industry

DeepSeek has always been about the model. With Harness, they're tackling the layer above—how to organize tools, manage context, and configure agents. This is a strategic move that could reshape the competitive landscape.

Codex is a product you use. Harness is a platform you build on. It's like the difference between buying a pre-assembled PC and getting a motherboard, CPU, and RAM with instructions.

The implications for enterprises are significant. If agents become modular infrastructure, companies can assemble their own AI workers with specific skills, tools, and guardrails—without waiting for a vendor to ship a feature. And since Harness supports third-party models (Kimi, OpenAI, Anthropic, Google—nearly 40 providers), you're not locked into DeepSeek's own models.

The plugin ecosystem is the wildcard. In the beta, 300 plugins in days. That's the kind of velocity that suggests Harness could become the WordPress of AI agents—a base that anyone can extend.

The Takeaway: Agents as Infrastructure

DeepSeek Harness isn't trying to be the next Codex. It's trying to be the thing that makes a thousand Codexes possible. By exposing the plumbing—plugins, presets, event logs—it turns agent-building into a craft, not a black box.

For developers, this is liberating. For enterprises, it's a chance to standardize on a flexible foundation. And for the industry, it's a signal that the next frontier isn't better models alone; it's better ways to deploy them.

I'm not sure Harness will win the mainstream user base that ChatGPT or Codex has. But it doesn't need to. It's building the infrastructure, and that might be the smarter play.