Same Model, Different Harness: See What the Program Around the AI Changes

T20-L01 · AI harnesses · Level 1 User · 12-minute read, plus 45 minutes of doing

Is it the model or the tool?

A colleague has switched coding assistants and says the new one is "much smarter". In the lab it fixed a plate-reader script in minutes; in a company it cleaned up a stock export that had been wrong for weeks. You want to know whether to switch too.

Often the model underneath is the same, and what changed is the program around it. That program is called the harness. It decides which files the AI sees, which tools it may use, when it runs a test and when it stops. Two harnesses can give the same model the same job and come back with different steps, different costs and sometimes different results.

In this book you look at three real runs of one small bug fix: the same model, the same instructions and three harnesses. Then you run it once yourself in OpenCode. You are at Level 1 User: you read, compare and try things on a practice copy, so nothing you depend on changes.

After this you can

• Say in two sentences what a harness is and what it adds to a model.
• Read an agent's step list and sort each step into Look, Reproduce, Change, Check or Report.
• Compare runs of the same task on four measures: passed the check, time, requests and tokens.
• Add a run of your own from OpenCode Desktop to the same comparison.
• Write the three lines you need before anyone in your group switches harness: the task, the check and what you measure.

Before you start

• Books: T01-L01 · From Idea to Working Result: The Four-Quadrant Method for the four-quadrant method, and T08-L01 · Start With OpenCode: Set It Up, Change One Line, and Undo It, so OpenCode Desktop is installed.
• Two downloads: the practice folder t20-l01-labtools.zip and the step lists t20-l01-runs.txt.
• A spreadsheet or a sheet of paper for the comparison table.
• About 60 minutes: 12 to read, 45 to do.

Last verified 30 September 2026. DeepSeek Harness, OpenCode and OpenHands are free and open source. You pay only for the model they call, and nothing if that model runs on your own computer. DeepSeek Harness is still a pre-release. Details for experts at the end of this book.

The idea in one page

• A model only writes text. On its own it can't open a file, run a test or remember what it did five minutes ago.
• The harness does everything else. It gives the model tools (read a file, edit a file, run a command), chooses what the model sees each time it asks, asks you before risky actions, and decides when the job is finished.
• Every request costs tokens. A token is a piece of a word, and each time the harness asks the model, it sends the instructions plus everything relevant so far. A harness that asks more often, or sends more each time, uses more tokens, which means more money with a paid model or more waiting with your own.
• Same model, different harness, different run. In the runs below all three harnesses fixed the bug, but one needed about four times the tokens of another, and one looked at files it was never given.
• Judge the result with a check the agent never saw. Every agent writes a confident summary. A test you keep to yourself tells you whether the work is right.

Worked example: one bug report, three harnesses

The task is a small Python tool that reads plate-reader exports and prints the mean optical density (OD). A lab user reported two faults: wells in columns 10 to 12, like A12, landed in the wrong column, and the mean was too low whenever some wells had not been measured.

Structure it

The question is narrow: does the harness change how the same model handles the same bug report? To answer it, only the harness may change. The model, the instructions, the folder and the check stay the same.

Before any run, the check is written and kept outside the folder: three tests that pass only when both faults are fixed and the tool prints the right mean. The agents never see these tests.

Choose tools

