DeepSeek Harness Has 4 Modes: Standard, Code, Minimal, and Creator Explained

DeepSeek Harness has four runtime modes: Standard, Code, Minimal, and Creator. They are not four performance levels, and choosing a different mode does not make the underlying DeepSeek model inherently smarter or weaker. Instead, each mode changes the environment around the model: which tools it can use, how those tools are orchestrated, how much help the harness provides, and whether the agent is doing work, being evaluated, or modifying the harness itself.

The simplest way to remember the difference is this: Standard is for doing the work, Code is for orchestrating the work, Minimal is for measuring the model, and Creator is for changing the harness. That distinction matters because agent performance comes from more than model weights alone. The tool surface, execution loop, memory, permissions, planning system, and other harness components all affect what an agent can accomplish.

If you are comparing DeepSeek with another persistent agent environment, our guide to Hermes plugins for DeepSeek agents shows the same principle from another direction: changing the agent layer can add vision, memory, private data access, and other capabilities without replacing the base model.

Why Does DeepSeek Harness Need Four Different Modes?

DeepSeek Harness is built around the idea that an agent is not just a language model with a command line attached. The harness sits between the model and the environment, deciding what the model can see, which tools are available, how actions are executed, how sessions are recorded, and what happens across multiple steps. DeepSeek summarizes this relationship as an agent being composed from a model plus a harness.

That architecture is also why the four DeepSeek Harness runtime modes can behave so differently while using the same underlying model. Standard exposes the complete everyday agent environment. Code preserves those capabilities but changes how the model orchestrates tools. Minimal deliberately removes most harness assistance. Creator adds the ability to inspect and reshape the runtime itself.

These modes therefore should not be interpreted as a ladder from basic to advanced. Minimal is not below Standard, and Creator is not simply a more powerful Standard Mode. Each preset optimizes for a different question: How should the agent work? How should it coordinate tools? How much of the result belongs to the model itself? Or how should the agent environment be rebuilt?

1. Standard Mode — The Default Full DeepSeek Agent Environment

Standard Mode is the natural starting point when your goal is simply to give DeepSeek a job and have it complete that job. It includes the full coding-agent environment: file editing, shell access, file and web search, skills, planning, goals, subagents, and workflows. Instead of requiring you to manually decide every next step, the model can inspect the environment, act, observe the result, and continue.

That creates the familiar agent loop: inspect a repository, search for relevant files, read code, make an edit, run a command, inspect an error, and revise the result. The important capability is not any single tool in that list. It is the ability to keep moving through the environment as new information appears. DeepSeek's plugin architecture makes those capabilities composable rather than treating the agent as one fixed application; coverage of the release has described it as a plugin-composable agent runtime.

For most users, that makes Standard Mode the correct default. If you want DeepSeek to investigate a bug, understand a repository, implement a feature, inspect several files, or coordinate a normal multi-step coding task, there is little reason to deliberately remove tools before you know that they are causing a problem.

Standard Mode becomes less suitable when the purpose of the session is evaluation rather than productivity. If a model succeeds because search, planning, skills, subagents, and other harness components compensate for its weaknesses, the final result tells you how well the agent system performed. It does not cleanly tell you how well the base model would perform with minimal external assistance.

2. Code Mode — Let DeepSeek Turn Tool Orchestration Into a Program

Code Mode is the easiest of the four modes to misunderstand. It does not mean “Standard Mode, but only for coding tasks.” According to DeepSeek's current definition, Code Mode retains all Standard Mode capabilities. The change is how the tools are exposed to the model: DeepSeek can use the Code Mode SDK to combine multiple operations inside a model-generated TypeScript program.

In a normal agent loop, a complex task may require repeated exchanges between the model and individual tools. The agent searches, receives a result, decides what to read, reads it, processes that result, calls another tool, and continues. The Code Mode SDK moves some of that control flow into executable code, allowing the model to express loops, filtering, branching, and several dependent tool operations as a program instead of a long sequence of isolated tool calls.

