DeepSeek Harness in Practice: Deep Dive into the "Everything is a Plugin" Agent Framework

What Exactly is DeepSeek Harness

DeepSeek's newly released Agent framework, DeepSeek Harness, is essentially a localized agent tool that competes in the same space as Codex, Worker Buddy, and similar tools. To understand its core, we first need to understand the two things all local Agent tools are doing.

Agent frameworks are one of the most active technical directions in the AI application domain today. Unlike traditional single-turn Q&A, the core idea behind Agent frameworks is to give AI the ability to autonomously plan, call tools, and perform multi-step reasoning. Task Orchestration is a key technology in Agent frameworks, borrowing from the orchestration pattern in microservice architecture—using a central scheduler to decompose complex tasks into multiple subtasks, completing them step by step according to dependencies and execution order. This pattern solves the problem of limited single-inference capability in large models, enabling AI to handle work far exceeding its single context window through multiple rounds of calls and intermediate state management.

First, they're installed on your local machine, so they naturally have access to local resources—reading and writing local files, executing local applications—all trivially easy operations. Second, and most critically, the core job of all Agent tools is task orchestration. When you submit a task, the tool doesn't just throw it directly at the large model. Instead, it decomposes the task at an intermediate layer, breaking it into smaller subtasks, calling the large model sequentially in a specific order, and finally integrating the results back to you.

The fundamental difference between various local Agent tools lies precisely in how they decompose tasks. And DeepSeek Harness reveals its philosophy with one official tagline: "Everything is a Plugin."

The "Everything is a Plugin" Design Philosophy

What is plugin thinking? Here's an intuitive analogy: when you need to read more files, you plug in a USB drive; when you don't need it, you just pull it out and toss it. DeepSeek Harness deconstructs its models, tools, and scheduling entirely into plugins that can be freely swapped and flexibly recombined.

This "Everything is a Plugin" design philosophy originates from Plugin Architecture in software engineering, a pattern that has been widely validated in well-known products like Eclipse IDE, WordPress, and VSCode. Its core principle is decoupling system functionality into independent, hot-swappable modules, where each module communicates with the main system through standardized interfaces. The advantage of this architecture lies in its extremely high extensibility and flexibility—developers can add or remove features without modifying the core system. For Agent tools, plugin-based design means model selection, toolsets, and execution strategies can all be independently configured and replaced, adapting to ever-changing task scenarios.

This means Harness is more like a highly flexible agent tool—you can choose different modes based on task characteristics, or even create different combinations. This design delivers a fundamentally different user experience compared to traditional Agent tools, and places higher demands on the user's programming experience.

Quick Start: Installing and Configuring DeepSeek Harness

To its credit, DeepSeek Harness has an extremely low barrier to entry. A mature product should be this simple—if a product requires taking a course just to use it, that's a failure in itself.

Environment Setup

Harness uses Codex (a TypeScript service) under the hood, so you only need to install a Node.js environment. Node.js is a JavaScript runtime environment based on the Chrome V8 engine that allows JavaScript to run on the server side, outside the browser. It's recommended to install the latest LTS version (Long Term Support, which typically offers 30 months of maintenance and is the most stable and reliable). If you need to frequently switch Node.js versions, consider using NVM (Node Version Manager), the de facto version management standard in the Node.js ecosystem. It achieves multi-version coexistence and quick switching by modifying the system PATH variable:

• nvm install 24.16.0 — download a specific version
• nvm use 24.16.0 — switch to a specific version
• node -v — verify successful installation

One-Command Launch

Once the environment is ready, you don't even need to download or install anything—just run it directly via the npx command. npx is a package executor built into npm 5.2+, and its unique feature is the ability to execute remote npm packages without global installation—npx temporarily downloads the package to a cache directory, executes it, and then releases it, greatly simplifying the distribution and usage of command-line tools. The first execution will download some components and be slightly slower; once complete, it exposes a local service address that you can access directly in your browser.

On first visit, you'll need to enter an API Key to call the DeepSeek large model backend. You'll need to register and log in to the API platform on DeepSeek's official website, create an API Key, and enter it.

Special Note: Alongside the Harness launch, DeepSeek also applied a "price increase buff"—API call fees have officially gone up, and by no small margin. This means you need to be more deliberate in your usage: what mode to switch to for different tasks, and how to work fastest, most accurately, and most cost-efficiently—these questions that reflect programming experience will become increasingly important.

Workspace Management

Harness organizes your conversations and tasks in the form of Workspaces, essentially categorizing tasks like files. It's recommended to create a separate workspace for each type of task. After specifying a local working directory, all your operations will revolve around that directory. For example, if you ask it to "list files in the current directory," you don't need to specify a path—it will automatically read the local directory corresponding to the current workspace.

Core Highlight: Three Working Modes of DeepSeek Harness Explained

The most fundamental difference between DeepSeek Harness and other Agent tools lies in its working modes (think of them as Agent Presets). Three common modes are provided by default: Standard Mode, PTC Mode, and Rally Mode, plus a Creation Mode for building new modes.

Rally Mode: Testing Model Limits

Rally Mode provides only a dual-tool coding Agent with Batch and STR Replace Editor. Simply put, it does things in a rather "straightforward" way—it can only execute local commands and file operations, with the toolset mainly consisting of a Bash tool (executing local commands, reading files, checking directories, etc.).