• The model: one open model, running on our own hardware, for all three runs.
• The harnesses: DeepSeek Harness (DeepSeek's own, new in 2026), OpenCode (the one you know from T08-L01 · Start With OpenCode: Set It Up, Change One Line, and Undo It) and OpenHands (an older, widely used open-source agent).
• The measures: did it pass the hidden check, minutes from start to finish, number of requests to the model, and tokens sent to the model.

Build it

Each harness got a fresh copy of the folder, the same bug report and permission to edit files and run commands without asking. The runs went one after another on 30 September 2026. After each run, the hidden tests were copied in and run.

Understand it

All three fixed both faults, so on this task the result alone doesn't separate them. The step lists do. Open t20-l01-runs.txt and compare:

• DeepSeek Harness read every file, then reproduced both faults with a short script before changing anything. After the fix it proved that its new tests would have failed on the old code, then ran a sample file through the tool. 17 actions.
• OpenCode read the files, made the two edits, wrote the tests and ran them, then tried a sample file. 11 actions. It never showed the faults before fixing them, and never showed that its tests catch them.
• OpenHands read the files, reproduced both faults like DeepSeek Harness, planned the work in a task list, made four edits, and ran the tests and a sample file. Then it read its work again and reran the tests. 18 actions, and the most tokens by far: over four times as many as OpenCode.

The model was identical. The habits came from the harness: whether to reproduce a fault first, whether to test the tests, how often to ask the model and how much to send each time.

A second task shows that results can differ too. Asked to add a --min-od option, test it and mention it in README.md, all three wrote working code. DeepSeek Harness and OpenCode passed the hidden check. OpenHands left out the README line, so its run failed, although its own summary called the job done.

One more thing happened, twice. The practice setup made mistakes that left the hidden tests within reach: once in a folder next to the project, and once as a leftover compiled file inside it. Both times OpenHands found them. The second time it spotted the leftover, decoded it, checked its fix against it and then deleted it. Both runs were thrown out and repeated on a clean folder. The lesson holds for your work too: the harness decides what the agent can see, and an agent will use whatever it can reach.

Company: a stock export

The same pattern fits a company. A warehouse script reads shelf codes like B7 and B12 and sums stock per aisle, and anything past shelf 9 lands on the wrong shelf. Structure it: one bug report and a hidden check of five shelf codes with known totals. Choose tools: one model, two or three harnesses. Build it: one fresh copy each. Understand it: the same four measures, plus the step lists.

What goes wrong

• Crediting the model for the harness. Symptom: "the new assistant is smarter", after a switch that changed the model and the harness at once. Fix: change one thing at a time. Keep the model and vary the harness, or the other way round.
• Trusting the summary. Symptom: the agent ends with "all tests pass", and you stop there. Fix: run a check the agent never saw, or at least read the changed lines yourself, as in T08-L01 · Start With OpenCode: Set It Up, Change One Line, and Undo It.
• The agent can see the answers. Symptom: a result that looks too perfect, or a step list with searches for files you never mentioned. Fix: give the harness only a clean copy of the project folder, and keep your check somewhere else.
• A task every harness passes. Symptom: all runs pass, as with the bug fix here, and you learn nothing about which to pick. Fix: for a real choice, use tasks from your own work that are harder to get right. The next book in this track shows how.
• Counting only minutes. Symptom: the fastest harness wins, and then the bill arrives. Fix: record requests and tokens too. With a paid model, tokens drive the bill, although many providers charge far less for input they have already seen (cached input), so check the price of each kind of token.
• One run each. Symptom: one lucky run decides for the whole group. Fix: use this book to learn what to look at; decide after several tasks.

Do it yourself (45 minutes)

Step 1 · Structure it (5 minutes). Write one sentence describing a small task from your own work that you'd give a coding agent. Add one sentence on how you'd know it was done right without asking the agent. You should see: two sentences, the second naming something you can check yourself, like a number, a file or an output.

Step 2 · Understand it (15 minutes). Open t20-l01-runs.txt. For each of the three step lists, mark every step with one word: Look (reads or lists files), Reproduce (tries the tool before the first change, to see the fault), Change (edits a file), Check (runs the tests or tries the tool after a change) or Report (the final message). The key at the top of the file says which words mean what. You should see: DeepSeek Harness has Reproduce steps and OpenCode has none.

Step 3 · Choose tools (5 minutes). Copy the table from "Understand it" into your spreadsheet or onto paper. Add five columns for your counts of Look, Reproduce, Change, Check and Report. You should see: three rows, each with nine filled cells.

Step 4 · Build it (15 minutes). Unzip t20-l01-labtools.zip into your OpenCode folder. In OpenCode Desktop, add the labtools folder with the folder-and-plus icon next to Projects, click it, then New session. Check that the mode says Build and the model is Space Bunny; the screens are the ones in steps 2 to 4 of T08-L01 · Start With OpenCode: Set It Up, Change One Line, and Undo It. Open BUG-REPORT.txt in Notepad or TextEdit, copy all of it, paste it into the message box and send it. Let it work, and answer a question only if it's stuck. You should see: OpenCode reading files, changing labtools/plate.py and adding tests. If your computer has no Python, it will say it can't run the tests. That counts as a Check step that failed, and how honestly it tells you is part of the result.

Step 5 · Understand it (5 minutes). Scroll through your session and mark its steps the same way. Add it as a fourth row. Fill in minutes (roughly), and leave requests and tokens empty if you can't see them. You should see: four rows, and one or two clear differences between your run and the three you were given.

Exit check

Hand in one table and three lines.

• The table has four rows: the three runs from this book and your own OpenCode run. Each row shows passed or not (write "not checked" for yours), minutes, and the counts of Look, Reproduce, Change, Check and Report.
• The three lines are for your own task from step 1: the task, the check the agent won't see, and the two measures you'd compare.

It passes when every row is filled, your check is something the agent can't read, and one sentence under the table names the biggest difference you found between the harnesses.

Rule to remember

Change only the harness, keep the model and the task, and judge the work with a check the agent never saw.

Details for experts

Checked on 30 September 2026. You don't need this to follow the book; it's for setting things up or answering a colleague.

Further reading and tools

• T01-L01 · From Idea to Working Result: The Four-Quadrant Method
• T08-L01 · Start With OpenCode: Set It Up, Change One Line, and Undo It
• T07-L02 · Hand a Task to an Agent, and Check What It Did
• OpenCode: Taught
• DeepSeek Harness: Catalogued
• OpenHands: Catalogued
• DeepSeek V4: Catalogued