Imagine a task that requires searching hundreds of files, filtering matches by path, reading only a subset, extracting values, and then running the same check against each result. Standard Mode can still perform that workflow, but much of the orchestration lives in repeated agent turns. Code Mode is attractive when the orchestration itself starts to resemble a small program.

search files
→ filter matching paths
→ loop through results
→ read selected files
→ process returned data
→ run follow-up operations

The important word is complexity, not “coding.” A simple edit does not automatically become better because Code Mode can generate TypeScript around it. Standard Mode can be easier to follow when only a few tools are involved. Code Mode becomes more interesting when repeated operations, structured transformations, conditional logic, or tool-result processing would otherwise create many back-and-forth model calls.

3. Minimal Mode — Remove the Harness and See More of the Model

Minimal Mode is not a lightweight option intended for slower PCs or smaller home servers. It is a deliberately constrained agent environment. DeepSeek currently defines it as a two-tool coding agent with persistent bash and str_replace_editor, removing the wider search, skill, subagent, and workflow surface available in Standard Mode.

The reason for that restriction is evaluation. DeepSeek itself used DeepSeek Harness Minimal Mode for public Code Agent benchmarks reported with V4-Flash. That usage makes the intent much clearer: Minimal is designed to reduce surrounding agent machinery when researchers want a narrower view of what the model can accomplish with a small, controlled set of tools.

This distinction matters because modern agent benchmarks can measure more than the model. A strong planner, better context assembly, repository search, specialized skills, retry policies, or subagent delegation can all change whether a task succeeds. Research on harness evaluation similarly argues that capability should be interpreted at the model-harness configuration level rather than automatically attributing the full result to model weights alone.

That gives Minimal Mode a very different optimization target from Standard. Standard asks, “What environment gives this agent the best chance of completing useful work?” Minimal asks, “What happens when we remove much of that environment and leave the model with a smaller execution surface?”

For everyday work, deliberately throwing away useful capabilities can be counterproductive. If your goal is to fix a repository as quickly and reliably as possible, Minimal Mode is usually solving the wrong problem. Its value appears when reproducibility, comparison, debugging, or understanding raw model behavior matters more than maximum task completion.

4. Creator Mode — Use DeepSeek Harness to Change the Harness

Creator Mode changes the object you are working on. Standard Mode primarily uses an agent environment; Creator Mode is designed for creating and experimenting with that environment. It includes the capabilities of Standard Mode while adding runtime inspection, in-memory plugin experimentation, and guidance for authoring custom presets.

This follows directly from the architecture underneath DSH. DeepSeek describes models, tools, skills, sessions, sandboxes, storage, loops, scheduling, and even the UI as plugins that can be selected, replaced, or recomposed. The Cordis kernel manages plugin mounting, unmounting, and dependencies, which means extending DSH does not necessarily require modifying a privileged monolithic agent core. The broader design is why the project's “everything is a plugin” claim matters more than the existence of four presets by itself.

Suppose you wanted an agent specifically for managing a home server. Its useful environment might include shell access, restricted filesystem permissions, Docker operations, infrastructure documentation, monitoring tools, and a few specialized skills. That combination is not identical to a generic coding agent. Creator Mode is designed around experimenting with capabilities like these and combining them into a reusable agent preset.

inspect current runtime
→ add or test plugins
→ observe services and dependencies
→ adjust the composition
→ save a specialized preset
→ launch that environment again

This makes Creator Mode more specialized than Standard Mode, but not automatically better for daily use. If you simply want DeepSeek to change three files and run a test suite, runtime inspection and preset authoring add little value. Creator becomes useful when the question changes from “Can the agent perform this task?” to “What capabilities should this type of agent have?”

Standard vs Code vs Minimal vs Creator: What Actually Changes?

The biggest mistake is arranging the four modes into a progression such as Minimal → Standard → Code → Creator. That suggests that each step simply adds power. The actual relationship is multidimensional: Standard emphasizes general execution, Code changes orchestration, Minimal deliberately reduces assistance, and Creator exposes the harness itself as something to configure.

