Your agent harness is an efficiency decision, not a quality decision
Hold the model fixed, one local DeepSeek V4 Flash (High), and change everything around it. Three harnesses, Pi, OpenCode and Claude Code, wrapped the same model, each bringing its own tool set and system prompt, the levers people believe make a coding model better. Handed the same tasks and graded the same way, the work came out the same across every setup. What changed, by multiples, was the time and tokens each one spent getting there.
19 July 2026 · same model, three harnesses
Three harnesses, lightest to heaviest: Pi, a bare 4-tool harness; OpenCode, a mid-weight framework; and Claude Code, a heavy off-the-shelf harness that does not speak the local server's API, so it reaches DeepSeek V4 Flash through a small proxy (CLIProxyAPI) that translates between the two. The same model sits underneath all three, served the same way throughout, the same set of real bug fixes, the same grading, and only the wrapper moves.
The grades come out the same
Across the tasks no grade difference held up, and whether it was Pi, OpenCode or Claude Code the scored work landed in the same overlapping place, because the run-to-run noise is wide enough to swallow the gaps between them whole.
On the hardest tasks the same harness scores a basic attempt on one run and a solid fix on the next, a full grade apart, with nothing changed between them but the random seed.
The run-to-run swing is that wide, so with only 2 or 3 runs the noise decides which harness looks best, and a ranking that changes every time you rerun it is no ranking at all. The chart below puts the three harnesses on one axis, and they land in a single overlapping band.
The difference is time and tokens
What separates the harnesses is efficiency, and Claude Code is the outlier by a wide margin, several times the tokens and the wall-clock of either lean harness to reach the same fix. The cost is all on the output side, in what the model generates and the tools it runs. The three read very differently too, Claude Code exploring far more, but on this model that barely registers, because DeepSeek V4 Flash reads input at nearly the same speed at 10K tokens or 200K, so heavy context is close to free here and would only bite as billed input on a metered API. What costs is generation, and since the same model decodes at the same rate for all three, more output and more tool-running is simply more time. The two lean harnesses come out close on output, and where OpenCode takes longer than Pi it is the tool-running, not the word count.
Pi reasons, OpenCode delegates
The two lean harnesses generate about the same amount, they just spend the clock differently. Pi does the whole task in one context, verifying by thinking, so almost all of its tokens are reasoning in one long stream. OpenCode hands chunks of the work to subagents instead, each a separate sub-run that generates on its own, and those tokens never surface in the main stream, which is what made a plain count read OpenCode as the leanest of the three at around 11,000. Count the subagents back in and it lands near 17,000, right alongside Pi's 15,000, not below it, so neither out-writes the other by much. What separates them is pace, the same model decodes at one rate for both, but Pi spends its clock generating in long bursts while OpenCode spends more of its shuttling work out to subagents and waiting on the hand-offs, so it takes longer to reach a similar word count. And none of it moves the grade, because the 8 bugs are subtle logic bugs, a guard testing the wrong condition, a state change firing a step too early, that a subagent catches no better than a careful line of reasoning, and a capable model lands either way.
Claude Code explores most, and edits only when certain
It runs the most tool calls of the three by a wide margin, around 70 to a task where Pi needs 40 and OpenCode just 22, and it holds off on changing anything until it is sure, its first edit landing about 80% of the way through the run where OpenCode commits nearer 60%. Nearly all of that front-loaded work is looking rather than touching, reading files and searching the tree, and the edit it finally makes is the same handful of lines the lean harnesses landed long before. The diligence has no ceiling and no reward: on the hardest bug it was still reading when the run hit its time limit, and everywhere it did finish the grade came out level with Pi. It is the most thorough reader of the codebase, and on fixes this size thoroughness is just time.
The three, and how each runs
All three drive the same local model; what differs is the machinery each wraps around it, and that is what the numbers reflect.
Pi (0.80.10), the bare harness, carries almost nothing, a short prompt and a handful of tools, so it stays the leanest on overhead by a wide margin.
OpenCode (1.17.10), the mid-weight framework, leans on compound shell commands, packing several operations into one call, but hands larger pieces of the work off to subagents, which do their own generating, bringing its true output up near Pi's, while the round-trips to and from those subagents are what cost it the extra clock.
Claude Code (2.1.186), the heavy harness, brings 27 tools, most of them orchestration plumbing a bug fix never touches, and it works through them in the most steps of the three, generating several times the output and running the most tools, which is where its tokens and its wall-clock go, with no grade to show for the extra.
Which one to reach for
This is DeepSeek V4 Flash on eight focused bug fixes, so read it scoped. For a capable model the harness is an efficiency choice and not a quality one, at least in my agentic workloads in a large codebase. And the next time a post claims that some harness, some prompt, or some clever context file made a coding model measurably better, the first thing to ask is how many times they ran it, because under about 10 runs a condition there is a good chance they mostly measured the weather.