DeepSeek Harness In-Depth Review: An AI Coding Agent Where Everything Is a Plugin

Yesterday is destined to be written into the history of AI development. DeepSeek dropped two major surprises at once: the official release of the DeepSeek V4 Pro model, and the DeepSeek Harness Developer Preview. Just two days after going open source, it has already surged past nearly 113,000 Stars and is still climbing. What makes it so hot? The answer lies in an architecture name that many people haven't noticed yet — Codex.

What Is DeepSeek Harness: Taming the AI Horse

DeepSeek Harness (DSH for short) is a local coding agent that can read files, run commands, modify code, and search for information — functionally similar to Claude Code. But its real differentiator lies in its design philosophy.

"Harness" literally means to control and direct. If you think of an AI model as a horse, then the Harness is everything you need to ride that AI horse — the project rule files you write for the AI, the various tools you design, the task decomposition and execution order you arrange, the testing and validation workflows you set up. All of this falls under the scope of the Harness.

This concept actually has deep engineering roots. The idea of an Agent Harness originates from the concept of a "Test Harness" in software engineering — a scaffold that controls the inputs and outputs of the system under test, records behavior, and validates results. When this idea migrated to the AI agent domain, Harness came to refer to all the engineering infrastructure built around a large language model: prompt templates, tool definitions and registration, execution orchestration, permission controls, logging and auditing, and quality assurance. The industry consensus is that a model's raw capability is just the "engine," while the Harness determines whether that engine can run stably, safely, and observably in a production environment.

There's a formula worth remembering here, proposed by the industry when discussing Agent Harness: A good agent must be composed of both a Harness and a model. In other words, a powerful model alone isn't enough — you also need an engineering system that keeps the model working reliably.

Previously, DeepSeek had only open-sourced the "model" half, with no movement on the Harness side. Now it's finally complete. You can think of DeepSeek Harness as a highly customizable AI coding tool, benchmarked against Claude Code and Codex — but its ambitions go far beyond that.

Core Architecture: A Reconfigurable Runtime Where Everything Is a Plugin

If I could pick just one defining feature of DeepSeek Harness, it wouldn't be the peripheral features it provides for the model — it's the fact that the runtime itself is reconfigurable.

In the official architecture, everything from connecting to models, registering tools, and rendering logs, to the agent's execution loop of "figuring out which tool to call and what step comes next" — all of it is treated as a plugin. Model connections, tool registration, logging, approval policies, and even the main loop driving the agent are all plugins.

This Reconfigurable Runtime design draws from the microkernel philosophy in operating systems. In a traditional monolithic kernel (like the Linux kernel), the file system, drivers, and network protocol stack all run in the same privileged space — change one thing and everything is affected. A microkernel splits these capabilities into independent services, with the kernel retaining only minimal message passing and scheduling mechanisms. DeepSeek Harness follows exactly this path: the core is only responsible for plugin lifecycle management and message routing, while model connections, tool execution, approval policies, and everything else are mounted as plugins. This is in the same lineage as Eclipse's OSGi, VS Code's Extension Host, and Kubernetes' CRD+Operator pattern. The core advantage is that each module can be independently upgraded, replaced, and rolled back, dramatically reducing system coupling.

At its heart is a plugin architecture called Codex, which thoroughly implements the philosophy of "adding necessary capabilities on existing connection surfaces" rather than piling features onto a privileged monolithic core. It's worth noting that this Codex is not OpenAI's early code generation model Codex — rather, it takes the Latin root meaning of "codex" — a legal code or manuscript — implying a compilable, extensible rule system. In the context of DeepSeek Harness, Codex refers to a unified plugin registry and contract layer: each plugin declares the Capabilities it provides and the Dependencies it requires upon registration, and the runtime automatically orchestrates the loading order and performs reverse cleanup during unloading. This "declarative registration + automatic teardown" design ensures the system maintains consistency under any combination of plugins.

So models, file operations, Shell, sandbox, authorization, search, sub-agents, Web UI, and more can all be freely configured and combined. Want to swap out the search engine or connect to your company's own model service? Just change the configuration — no need to touch the framework code at all. Adding functionality to the system is as simple as plugging in a new plugin, and anything that's been registered is automatically revoked upon unloading, leaving no trace behind.

What This Architecture Means for Future AI Agent Design

The key here isn't "having lots of plugins" — it's that when you swap models, move local file operations to a different execution environment, or replace a sub-agent with a different AI, the high-level workflow design doesn't collapse along with it.

In other words, DeepSeek Harness isn't organized around a specific AI — it's organized around "the contracts of an execution platform." The next round of competition isn't just about picking a strong model — it's about having a system where "roles, permissions, records, and evaluations" survive intact even after the model is swapped out. This also explains why this version is called a "Developer Preview" — what's being built isn't an agent product, but the infrastructure itself, and it needs developers worldwide to come in and enrich the entire ecosystem.