The comparison becomes clearer when the modes are evaluated against the same questions rather than feature count. Standard and Code both retain the broad agent environment, but Code changes how multi-step tool work can be expressed. Minimal intentionally moves in the opposite direction by shrinking the tool surface. Creator starts from Standard and adds capabilities for runtime composition rather than simply adding another everyday productivity tool.

This is also why two tests using the same DeepSeek model can produce different results if their harness configurations differ. Early analysis of DSH has already highlighted the importance of recording the model and harness configuration rather than comparing only model names. Tool access, permissions, context construction, agent loops, and other runtime choices can all change the path the model takes through a task.

Which DeepSeek Harness Mode Should You Actually Use?

For most normal work, start with Standard Mode. It exposes the broad set of capabilities DSH was designed to coordinate and lets you discover whether a more specialized runtime is even necessary. Starting in Minimal merely because it sounds lighter can remove exactly the capabilities that make an agent useful.

Switch to Code Mode when the tool workflow itself has become complex. Repeated searches, loops over many files, filtering tool results, structured transformations, and conditional actions are stronger reasons to use Code Mode than the fact that your task happens to involve software development.

Use Minimal Mode when the question is about the model rather than maximum productivity. It is the better fit for controlled comparisons, benchmark reproduction, prompt experiments, and situations where you want to know whether success depends on the model or on a richer harness around it.

Use Creator Mode when you want to change what the agent environment is. It is intended for plugin experiments, specialized presets, and developers treating DeepSeek Harness as infrastructure for constructing a new agent rather than simply operating the default one.

If your broader goal is building reusable agent capabilities around private data rather than modifying DSH itself, our guide to AI agent skills for local knowledge bases explains how skills can package repeatable retrieval, parsing, evidence, and knowledge workflows on a self-hosted system.

Plan Mode Is Not a Fifth DeepSeek Harness Runtime Mode

There is another DSH feature that makes the terminology confusing: Plan Mode. It sounds like it belongs beside Standard, Code, Minimal, and Creator, but DeepSeek's current architecture treats it differently. The four modes above are runtime presets or compositions. Plan Mode is an optional per-agent planning state that changes guidance supplied to the model.

DeepSeek's subsystem documentation explicitly describes Plan Mode as soft guidance. While active, a planning-related prompt section is included in model requests. Sandbox mode and approval policy independently enforce restrictions, and the agent loop itself does not depend on Plan Mode.

That gives the two concepts different jobs. Standard, Code, Minimal, and Creator answer questions about runtime composition: which capabilities exist and how the agent operates. Plan Mode answers a behavioral question: should the agent remain in a planning-oriented collaboration state before execution proceeds?

Standard / Code / Minimal / Creator
= runtime composition

Plan Mode
= planning and guidance state

So if someone asks whether DeepSeek Harness has four modes or five, the useful answer is: DSH currently ships four primary runtime modes, while Plan Mode is a separate optional planning mechanism rather than a fifth peer runtime preset.

The Four Modes Reveal What DeepSeek Harness Is Actually Building

The most interesting part of DSH is not that it gives users four buttons to choose from. The modes expose four different layers of agent engineering. Standard focuses on execution. Code focuses on orchestration. Minimal focuses on evaluation. Creator focuses on composition. Together they show that DeepSeek is treating the harness as an active part of agent behavior rather than invisible glue around the model.

This matters because improvements in agent systems do not have to come only from training a larger model. Changing tool presentation, context management, execution policies, retry behavior, skills, memory, or runtime composition can change what the same model is able to accomplish. If you are interested in expanding those capabilities rather than rebuilding the whole runtime, the DeepSeek and Hermes plugin stack is another example of how the surrounding agent system can add entirely new abilities.

That also means the four presets should be treated as starting configurations rather than universal answers. A benchmarking environment wants less assistance. A production agent may want more tools and stricter permissions. A complex tool workflow may benefit from programmatic orchestration. A specialized home-server agent may eventually deserve its own preset.

DeepSeek Harness is still in developer preview, and DeepSeek says its core plugins and APIs will continue to evolve. The exact presets and interfaces may therefore change. But the architectural distinction is already useful: when an agent behaves differently, do not look only at the model. Look at the harness that determines how that model can act.