跪拜 Guibai
← Back to the summary

The Heaviest Word in "DeepSeek Harness" Isn't DeepSeek

On August 13, 2026, DeepSeek released DeepSeek Harness v0.1 (dsh for short), and open-sourced it at the same time.

With "DeepSeek" in the name, many people think it's another new model. After reading the first lesson of blogger "轩辕的编程宇宙"'s tutorial, I figured out the key point: the focus isn't DeepSeek at all, it's Harness.

This post retells it in my own words, trying to avoid jargon. If you've never touched Agents, you should still be able to follow.

Original link: What exactly is DeepSeek Harness? | Lesson 1


1. First build a picture: a person locked in a room

Imagine you've hired an extremely smart person, but they're locked in a room with no windows.

They can understand every word you say, and can write anything. But you can only slip notes through the door crack, and they slip written notes back out.

This is exactly where large models are today.

It's startlingly smart, but it actually only does one thing: based on the text you hand it, write the next piece of text.

This point matters a lot, because many people's misunderstandings about AI start here. They think it can "see" web pages, "open" files, "run" code.

It can't. It can only write.

When it writes "I need an image of the Apple Logo", that's just a sentence it wrote, not it actually searching for an image.

Everything that follows grows out of that one sentence.

2. So someone has to act on its behalf

You slip in a note: "Use HTML and SVG to make an animation where lines gradually outline the Apple Logo."

It quickly hands back a piece of code. But the rendered Apple is crooked, because it has never seen the Apple logo, and can only guess the outline from your description.

What do you do? Slip in an image of the Apple logo.

But having to find the image yourself and slip it in every time clearly isn't practical. So you cut a small window in the wall, and outside the window sits a reference clerk:

Note the most crucial point here: he didn't go out and search himself. He only wrote a note.

This is what's called "tool calling". When the model says "I want to use the search_logo tool", that sentence itself produces no action; it's only a request. The one who actually searches, the one who actually reads the file, is the program outside the model.

Flow of drawing the Apple logo: you state the requirement → the model finds the outline can't be guessed accurately → writes a note to search for reference material → the system actually searches (the model does nothing) → gets the image → the model redraws based on the image → the animation comes out

In the picture: the model wrote only three notes the whole time, and never once left the room.

Many people get stuck here because they conflate "the model saying what it's going to do" with "the model doing it".

3. It can do the work now, but it still makes mistakes

With the image, results are much better. But it can still fail: the lines might not close, the dimensions might exceed the canvas.

So cut another window and hire an inspector: when it finishes drawing, first render it into an image, the inspector takes a look, and if it doesn't pass, it's sent back to redraw.

Now the way it works becomes a loop:

Think → Do → Look → Think again

This loop has a professional name: ReAct (Reason + Act). If you can't remember the name, that's fine. Just remember the "Look". Without the "Look", the model is writing blind, handing in the result the moment it's written, without knowing whether it's wrong.

ReAct loop: think about what to do next → do, call a tool → look at whether the result is right → is it done? If not, go back to think; if done, hand it to you

In the picture: the most crucial part of this loop is "Look". Without it, the first two steps are wasted.

At this point, you've built the simplest Agent. In one sentence:

Agent = Model + Tools + Loop

The model handles "thinking", the tools handle "doing", and the loop chains "think-do-look" around, round after round.

4. Running is not the same as going live

The thing above can be demoed. But if a thousand people actually use it, you'll hit a pile of trouble within a day:

None of these seven questions can be dodged.

And you'll discover: not a single one of them can be solved inside the "model". The model only knows how to write text; it has no idea how to recognize malicious code, and no idea that it should give up after waiting ten seconds. It has no concept of "time" at all.

All of these have to be handled outside the model.

This engineering system wrapped around the model and the loop is the Harness.

5. What the Harness actually manages

No need to memorize terms. Follow one real operation and you'll understand.

The user clicks "generate" on your webpage:

  1. The webpage (or a command line, or someone else calling your API) hands the sentence to the system. This is the entry.
  2. The system first opens this user's work record, where they stopped last time, which tools were used, what the results were.
  3. The system passes "task + available tool list" to the model together.
  4. The model replies with one line: "I want to use search_logo."
  5. The system first checks: can this tool be used freely? (permissions)
  6. If allowed, execute. But it won't wait forever. Ten seconds without a result counts as failure. (timeout)
  7. On failure it doesn't crash; it records it, and it becomes reference for the next step. (error handling)
  8. The result is written back to the work record. The model looks at the record again and decides the next step.
  9. Repeat 3–8 until the model says "I'm done", or until the turns run out. (loop limit)

