DeepSeek Harness: what it is and how to install the AI agent

DeepSeek Harness is an open environment for running AI agents on a computer. Unlike a regular chat with an AI model, Harness can work with project files, run terminal commands, modify code, verify results, use tools, and delegate individual tasks to subagents. DeepSeek Harness itself is not a language model: you need to connect DeepSeek, OpenAI, or another supported provider to it.

Installation is quite simple: install Node.js, run one command in the terminal, open the local web interface, connect an API key, and select a working folder. But there is an important caveat: as of September 2, 2026, DeepSeek Harness officially has the status of developer preview. The developers explicitly warn about possible breaking changes and do not consider the product production-ready.

What DeepSeek Harness is in simple terms

The term agent harness can be translated as “AI agent execution environment.” The language model is responsible for reasoning and decision-making, while the Harness provides it with tools to execute those decisions.

In simplified terms, the process looks like this:

  1. You select a working folder — a Workspace.
  2. You set a task in plain text.
  3. DeepSeek Harness sends it to the selected language model.
  4. The model examines the files and decides which tools to use.
  5. Harness reads or modifies files, runs commands, and receives results.
  6. The model analyzes the result and continues working if necessary.
  7. You get not just text advice, but an actually completed task.

That is why Harness is closer to Codex, Claude Code, and other agent environments than to a regular web chat. If you are interested in the concept of such systems itself, the CenterAI blog has a separate section about AI agents and assistants.

What DeepSeek Harness can do

In its standard configuration, the agent can work not only with dialogue but also directly with a local project. For example, you can ask it to:

  • examine the repository structure;
  • find errors in code;
  • modify several files;
  • run tests or a build;
  • compare configuration files;
  • analyze Markdown, JSON, CSV, and other text data;
  • create a work plan;
  • delegate parts of a large task to subagents;
  • create custom Harness extensions and configurations.

The DeepSeek Harness architecture is built on the principle of “everything is a plugin”: model adapters, tools, session handling, and many other components are connected as plugins. This makes Harness interesting not only as a ready-made AI agent, but also as a platform for creating custom agent systems.

What you need to install DeepSeek Harness

For a regular npm launch, you do not need to download the source code from GitHub yourself. You need three things:

  • a computer running Windows, macOS, or Linux;
  • a compatible version of Node.js;
  • an API key from at least one language model provider.

The DeepSeek Harness source repository specifies the requirement Node.js 22.19 or later in the 22 branch, or Node.js 24+. At the time of checking, the current Node.js LTS version is 24.20.0, so for a new installation it is easier to use Node.js 24 LTS.

You can download Node.js from the official website: Node.js Download.

A separate graphics card is not required to run Harness with cloud APIs: the model itself runs on DeepSeek, OpenAI, or another provider's servers. But it would be wrong to say that the product will run on “absolutely any computer.” Node.js, the terminal, agent tools, your tests, and applications still run locally.

How to install DeepSeek Harness

Step 1. Install Node.js

Download the current LTS version of Node.js from the official Node.js website and complete the standard installation for your operating system.

After installation, open PowerShell, Windows Terminal, Terminal on macOS, or a Linux terminal and check the version:

node -v

It is preferable to use Node.js 24 LTS.

Step 2. Launch DeepSeek Harness

The official npm launch method consists of just one command:

npx @deepseek-ai/dsh web

On the first launch, npx will download the required packages. After launch, DeepSeek Harness will start a local Web UI. By default, it runs at:

http://127.0.0.1:3080

When launched locally, the browser usually opens automatically.

Official project repository: DeepSeek Harness on GitHub.

Official Web UI guide: DeepSeek Harness — Use the Web UI.

Step 3. Select a working folder

After the first launch, you need to create or select a Workspace — a directory the agent will work with.

For example, this could be:

  • a website project folder;
  • a Python application repository;
  • a Telegram bot folder;
  • a separate directory with documents and configurations;
  • a test copy of a project.

In the new Web UI, message input is unavailable until a Workspace is selected.

How to connect DeepSeek

If you want to use DeepSeek's own models, open Settings → Models. The interface already includes a built-in DeepSeek provider — just paste the API key and save the settings.

The API key is created in the official dashboard: DeepSeek Platform — API Keys.

API documentation: DeepSeek API Docs.

The standard Harness catalog includes, among others:

  • DeepSeek V4 Flash — a cheaper option for a large number of everyday tasks;
  • DeepSeek V4 Pro — a more expensive model for tasks requiring more complex reasoning.