Installation Guide: Up and Running in Minutes

Installing DeepSeek Harness is remarkably simple — just one installation command.

Before running it, make sure Node.js is installed on your machine (if not, download the easy installer from the official website). Once your environment is ready, copy the installation command, open a terminal, paste it, and hit Enter. After a brief wait, the terminal will display a URL — open it to access the web interface.

On first use, you'll need to enter your DeepSeek API Key (keep it confidential — don't leak it). Paste it in and you're done. If you've made it this far, you're already ahead of 60% of users.

Once inside the web interface, select the project folder you want the AI to work on and you're ready to go. The dialog box lets you choose the model and reasoning level, and you can also set the agent's permissions for the file system and terminal. The default is standard mode, which includes all the essential AI coding capabilities and is sufficient for most use cases. The overall experience is very similar to tools like Codex — you can think of it as a "domestic alternative to Codex."

Real-World Testing: Architecture Analysis and Website Generation

To evaluate DeepSeek Harness's actual capabilities, we ran several real tasks.

Task 1: Analyze Source Code and Generate an Architecture Diagram

The prompt asked the agent to analyze the current project repository structure and draw an architecture diagram in Mermaid syntax that "even a beginner could understand." DeepSeek Harness's own codebase is large with many modules, making it a perfect test of code comprehension. You can see the AI automatically reading files and analyzing the structure, executing at very high speed, with each step clearly displayed on the interface. The task was completed quickly, outputting Mermaid diagram syntax (it doesn't render as a graphic by default — you need to copy it into a Mermaid tool to view it).

At the bottom of the interface, you can clearly see the tokens consumed by the task, the current context usage, and the total consumption across the entire conversation. More importantly, the trace panel at the top lets you fully replay the history of every conversation and tool call — this is a key feature of DeepSeek Harness: making every run traceable.

In AI agent systems, traceability is a critical threshold for moving from experimental prototypes to production deployment. The trace panel records not just the final output, but the reasoning process at each step, tool call parameters, return results, latency, and token consumption. This aligns with the concept of Distributed Tracing (such as OpenTelemetry) in distributed systems. When an agent's output doesn't meet expectations, developers can replay step by step — just like debugging a program — to pinpoint whether the issue was caused by model hallucination, tool errors, or poorly designed prompts. This transparency is crucial for enterprise adoption — AI agents without audit capabilities can hardly pass compliance reviews.

Task 2: Build an Interactive Educational Website from Scratch

We used the exact same prompt from our previous review of "Codex + DeepSeek V3 Pro," asking it to build a website that explains the concept of "attention residuals" using interactive animations. Attention residuals are one of the core design elements in the Transformer architecture: in a standard Transformer block, the input first passes through a Multi-Head Self-Attention layer, whose output isn't directly fed to the next layer but is instead added to the original input to form a Residual Connection, followed by Layer Normalization. This design solves the vanishing gradient problem in deep networks, allowing information to flow directly to deeper layers through "shortcuts." Using interactive animations to visualize this process helps learners intuitively understand how data flows between the attention computation and the residual path.

The task was completed in about 20 minutes — not the fastest, with most of the time spent on the AI's self-checking process.

But there were two highlights: First, this task achieved a 99% cache hit rate, meaning the vast majority of costs were calculated at cache prices, resulting in extremely low actual costs. It's worth explaining what cache hit rate means here: LLM APIs typically charge based on input and output token counts. When a large portion of the prefix context in a long conversation is identical to the previous request, server-side KV Cache reuse mechanisms can skip the attention computation for those tokens and only perform inference on the new portions. DeepSeek's API supports this Prefix Caching, where cache-hit tokens are billed at extremely low prices or even for free. A 99% cache hit rate means that during 20 minutes of multi-round tool calls, the vast majority of context was reused, and the actual inference cost may have been only a fraction of the full price. This feature is particularly important for agent workflows that require frequent iteration and repeated self-checking, since each tool call carries the complete conversation history.

Second, the finished product had very accurate point-and-line connections, and like the previous Claude Opus version, it included summary and quiz features to make the knowledge presentation more complete. Judging from this example alone, DeepSeek V4 Pro paired with Harness can genuinely compete with Claude — it seems that good Harness engineering is indeed crucial to agent performance.

Conclusion: Everyone Can Assemble Their Own AI Coding Tool

The birth of something new is always accompanied by controversy. Some marvel that "this concept is incredible," while others question "who's going to bother plugging and unplugging things." But the best way to judge is to try it yourself.

DeepSeek Harness was released just one day ago, and mastering the basics already puts you ahead of 90% of users. Open source plus the "everything is a plugin" philosophy makes it extremely open, with nearly limitless possibilities. Before long, everyone might have their own unique AI coding tool, because everyone can freely assemble one to suit their needs — and that really is a pretty cool thing.