This whole stretch is the Agent Loop.

What happens behind one "generate": user clicks generate → entry → open work record → hand to the model → determine whether this tool can be used freely (dangerous operations ask a human first) → the tool actually does the work → write back to the record (timeout or error stops it) → back to the model, until it says it's done, then hand it to you

In the picture: in the whole diagram, the "model" is just one small block; everything else is the system built around it. That's where the Harness sits.

And every link it passes through, entry, records, model, tools, permissions, timeout, is a part that can be removed and swapped out. This is "pluginization".

Why does it have to be swappable? Because for a coding assistant, you want file read/write and running a terminal; for a media assistant, you want web search and image generation. Different businesses, different parts. If everything were welded into one program, every new scenario would mean changing the main program, and sooner or later you couldn't maintain it anymore.

So the string of intimidating terms, Plugin, Profile, Bundle, Patch, Preset, Context, Provider, is all saying the same thing: how to assemble these parts into a Harness that runs.

No need to memorize them now. Knowing they refer to "parts" and "assembly instructions" is enough to keep reading.

6. The horse harness metaphor

The original meaning of Harness is a horse harness.

A harness doesn't run for the horse. It only does three small things: makes the horse go in the right direction (reins), keeps it from crashing around (constraints), and when you swap in a faster horse, the carriage still works (unified interface).

The Harness does the same for the model: it doesn't produce intelligence, it only makes intelligence usable and dependable.

7. Writing the above as code

First, the plain-language version:

Round 1
  Model looks at the task → "I want to search for the Apple logo"
  System executes the search → gets the image → notes it down

Round 2
  Model looks at the notes (there's an image now) → writes animation code
  System renders it into an image → checks → "there's a gap" → notes it down

Round 3
  Model sees "there's a gap" → changes the code → checks again
  ...

Until the check passes, or it stops after more than 10 rounds

The same thing in TypeScript looks roughly like this (not dsh's real API, just for illustration):

async function agentLoop(session, tools, provider) {
  for (let turn = 0; turn < MAX_TURNS; turn++) {
    const reply = await provider.complete(session.messages, tools.schema);
    session.append({ role: "assistant", content: reply });
    if (!reply.toolCalls?.length) return reply.content;

    for (const call of reply.toolCalls) {
      if (needsApproval(call) && !(await session.askUser(call))) continue;
      try {
        const result = await withTimeout(tools.run(call), TIMEOUT_MS);
        session.append({ role: "tool", content: result });
      } catch (err) {
        session.append({ role: "tool", content: `Failed: ${err.message}` });
      }
    }
  }
}

Line by line, each one answers one of the seven questions from section 4:

This line of code Which question it answers
session.append(...) After refreshing the page, is the progress still there
if (!reply.toolCalls?.length) return How to tell it's done, instead of spinning forever
needsApproval + askUser Should dangerous operations ask a human first
withTimeout(..., TIMEOUT_MS) Tool is stuck, how long to wait
catch (err) Errors don't crash; mistakes become clues for the next step
MAX_TURNS The brake on endless retries

And the model part, provider.complete(...), never touches any of these things. It only does the "thinking".

Everything else is taken over by this loop. That is the entire reason the Harness exists.

8. Finally, in three sentences

  1. It's not a smarter model; it's the system outside the model that lets it actually do work.
  2. The model handles thinking, tools handle doing, and the loop keeps "think-do-look" going.
  3. The Harness keeps this thing from causing trouble in the real world: it remembers, it blocks, it tolerates mistakes, it connects.

To make it even shorter:

It's the engineering layer that turns "a model occasionally doing one thing right" into "a system stably doing one thing right". The model provides the intelligence; the Harness provides the reliability.


This post is based on blogger "轩辕的编程宇宙"'s "DeepSeek Harness Technical Architecture Tutorial" Lesson 1, organized and extended. The content is personal understanding; some statements are the author's own interpretation. If there are discrepancies, defer to the original text and DeepSeek's official documentation.

Original link: https://www.xuanyuancode.com/learn-deepseek-harness/lessons/what-is-deepseek-harness

#DeepSeek #Agent #AI工程化 #Harness #ReAct