Both models support tool calling and are intended, among other things, for agent scenarios. It is best to check current specifications and pricing directly on the Models & Pricing page, as pricing may change.

How to connect OpenAI to DeepSeek Harness

Using DeepSeek models specifically is not required. Harness includes a catalog of other providers, including OpenAI.

To connect OpenAI:

  1. Open Settings → Models.
  2. Click Add provider.
  3. Select OpenAI.
  4. Enter your OpenAI API key.
  5. Save the settings.
  6. Select the desired model in the model switcher for a new session.

For standard OpenAI, you do not need to manually specify a Base URL: Harness uses the built-in provider catalog, where the endpoint, protocol, and models are already defined.

You can create an API key in OpenAI Platform.

Important: ChatGPT and OpenAI API subscriptions are billed separately. Having ChatGPT Plus or Pro alone does not provide a paid API balance.

In the current OpenAI lineup for agentic and programming tasks, you can use GPT-5.6 Luna as a cost-effective option, GPT-5.6 Terra as an intermediate one, and GPT-5.6 Sol for more complex programming and reasoning. The specific list in Harness depends on the installed catalog and model availability for your API account.

Can I connect another API

Yes. There is a separate item in the models section Add a custom provider. It is intended for corporate gateways, self-hosted models, and other OpenAI-compatible services.

For this type of connection, specify:

  • Provider ID;
  • display name;
  • Base URL;
  • API protocol;
  • API key;
  • one or more models.

This is a more advanced scenario. OpenAI and other providers already present in the Harness catalog are better added through the standard Add provider, rather than through Custom Provider.

Which access mode to choose

This is one of the most important DeepSeek Harness settings. The AI agent can run real commands and modify real files.

At the sandbox level, Harness supports three filesystem modes:

  • read-only — no file modifications;
  • workspace-write — write access within the Workspace;
  • danger-full-access — removes filesystem restrictions.

The default Web UI configuration uses the preset Workspace Write. This is the one you should keep for most everyday tasks.

Workspace Write

The agent can modify files within the selected Workspace. A confirmation mechanism is used for actions that require broader permissions.

This is a sensible option for development and everyday work.

Danger Full Access

In this mode, filesystem isolation is disabled. In the standard Harness preset, it is also linked to an execution policy without constant confirmation prompts.

Do not enable Full Access just for convenience. For experiments with this mode, it is better to use a separate virtual machine, container, or other isolated computer.

There is another important nuance: Harness sandbox mode primarily regulates filesystem changes. Network and process visibility are not part of this particular restriction model. We wrote more about the principles of least privilege for AI agents in the article “AI Agent Security: How to Restrict Access to Email, CRM, and Data”.

Standard and Creator: how agent modes differ

In addition to file permissions, DeepSeek Harness uses agent presets — sets of tools and settings for a specific agent.

Standard

This is the main mode for normal project work. The agent gets tools for working with files, the terminal, planning, and task delegation.

Standard is the best place to start getting familiar with Harness.

Creator

Creator is designed to modify and extend the agent environment itself. The Harness architecture allows you to build custom agent presets and plugins, while Creator gives the agent tools to work with this system.

This is where Harness's main architectural difference becomes apparent: instead of a rigid set of capabilities, almost the entire system is assembled from plugins.

If you are interested in a similar concept for extending AI tools, you can compare it with OpenAI Codex's approach in the guide “Skills and Plugins in Codex: how to choose, install, and use them in your work”.

How to use DeepSeek Harness in practice

After connecting a model and selecting a Workspace, you can give the agent regular tasks in Russian.

For example:

Review the entire project. Do not change anything yet. Find architectural issues, potential bugs, and code duplication. Create a prioritized task list.

After the analysis, you can continue:

Fix the first task. Do not touch the rest of the project. After making changes, run the existing tests and check the result.

This approach is usually safer than the command “fix everything” because the result is easier to control and roll back.

What are subagents in DeepSeek Harness

Harness supports delegating work to child agents. The main agent can pass a separate task to a subagent and then use the result.

For example, a large application review can be divided into:

  • backend audit;
  • frontend audit;
  • security issue search;
  • test review;
  • documentation analysis.

But it is important not to attribute to Harness what the official architecture does not guarantee: a subagent does not necessarily automatically receive a separate physical copy of the entire project. Harness supports different subagent mechanisms, and the degree of their filesystem isolation depends on the specific provider and configuration.

If several agents need to edit one repository simultaneously, it is safer to deliberately separate their working directories, Git worktrees, containers, or use another isolation mechanism.