The intent behind this minimalist design is to test the large model's limit under pressure. Just like testing an off-road vehicle's extreme performance by stripping away non-core features like cameras and radio, Rally Mode removes a large number of plugins, keeping only the most essential capabilities to better benchmark the model's peak performance.

Its execution characteristic is "heads-down work"—almost no intermediate reports, just direct results. Since it doesn't need to search through a large set of tools, it requires fewer input tokens and simpler execution.

Standard Mode: One Step at a Time

Standard Mode works similarly to other Agent tools: it calls the large model to determine which tools are needed, then calls those tools to gather information, feeds it back to the model for integration, and completes the task step by step.

Its advantage is high fault tolerance—if a step goes wrong, it can go back and handle it, making the process relatively flexible. Since it searches through many local plugins (search plugins, file read/write plugins, etc.), its input token count is relatively high. However, Harness does an excellent job of token optimization: cache hit rates are very high, meaning actual costs are relatively low. The caching mechanism here refers to the fact that when consecutive requests contain large amounts of repeated context (such as system prompts, tool descriptions, and other fixed content), the API provider can reuse previously processed KV Cache, calculating those tokens at a lower price. DeepSeek's cached token price is typically about one-tenth of the normal input token price, so although Standard Mode's total token count looks high, actual costs may be much lower than expected.

Standard Mode is better suited for complex tasks, such as scenarios requiring web searches for information, writing complex reports, and other multi-step workflows.

PTC Mode: Programmatic Task Calling

The core of PTC (Program to Call) Mode is compiling the task into a TypeScript program on the backend, using code to drive the large model to solve the task. It's like holding a meeting before a marketing campaign to plan out all processes, forming a "battle guide" that everyone follows during execution.

PTC Mode represents an important technical approach in the AI Agent field—Code-as-Policy, which uses code rather than natural language to express execution plans. The core idea of this method is to concretize the model's reasoning results into executable code. TypeScript was chosen as the target language for good reason: it has static type checking capabilities that can catch logical errors at compile time; as a superset of JavaScript, it can seamlessly call the massive tool libraries in the Node.js ecosystem. The essential trade-off of this pattern is: paying a higher planning cost upfront in exchange for determinism and efficiency during the execution phase.

PTC Mode's advantages are fast execution and more precise logic; its disadvantage is weaker fault tolerance—once a task errors out, you need to go back and adjust the entire execution script before re-running, which can end up consuming even more resources in the round trip.

PTC Mode is better suited for high-frequency, logically stable tasks. For example, tasks like "pull news at a scheduled time every day"—not very difficult but executed frequently—can be orchestrated once and then directly executed each time.

Practical Comparison: Token Consumption Tests Across Three Modes

To intuitively understand the differences between the three modes, we ran a comparative test using the comprehensive task of "generate virtual user information → sort by first letter of name in memory → write to file." Here you need to understand the concept of tokens: a Token is the basic billing unit for large models, with one token roughly corresponding to 4 English characters or 1-2 Chinese characters. Input tokens (Prompt Tokens) and output tokens (Completion Tokens) are typically priced separately. The token consumption data tells a clear story:

Mode	Input Tokens	Characteristics
Rally Mode	Fewer	Heads-down execution of Python script, no reports
Standard Mode	41K	Step-by-step scheduling with process feedback
PTC Mode	62K	Errors require script re-orchestration
Safe Review Mode (custom)	28K	Restricted permissions, most token-efficient

As you can see, PTC Mode actually consumed the most tokens (62K) due to repeated script adjustments mid-process, while a carefully designed custom mode used only 28K.

Creation Mode: Build Your Own Custom Agent

The most innovative aspect of Harness is its Creation Mode—you can describe requirements in natural language to create entirely new working modes. For example, creating a "Safe Review" mode with a simple requirement: only review local code, no file modification or script execution allowed.

When executing the previous task with this restricted mode, since it lacks file-writing permissions, the Agent proactively asks the user, offering three options: provide a Python script guide, output the generated content directly in the chat, or simply explain the limitations. This "Human-in-the-Loop" interaction pattern is a core concept in AI system design—introducing human judgment and decision-making at critical nodes in automated workflows. When an Agent encounters operations beyond its permission scope, ambiguous instructions, or scenarios requiring value judgments, it proactively pauses and requests human intervention rather than blindly executing or failing outright. This design strikes a balance between safety and efficiency, preserving the high efficiency of automation while avoiding catastrophic errors through human oversight, allowing users to deeply participate in the task processing.

Key Takeaway: Choosing the Right Mode Matters More Than Choosing the Right Model

The biggest insight DeepSeek Harness offers us is: An Agent's capability depends not only on how smart the large model is, but more on what kind of working environment you assign to it.

Through the token data comparison, we can clearly see that for completing the same task, choosing the appropriate mode can dramatically reduce costs—from 62K to 28K, a difference of more than half. Against the backdrop of rising API fees, this ability to "match mode to task" is a tangible competitive advantage.

This also points to the future direction of large model applications: the mining of basic application scenarios is mostly done, and various product forms have already taken shape. The early stage is about who has better ideas; the later stage is about who can execute better. DeepSeek Harness, with its flexible "Everything is a Plugin" architecture, provides the tooling-level possibility for "using AI more precisely."