Deep Dive into DeepSeek Harness: The Ambition to Build Infrastructure, Not Just an Agent

An Overnight Sensation: The Developer Preview

DeepSeek has finally shipped its own Agent product, and it's called Harness. According to a hands-on review by Bilibili creator Keluo Mao, the project had already climbed to 37,000 GitHub stars by the time the video was published — a growth rate that can only be described as wild.

But the hype comes with real controversy. Fans say it represents the future of AI agents; critics ask "what on earth is this thing?" That sharp divide actually makes sense — this is a product built around a clear design philosophy, not one trying to please everyone. To understand the controversy, you first need to understand what Harness actually is.

Not a Terminal Agent — Agent Infrastructure

Why is it called Harness (as in a harness or framework), and not Code or Build? Because DeepSeek isn't building a terminal Agent application. It's building Agent infrastructure.

In AI development, an Agent is an AI system that can autonomously perceive its environment, make decisions, and execute actions. Today's mainstream Agent products — GitHub Copilot Workspace, Cursor, Devin, and others — use closed architectures. Vendors pre-define which tools the Agent can call, what environment it runs in, and how tasks are orchestrated. That delivers a consistent user experience with a low barrier to entry, but it sacrifices flexibility: developers can't deeply customize how the Agent behaves. DeepSeek's decision to build "infrastructure" rather than an "end-user application" is a deliberate choice at the opposite end of that spectrum.

The core formula on the official site is: Agent = Model + Harness. In other words, every coding assistant or code Agent you use day-to-day is essentially a "shell" wrapped around a model. That shell contains a whole stack of mechanisms: tool calling, sandbox environments, task scheduling, sub-agents, workflows, and more.

Historically, that shell was locked down by vendors — tools, sandboxes, and schedulers were all hidden behind the scenes, invisible and unchangeable. DeepSeek Harness takes a far more aggressive stance: break everything into plugins. Every capability can be plugged in, pulled out, or swapped by you. This is a shift in mindset from "black box" to "composable system," and it's what fundamentally sets Harness apart from everything else on the market.

Hot-swapping originally comes from hardware — replacing components without shutting the system down. In software engineering, it means dynamically loading, unloading, or replacing modules at runtime without restarting the whole system. Traditional Agent frameworks bind their tool chains statically at startup; once running, nothing can change. Harness abstracts every capability into an independent plugin and lets the Codex kernel manage their lifecycle, enabling dynamic composition at runtime. Think of it like an OS driver model or browser extension system — except applied to the capability layer of an AI Agent.

The Codex Kernel: Teaching an Agent to Self-Evolve

The heart of Harness is called the Codex kernel. According to Keluo Mao, its author has joined DeepSeek and published an 88-page paper laying out the design in full.

The kernel's philosophy is one of extreme restraint — it handles only plugin loading, downloading, and dependency management, and nothing else. This is the "microkernel" pattern in software architecture, with classic examples like the Mach and L4 kernels in operating systems: they handle only the bare minimum (inter-process communication and memory management) and push everything else — file systems, network protocols — out to independent services. The payoff is high stability (a tiny core means fewer failure points) and strong extensibility (new functionality arrives as plugins, not kernel patches). The fact that the paper runs 88 pages signals this is not a quick engineering hack; it's an architecture grounded in rigorous theoretical work.

And that restraint is exactly what unlocks a critical capability: the Agent can swap plugins at any point during a run without its runtime state collapsing.

What does that actually mean? Picture this: an Agent is mid-task, realizes it's missing a capability, builds a plugin on the spot, attaches it to itself, and keeps going. As the video author puts it: "This isn't a tool — it's self-evolution." Runtime hot-swapping like this is something traditional closed Agent frameworks can't do, and it's the most imaginative part of what Harness offers.

Four Run Modes Explained: Really Four Preset Templates

Harness ships with four run modes. Don't let that intimidate you — they're essentially four preset configurations.

Standard Mode: Ready Out of the Box

Everything included: file read/write, Shell, search, sub-agents, workflows. Friendliest for newcomers. When in doubt, pick this one.

TTC Mode: Token-Efficient but Hard to Debug

Has the model write a TypeScript snippet that compresses multiple tool calls into a single execution. Great for saving tokens; brutal when something goes wrong. Not recommended for beginners.

Tokens are the basic unit LLMs use to process text, and every API call is billed by the token. In Agent scenarios, a complex task can require dozens of tool calls, each carrying the full context along for the ride — token costs compound fast. TTC (Think-Then-Code) mode addresses this by having the model "think it through first," then generate a TypeScript script that executes multiple operations in one shot rather than interactively step by step. It's similar to the performance difference between batch processing and row-by-row processing in a database. The trade-off: when something breaks, you're staring at a wall of logic rather than an individual step, and debugging difficulty goes up sharply.

Minimal Mode: Testing Raw Capability

Just two tools: a Shell (Bus) and a file editor. Mainly useful for benchmarking a model's baseline capabilities. The author's candid take: "For day-to-day work, you'll want to throw your laptop out the window."

Creation Mode: The Real Killer Feature

This is the capability worth paying attention to. It lets the Agent inspect its own plugin inventory, and when it finds a gap, build a new plugin on the fly and attach it. You can literally say: "Build me a safe audit mode that reads code but never modifies files" — and it will construct that for you. The idea of "generate capabilities on demand" transforms the Agent from an executor of fixed tools into a builder that can extend itself. That's the most compelling thing Harness does.

Creation Mode touches the frontier of current AI research: tool making. Since 2023, several academic papers have explored letting LLMs autonomously create their own tools — the LATM (LLMs As Tool Makers) framework being a notable example. The core intuition is that instead of pre-loading an AI with an exhaustive toolbox, you give it the meta-ability to build tools as needed. Harness's Creation Mode is an engineering realization of that idea. Worth noting: this also raises real security questions. An Agent that can expand its own capabilities — how do you ensure it doesn't "create" something dangerous beyond its intended scope? That's likely a problem future versions will need to tackle head-on.

One more thing worth mentioning: Harness doesn't lock you into DeepSeek's own models. You can connect any vendor's model by setting a custom base URL. For a product positioning itself as infrastructure, that openness is the only stance that makes sense.

A High Bar: This Is a Product for Developers

After all the highlights, a word of honesty: this thing is genuinely unfriendly to everyday users. The terminology is dense, the barrier to entry is high, the features are rough, the experience is raw — nearly every step is pushing non-developers away.

Right now, this is a developer preview. It needs developers around the world to come in, find the gaps, and build the ecosystem. From that angle, 37,000 stars looks more like a call to collaborative community building than a consumer product launch metric. The "open source first, ecosystem second, commercialization later" path is well-trodden in developer tooling — Kubernetes, Docker, and VS Code all walked a version of it. The key question is whether it can attract enough high-quality contributors early on to create a positive network effect.

Conclusion: Exploring the Unknown

Stepping back: DeepSeek may never have intended to build a consumer product at all. They seem like a team chasing a "geek product" vision. Their slogan is "Explore the unknown" — and in a way, that phrase explains everything about what Harness is.

Whether Harness becomes something legendary is too early to call. But its willingness to crack open the Agent's shell entirely and hand the definition of it to the community does offer a genuinely different path from the mainstream closed-product approach. For developers who care about the underlying architecture of Agents, it's worth spinning up and running — after all, it opens in a browser tab.