What is Trajectory

Trajectory — a detailed view of session events. It shows not only the model's final response, but also the agent's actions: tool calls, call results, steps, and boundaries of individual turns.

In the interface, you can examine, for example:

  • which tool was called;
  • its input and output data;
  • how long the action took;
  • token usage information;
  • the sequence of agent actions.

For debugging agentic systems, this is much more useful than regular chat history: you can see not only the wrong outcome, but also where the agent started following the wrong trajectory.

How session branching works

DeepSeek Harness supports session forks. A new branch receives the source session's history up to the selected completed point, after which it can be continued independently.

This is useful if the first half of a complex task was completed correctly but the agent then chose an unsuccessful solution. Instead of restarting the entire process, you can create a branch from the successful point and give a different instruction.

But a session fork is primarily a branch of the agent history. It should not automatically be considered the creation of a separate copy of the project files.

Can I install plugins

Yes. DeepSeek Harness allows you to connect additional plugin bundles. The official documentation uses a command like this:

dsh plugin –profile web add PACKAGE_NAME

Plugins can add new tools, interface components, and agent behavior.

But they should be treated roughly the same way as installing a regular program from an unknown source. The official documentation specifically warns that installing some packages may allow their code to run on the computer itself and outside the agent sandbox.

Therefore, before installing a third-party plugin, it is advisable to:

  • review the source code;
  • check the author and repository;
  • look at current issues;
  • do not run unverified code on a machine with work secrets;
  • use a separate environment for experiments.

How safe is DeepSeek Harness

DeepSeek itself states this quite clearly: Harness is an experimental developer-preview product, has not undergone a security audit and should not be considered production-ready.

It can execute model-generated commands, access the network, work with processes, files, and credentials provided to it. A model error, incorrect configuration, or malicious plugin could potentially lead to file changes or data leaks.

Minimum rules:

  • keep Workspace Write instead of Full Access;
  • make backups;
  • do not give the agent unnecessary secrets;
  • do not open your entire home directory to it unless necessary;
  • do not install unknown plugins;
  • use a VM or container for risky experiments.

Who should try DeepSeek Harness

In its current form, Harness is particularly interesting for developers and technical specialists who want not just to talk to a model, but to give it a controlled set of real tools.

Typical use cases:

  • code development and refactoring;
  • diagnosing existing projects;
  • automating repetitive technical tasks;
  • experiments with multi-agent systems;
  • building custom tools for an AI agent;
  • exploring agent harness architecture.

For critical production processes, it is still more sensible to view the product as an experimental platform rather than a ready-made autonomous executor.

In short: installing DeepSeek Harness from scratch

  1. Install Node.js 24 LTS.
  2. Open the terminal.
  3. Run npx @deepseek-ai/dsh web.
  4. Open the Web UI if the browser did not open automatically.
  5. In Settings → Models add DeepSeek or, for example, OpenAI.
  6. Select Workspace.
  7. Keep Workspace Write for regular work.
  8. Select a model.
  9. Start a new session and set the first task.

For the first test, it is best to use a copy of a small real project: first ask Harness only to analyze it, then fix one specific issue and verify the result. This quickly makes it clear where the agent actually saves time and what permissions it needs.

If the goal is not to experiment with Harness but to create a working AI agent for a specific business process, you can discuss the architecture and MVP with CenterAI.

FAQ

Is DeepSeek Harness free?

The project itself is published as open source under the MIT license. But requests to DeepSeek, OpenAI, and most cloud models are charged according to the relevant API rates.

Is DeepSeek required?

No. Harness supports other providers. The official documentation explicitly lists OpenAI and Anthropic, and also provides for connecting a custom provider.

Do I need a powerful graphics card?

For working with a cloud API, no. The model runs on the provider's server. However, commands, tests, project builds, and other local processes run on your computer.

Can DeepSeek Harness be installed on Windows?

Yes. Harness architecture provides local sandbox mechanisms for Linux, macOS, and Windows. At the same time, the developers note differences in the level of isolation between platforms, so the sandbox cannot be considered absolute protection.

Can I connect OpenAI?

Yes. Open Settings → Models → Add provider → OpenAI and add an API key. You do not need to create a Custom Provider for standard OpenAI.

Does Harness replace a developer?

No. It can independently perform multi-step technical actions, but the result still requires task definition, permission control, and human review of critical changes.

Sources and verification

Last verified: 02.09.2026

Leave a Reply

Your email address will not be published. Required fields are marked *