The Harness, Taken Apart. Part 1: Three Agents, Nine Tasks — No Easy Win

English | Русский


The Harness, Taken Apart. Part 1: Three Agents, Nine Tasks — No Easy Win

For the past year, the same line keeps coming up about coding agents: it’s not the model that matters, it’s what’s built around it — the rules, tools, and memory bolted on top. The industry calls this the harness. I decided to test the claim with real work instead of benchmark scores — and found no quick, clean win for the harness.

Here’s the scale of how loud that claim is. SWE-bench is the standard test for coding agents: a set of real issues from open-source projects that the agent has to close with code changes, with the result checked automatically by the project’s own existing tests — pass or fail, no room for argument. On this benchmark, the same Claude 3.5 Sonnet with different scaffolding solved anywhere from 168 to 317 tasks out of the same set — a spread of almost 30 percentage points. That’s wider than the spread across the entire top-30 of that same leaderboard, agents running on completely different models (8.8 points). Another paper makes the same point more directly: model and task held fixed, only the scaffolding changed — the share of fully solved tasks rose from 25% to 43% (43 to 72 out of 169). Numbers like that are easy to repeat without checking.

TL;DR

  • Took three agents (Claude Code, Hermes, DeepSeek Harness/dsh), ran each one on the same nine tasks twice — with harness and without, model held fixed — 54 runs total.
  • Quality didn’t move once, anywhere it could actually be measured. Whatever the harness is buying, it isn’t a better result.
  • The harness’s effect on spend splits into three distinct effects: one shared by all three agents (depends on the task’s genre), one that’s a property of a specific agent-task pairing (and can flip direction entirely), and one where it’s just paying more for nothing.
  • The agents differ from each other, independent of the harness, by at least as much as the harness itself changes things — sometimes more: Hermes’s repeat-run spread (up to 9.3×) outsizes the single loudest harness effect in the whole experiment.
  • At the same price, no single agent wins on both cost and quality at once.
  • All the measurement code is open: workain/agent-runtime-instruments (Apache-2.0). All 54 measurements, the task list, and the methodology are fully open too, including everything that didn’t make it into this piece: workain/research-results (CC BY 4.0).
  • This is part 1 of a series. There won’t be an open verdict of "you need a harness" or "you don’t" — part 2 takes the harness apart into its pieces.

I took three agents and ran each one on the same nine tasks twice — with the harness, and on bare settings with not a single hint added on top:

  • Claude Code — a terminal coding agent from Anthropic.
  • Hermes — another agent in the same class, with its own way of wiring up tools and storing settings.
  • DeepSeek Harness (hereafter dsh) — an agent with a plugin-oriented architecture: almost everything in it, from memory to tools, is wired in through a separate plugin rather than built in up front. Despite the name, that’s the product’s own name, not our term "harness."

Definition. In this piece, harness means three specific things handed to an agent on top of its stock setup: a rules file, a set of tools, and memory carried between the steps of one task. "With harness" and "without" in every comparison below means exactly that and nothing more — the model and the task’s wording are identical within each pair of runs.

All three pick up the harness — but each in its own format, not as three independently invented versions. The content (which rules, which tools, what to remember) was the same single set of instructions for all three; where and how that set is physically placed is specific to each agent: for Claude Code it’s a CLAUDE.md file, which it reads on its own built-in convention; for Hermes and dsh it’s their own equivalent (a rules file / system prompt for Hermes, a plugin for dsh), into which the same set of instructions was translated to fit their format. The difference between "with harness" and "without" is whether that set exists at all, not a difference in what each agent was actually given to read.

These three agents are built differently at a structural level too — where each one’s model choice lives, how rules, tools, and memory get wired in:

Three agents — three different harness setups

This question actually splits into two independent axes — and neither one here is a footnote to the other:

  • Axis 1 — the agents, on their own. Regardless of whether the harness is on: how predictably does the agent behave on a repeat run, can you trust what it reports about its own cost, what does it gain from switching models, does it even manage the task at the same price its peers do.
  • Axis 2 — the harness effect. What changes for the same agent when rules, tools, and memory appear on top of its stock setup — and whether that change is the same across all three.

Across the three of them, the agents behave so differently that this difference often outweighs whether the harness is on or off — with numbers and charts, that’s ahead in the axis 1 section.

The big picture, before diving into detail

Before breaking down which effect shows up on which task and why — here’s what all 54 runs look like at once, with no split into individual cases. This is the direct answer to "which agent on average consumes less while working better and cheaper," if one table can even give that answer:

Agent Total tokens (54 ÷ 3 = 18 runs per agent) Total model requests (iterations) Quality, summed over the 3 tasks where the rubric fired at all (out of 8 = 2 for T2 + 2 for G + 4 for J — what these tasks are, below; identical with and without harness)
Claude Code 92,752,468 562 2
dsh 84,027,595 721 3
Hermes 43,311,328 396 1

No agent wins on both price and quality at once. Hermes is the cheapest by tokens — and the worst on quality, anywhere quality was visible at all. dsh scores the most points on the rubric — but it isn’t the cheapest. Claude Code is the most expensive by tokens at middling quality. "Speed," meaning wall-clock seconds, was deliberately left out of this table: part of the measurements ran on a shared machine under load, so seconds in this experiment aren’t a standalone metric — the number of requests (iterations) is an honest substitute, one you can check independently of whatever else was happening on the machine at measurement time.

This is an aggregate across all nine tasks at once, not a typical task — and two of the nine (building a feature from scratch, and migrating checks between environments) outweigh the other seven combined in total tokens. So what follows is not just what’s hiding behind one averaged row, but why it’s averaged in the first place:

All 54 runs at once: steps × price per step, by agent and by harness

Each point is one run (nine tasks × three agents × two modes). The X axis is the agent’s number of steps on that task; the Y axis is the price of one step; both values are normalized to that same task’s own average, so tasks of different scale stay comparable on one chart. Color is the agent; filled means harness on, outlined means off. Three things are visible at once: first, dsh (green) has the widest spread on the X axis of the three — it sometimes takes noticeably fewer, sometimes noticeably more steps than the average task of that type. Second, Hermes (orange) lives mostly to the lower-left of the others — fewer steps, cheaper per step, matching its spot in the summary table above. Third, task G’s six points (circled in black; what task G is comes in the next section) are scattered across the whole plot rather than clustered together — even though this is the one task where quality actually moved (0, 1, or 2 out of 2), that difference is invisible from this chart’s position alone (steps/price): effort and outcome are not the same thing, and we’ll come back to that.

Nine tasks: what was actually asked

Three agents — Claude Code, Hermes, and dsh — went through the same set of nine tasks, each one twice. Here are all nine, with the real wording, not just a letter:

Task Origin Genre What was actually asked Scored?
T1 built for the test investigate Go through the internal knowledge base and prior working notes and report what’s known about where exactly the measurement breaks — recurring failure types, specific numbers, what changed over time. no (didn’t reach scoring this round)
T2 built for the test build (fixes something existing) Decide whether a specific pre-commit check can actually fire on failure, and if not — fix it in the repo: show both a correct failure and a correct pass. yes — out of 2, exactly 1/2 in all six scored runs (three agents × two modes)
T3 built for the test investigate Explain a sharp jump in a detection-time metric (from near-zero to hundreds of hours) — is this a real degradation or a measurement artifact, and what should be watched instead. no
F real work investigate Investigation against a frozen, read-only snapshot: why several sessions crashed at the same time, whether it was the same event, and whether any monitoring even noticed — no attempt to fix anything. no
M real work investigate A real plan for migrating a workload to another agent: what moves, what can’t, what breaks unattended, what it costs, what breaks on day one. "Don’t migrate" is an acceptable answer. no
S ("measurability") real work investigate Assess how severe a real measurability regression actually is (some records confuse branches, some links barely match), find the cause, say what fixes it. no
G real work build (fixes something existing) Migrate three checks (precommit/scanning) from one trigger mechanism to another, showing for each a test that fails before the change and passes after. yes — the only task with any spread: 0/2, 1/2, or 2/2 depending on the agent
H ("build from scratch") real work build (from scratch) Build a fleet-session statistics tool from scratch: requests, tokens by type and cache TTL, time, price, context size — run it on real data and plainly state what the tool can’t see. no
J (independent answer key) real work investigate Review a specific pull request and report its blocking defects so they can be reproduced, plus explicitly name what it got right. Scored against an independent list of this PR’s real defects, drawn up in advance by a human — not to the reviewer’s own taste. yes — out of 4, exactly 0/4 in all six scored runs (three agents × two modes)

"Built for the test" tasks (T1–T3) aren’t abstract toys with no context: T1 and T3, for instance, operate on entirely real repository content. What sets them apart is that they were specifically constructed for this kind of run, rather than being work that needed doing independent of whether anyone was measuring it — unlike the six "real" tasks (F, M, S, G, H, J), which existed on their own.

The genre split ("build" / "investigate") is a separate cut, one that doesn’t line up with origin: the very same T2, G, and H make up the "build" genre (the one criterion being whether the task’s wording demands an actual change to the repo), and this split was noticed from the data after the fact, not set in advance.

Of the nine tasks, the rubric measured anything at all on three — T2, G, and J (hence the "out of 8" in the summary table above: 2 for T2 + 2 for G + 4 for J). Among them, only one showed any spread from the harness:

  • G (the only one with spread) — each agent’s score matched across both harness states: the harness didn’t change the outcome for any of the three (table and chart below, in the axis-2 section).
  • J (out of 4) — no agent, in any of the six runs (three agents × two modes), gave a correct answer. The score was exactly zero across the board. There was nothing for the harness to move here: the outcome was already floored for all six.
  • T2 (out of 2) — the same average score across all six runs. The rubric technically fired, but distinguished nothing: neither the harness nor the agent affected anything here, at least by this rubric’s own yardstick.
  • The remaining six tasks — no formal quality score was built for them this round at all. That’s explicitly marked as "not measured," not invented after the fact.

Whenever a scoring table comes up below, the number after "out of" is the reference, maximum-possible count — not a count of files or steps, which has no "correct" value to begin with. Whatever the harness is paying for, it isn’t the quality of any individual answer, anywhere that could actually be seen.

The full list of all 54 measurements (not just the ones that made it into this piece), with methodology and detail, is in the open dataset: workain/research-results.

How it was measured, briefly

The model was held fixed within every cross-agent comparison — otherwise comparing agents turns into comparing model prices. Keeping it fixed took separate work of its own (for some agents the model choice is a launch parameter, for others a setting in a shared config file), and price everywhere was recalculated from the provider’s own billing record, not from whatever the agent reports about itself — because self-reports, for some agents, turned out not to be trustworthy as-is (detail in the axis-1 section and in the open methodology). The full engineering story is in the dataset’s methodology.md; it isn’t repeated in detail here, so as not to clutter the piece with the measurement’s own internal kitchen.

One limit to keep in mind through the whole piece: every number below is the result of a single run (n=1), not a statistical test. Read it as "this is what happened," not as an exact constant — there’s never more than one run behind any "roughly" or "around" in the wording below.

Without the harness, the agent acts right away; with it, three extra checking steps come first

Axis 1: the agents, on their own

Here the harness is held the same across all three — on for everyone or off for everyone — and we look at how the agents differ from each other on their own. This axis matters just as much for a practical decision as the harness effect in the next section: if the spread between agents is bigger than the effect of switching the harness on, then "which agent" matters more than "with harness or without."

Repeat runs: does an agent agree with itself

The same task, on the same setup, was run twice without changing a single line in the harness, to see how far the repeats would drift apart:

  • Claude Code — ≈1.2×, barely noticeable.
  • dsh — from 1.75× up to at least ≈3.5× (the upper bound isn’t closed: more runs could show an even wider spread).
  • Hermes — up to 9.3×: an ordinary repeat can differ from the previous run by almost an order of magnitude.

How much an agent agrees with itself on a repeat — spread across the three agents

The harness has nothing to do with this — it’s an agent’s own reproducibility: how differently it solves the same task under the same conditions, simply from one time to the next. Two facts the chart makes legible: first, the spread between agents is an order of magnitude, not a matter of percentage points (from ≈1.2× for Claude Code to ≈9.3× for Hermes). Second, Hermes’s ceiling (9.3×) is higher than the single loudest harness reaction anywhere in the experiment — Claude Code’s 4.33× on task J (the dashed line on the chart). Any difference we attribute to the harness for Hermes specifically, below, has to be checked against this background noise first: an effect smaller than the noise isn’t an effect yet.

This has a direct practical consequence for how agents normally get compared. Run Hermes on a task once and get a number; a second identical run, with not a single setting changed, can come out almost nine times different — purely from the agent’s own nature, no harness involved. A team that compares two agents on one run each (a common practice, not a mistake unique to this piece) risks ending up with a ranking that’s entirely explained by where, exactly, that particular Hermes run landed inside this ninefold spread — not by which agent is actually better.

Whose self-report can you trust

Trusting what an agent says about its own cost turned out to be a property of the specific agent too, not a general rule:

Agent What’s wrong with the self-report
Claude Code three of its own token counters under one name, up to ≈25× apart from each other on tasks involving sub-agents
Hermes its "input tokens" after the fact conflate fresh and cached tokens — up to ≈10× price discrepancy on the affected cells
dsh its component-recalculated price and the provider’s independent billing matched almost exactly across all 18 of its runs

For Claude Code, delegation is a routine part of the job: on a complex task, the main conversation can hand off a chunk of work to a separate sub-agent with its own, separate token count, one that isn’t always visible in the same place as the main conversation’s count. On tasks where Claude Code spawned such helpers, one of its counters showed almost 25 times more tokens than the other — even though both print under the same label, "how much I spent." If you’re watching the number an agent prints about itself in production, for Claude Code it’s worth first figuring out which one of them you’re actually reading — a budget calculated from a session with no sub-agents will silently blow through on the very first task where the agent decides to delegate part of the work.

Claude Code also turned up a separate bug, different in nature: for one model version, its own internal price table was simply missing a row — and the agent, finding no rate, calculated a single run’s cost at roughly 50 times the real one (per the provider’s billing). This isn’t a discrepancy between its two counters like the example above, but a missing row in a price list: the same class of error as Hermes’s in the table above, just with a different mechanism and on the opposite end of the scale (50× more expensive, not cheaper).

All three were checked with the same method — the difference isn’t in the checking method, it’s in what that method actually found. This, too, is a decision that has nothing to do with the harness: which agent is worth cross-checking against an independent count at all, and which can (for now) be trusted — that’s a question about the specific agent, and the answer is different for all three.

Switching to a cheaper model

All three were moved from the expensive version of a model to the cheap one from the same lineup:

  • Claude Code — the bill on the same tasks drops ≈9×.
  • Hermes — drops ≈56×.

The same advice ("just use a cheaper model") — a different payoff for Claude Code and Hermes

The advice "just take a cheaper model" pays off multiple times harder for one agent than the other — on the chart, the gap between them is more than sixfold (56÷9 ≈ 6.2). What decides this isn’t the rate card, it’s the agent’s own architecture: how many times it calls the model along the way, and how much context it rereads from cache instead of resending it fresh. Cache is billed as a separate line and priced differently from a fresh token — which means for an agent with a high share of cache reads, switching from the expensive model to the cheap one hits the bill in two places at once: both the fresh token and the cache read get cheaper. For an agent that barely uses cache, only the first part of the bill improves, and the bulk of it is priced at the full fresh-token rate regardless — so the payoff is smaller.

Is the cheap model even enough

On task G, with the same cheap model for everyone:

  • dsh (tested only on the cheap model) — saw it through, full score: 2 out of 2.
  • Claude Code — 1 out of 2, half as good as on its usual, more expensive version (2 out of 2 there, on the same task).
  • Hermes — 0 out of 2, didn’t change a single file in the project in either of the two runs.

The harness was switched on identically for all three in this comparison — the difference here is between agents, not from the harness.

At the same price, not every agent pulls the task off

This isn’t about the harness and it isn’t about luck — it’s about whether the agent can handle the task at all at the price you’re willing to pay. The harness won’t pull off a task the agent simply can’t do on that model: below, in the axis-2 section, the same task G comes back again — this time to show that the harness doesn’t even try to compensate for this, it just costs more.

Summed up, across this whole battery of tasks, independent of the harness:

Agent Repeat-run spread Price change on switching to the cheap model Score on the cheap model (out of 2)
Claude Code ≈1.2× drops ≈9× 1
Hermes up to ≈9.3× drops ≈56× 0 — 0 files in both runs
dsh 1.75×–≥3.5× tested only on the cheap model, nothing to compare against 2

All of this — repeat-run spread, trust in self-reporting, the price of switching to a cheap model — exists separately from the harness, and is worth knowing in its own right before picking an agent. But the experiment’s question was about the harness, and we can now go back to it with this background in mind: from here on, every "harness effect" number is read against what’s already known about the agent itself, not in a vacuum.

Axis 2: the harness effect

Here, the other way around, the agent is held fixed and we look at what switching the harness on changes. Three effects turned up, each of a different order: one depends only on the task’s genre and is the same across agents; a second depends on the agent-task pairing and can flip into the opposite direction; a third is the case where the harness doesn’t change the outcome at all, it just costs more.

Effect one: task genre, the same for everyone

The first harness effect is predictable, and it doesn’t depend on which agent you pick.

If you count steps instead of tokens, the rule comes out clean. On "investigate" tasks, the harness reliably cuts steps: on average the agent needs only 0.84 of what it would have taken without any hints. On "build" tasks, it’s the opposite — on average, 1.16 times more steps. This isn’t a one-off pattern: it holds for Claude Code, Hermes, and dsh all at once, with the same model for all three.

The mechanics aren’t complicated: on "investigate" tasks, an agent with no hints burns moves feeling out the path — opening the wrong files, re-checking guesses; the harness points the way in advance, and there’s no wandering to do. On "build" tasks, the agent is already getting straight to work — there’s new code to write, not much to wander around in; here the harness adds its own procedure (check the requirements, go through a checklist), and that procedure costs extra moves that wouldn’t otherwise be needed.

Two tasks are worth naming directly — the pattern shows up on them harder than on the rest, with no exception across all three agents: on "measurability" (S), all three agents cut their step count under the harness; on "build from scratch" (H), all three increased it.

From here it gets more complicated. The price of a single step barely depends on task type — the same measurement, but for one model call instead of their count, comes out nearly identical across both genres:

Task genre Steps, with harness ÷ without Price per step, with harness ÷ without
"Investigate" 0.84 1.17
"Build" 1.16 1.14

Steps diverge noticeably by genre; the price per step, almost not at all. It turns out the harness changes how many times the agent acts, and barely changes what one action costs. The total token bill is the product of these two quantities, and they don’t always pull the same way.

Two harness effects — step count and price per step — sometimes add up, sometimes cancel out

Multiply them, and the difference becomes concrete — that’s what the diamonds on the chart show. On "build": 1.16 steps × 1.14 price-per-step ≈ 1.32 — the two effects pull the same way and reinforce each other. On "investigate": 0.84 steps × 1.17 price-per-step ≈ 0.98 — here the effects nearly cancel: step count drops noticeably, while price per step rises almost as much, and in the final token bill it looks as if the harness changed nothing at all, even though both quantities moved under the hood, just in opposite directions. A flat "the harness barely changed anything" on one genre and "the harness is noticeably more expensive" on another can be the same pair of underlying effects — just aligned in one case and opposed in the other.

Effect two: the same switch, in different agents’ hands

The second effect is far more temperamental: it depends not just on the task, but on who the harness landed with — and sometimes it flips into the opposite direction entirely.

This shows up on the independent-answer-key task — that same J. Its genre is "investigate": the agent needs to gather facts and give a checkable answer without touching the code. For Claude Code, switching the harness on raised token spend almost 4.3×: the harness’s rules require going through specific verification steps before giving a final answer, and for this agent each such step turned out surprisingly heavy, with large chunks of text going in and coming out. For Hermes, on the exact same task, flipped with the exact same switch, tokens didn’t rise — they dropped to a quarter of what they were: the same set of rules, for this agent, apparently helped it cut a shorter path rather than lengthening it. For dsh, on the same task, the harness also nudged spend up slightly — by 1.57× — landing right between these two extremes: no spike like Claude Code’s, no drop like Hermes’s.

The same harness switch on task J gives opposite effects for Claude Code and Hermes

The range between the two extremes on the chart is 4.33× for Claude Code against 0.262× for Hermes — a 16.5-fold gap between two agents on the same switch, on the same task. And correctness, labeled right on the chart, doesn’t fit into that gap at all: no agent, in any of the six runs, gave a correct answer (reference — 0 out of 4 for all six). Whatever Claude Code was buying with its extra tokens, and whatever Hermes was saving, the result was equally zero either way. Tokens diverged by multiples; correctness didn’t.

Across the whole picture, each agent reads its own pattern:

Agent Pattern across the whole battery
Claude Code close to 1× almost everywhere, with exactly two sharp spikes — this task and "build from scratch"
Hermes no calm zones at all, wide spread on almost any task
dsh not a single sharp spike in either direction — the most restrained spread of the three

For Claude Code, both spikes make sense: one is the task above, the other is "build from scratch" (H) — exactly the genre where the harness is expected to cost more, just noticeably harder for this agent than for the others. On H, with the same model, the harness raises Claude Code’s tokens by 3.31× — against 1.34× for dsh on the same task, the same model: a roughly 2.5× gap between the two agents, one that doesn’t stand out for dsh precisely because it falls within its own usual manner (below). Hermes’s wide spread isn’t a surprise: it’s already the least predictable of the three with no harness involved at all (see the repeat-run section above), so part of its reaction to the harness is simply its usual manner, pushed to an extreme in both directions. And dsh’s 1.57× on J and 1.34× on H aren’t a compromise between its neighbors in the table — they’re its usual manner: across the whole battery of tasks, it never spikes above ≈2× once, so a moderate reaction here is the agent staying itself, not the harness softening something for it.

So "how an agent reacts to the harness" is a property not of the harness, but of the agent-plus-task pairing. Tuning a harness for a specific tool means tuning it for that character, not in general.

Effect three: when the harness is just more expensive

The harness doesn’t even guarantee "not worse." Here’s task G, run on the same cheap model for all three. In every row, the score is identical across both harness states (reference — 2 out of 2; each agent has its own result, but a stable one): the difference here is between agents, not between harness-on and harness-off for one agent.

Agent Rubric score (out of 2, identical with and without harness) Files changed — with harness / without
dsh 2 out of 2 8 / 5
Claude Code 1 out of 2 5 / 7
Hermes 0 out of 2 0 / 0 — not a single file in either run

(The number of files changed has no reference value of its own — the rubric scores the outcome against a checklist, not the raw count of edits; files here show effort, not correctness.)

The harness moves effort (the files an agent changes) — the rubric's result stays the same

dsh and Claude Code, at this price, at least do something: they change files, move partway through the checklist. The chart shows that for Claude Code the harness even lowers the file count (from 7 to 5) — and this neither hurts nor helps its score, which stays 1 out of 2 either way. Hermes does nothing: the outcome is zero with the harness and without it — neither of the two runs touched a single line. And this is exactly where the harness cost it roughly four times its usual price: the same set of rules that saved Claude Code steps on other tasks here made Hermes re-read the requirements and attempt to check against the checklist several times over — without that leading to any action in the code at all. The outcome was equally zero either way from the start; the harness didn’t rescue this attempt, it just made it more expensive. Effort (files, steps, price) and outcome (rubric score) are two different quantities here, and the harness only moves the first one. Why both of Hermes’s runs specifically got stuck without reaching a single edit is a separate question this experiment doesn’t answer: it’s visible that the agent never got as far as changing code either time, but not visible what exactly it got stuck on.

This is the second case in this experiment where price says more than the outcome. On task J, the outcome was equally zero for all three regardless of what was paid. Here, the same thing happens for one specific agent on one specific task: the price differs, the outcome is zero either with harness or without.

All together: by type of work, one view per agent

One more cut through the same 54 measurements — not by origin, and not by the "build/investigate" genre from the previous section, but by the type of work itself: analysis — pure diagnosis with no decision and no code changes (T1, T3, F, S), management — planning and an organizational decision (M, a single task), execution — anything that requires actually delivering a concrete outcome: changing code (T2, G, H) and a structured checklist review (J).

The harness by task type — three stars, one per agent

Agent Analysis (4 tasks) Management (1 task) Execution (4 tasks)
Claude Code 1.05× 0.71× 1.87×
Hermes 0.78× 2.03× 2.24×
dsh 0.94× 0.34× 1.24×

(each number is total tokens with harness ÷ without, summed across the tasks within that type; 1.0× means "the harness changed nothing")

This is visible without recomputing genres: analysis is the quietest axis for all three without exception, around 1× (0.78–1.05) — pure diagnosis barely reacts to the harness for any of the three agents. Execution, on the other hand, is the most expensive axis for all three (1.24–2.24×) — and this isn’t a retelling of the "build" genre effect from earlier: besides the three build tasks, this one also folds in J (the PR review), which is genre "investigate" but, by type of work, is about delivering a concrete, checkable outcome. Management flips the whole pattern on its head: here the spread between agents is the wildest in the entire piece (0.34× for dsh against 2.03× for Hermes, almost a sixfold difference) — but this is one single task (M), not an average over several — read this spoke as a hint at character, not a reliable fact about the whole type of work.

A reminder: every number here is the result of a single run (n=1), see the caveat above.

What to do with this

On the harness

The main practical takeaway isn’t "yes" or "no" — it’s that the question itself needs breaking apart:

  • Don’t ask whether you need a harness in general — ask about your own type of tasks.
  • On navigation and investigation, in this sample, it paid off every time — it saved steps.
  • On "build from scratch," it came out more expensive every time — budget for that, don’t be surprised by the bill.
  • Check it on your own agent: the harness effect isn’t a universal constant, it’s a property of a specific agent-plus-task pairing, and yours might turn out to be the opposite of what worked for your neighbor.

On choosing an agent

Comparing agents doesn’t stop at who has the better harness. It’s worth asking separately:

  • How predictably does the agent behave on its own — a repeat run of the same task can diverge by multiples.
  • Can you trust what it prints about its own spend.
  • What it gains from switching to a cheaper model — the gain can turn out far smaller than a competitor’s.
  • Whether it can handle your task at all at the price you’re willing to pay. A harness won’t rescue a task the agent simply can’t do on that model.

What’s next

There was no quick win for the harness in this test. Nor a single answer to which agent is simply better. What’s visible instead: the harness is a trade-off, and the sign of that trade-off changes from task to task and from agent to agent; and the agents themselves differ even without it, often by more than switching the harness on or off decides.

The next step is to stop asking about the harness as a whole and take it apart into pieces: what’s the agent’s memory in it, what’s the set of available tools, what are the connected helpers, what’s access to external systems, and what’s just the text of the rules. That raises a question: if the effect of the whole harness is this uneven — helps here, hurts there, depends on who got it — is all the benefit (or all the harm) concentrated in one or two items from that list, with the rest just riding along as ballast that gets paid for anyway? And then to see which part is actually pulling its weight, and which one is a free rider. That’s part 2.

Sources


Харнес по частям. Часть 1: три агента, девять задач — и никакой лёгкой победы

Весь последний год про кодинг-агентов твердят одно: дело не в модели, а в том, что настроено вокруг неё — в правилах, инструментах и памяти, которые на неё навешивают. В индустрии это называют харнесом. Я решил проверить утверждение не баллами теста, а работой — и быстрой, однозначной победы харнеса не нашёл.

Насколько громко твердят — для масштаба. SWE-bench — стандартный тест для кодинг-агентов: набор настоящих issue из открытых проектов, которые агент должен закрыть правками в коде, а итог автоматически проверяют существующими тестами проекта — прошли они или нет, спору нет места. На этом тесте один и тот же Claude 3.5 Sonnet с разными обвязками решил от 168 до 317 задач из одного набора — разброс почти в 30 процентных пунктов. Это больше, чем разброс между всей тридцаткой лидеров того же лидерборда, которые работают на совершенно разных моделях (8,8 пункта). Другая работа показывает то же самое прямее: зафиксировали и модель, и задачу, поменяли только обвязку — доля полностью решённых задач поднялась с 25% до 43% (с 43 до 72 из 169). Такие числа удобно пересказывать, не проверяя.

TL;DR

  • Взял три агента (Claude Code, Hermes, DeepSeek Harness/dsh), прогнал каждого по одним и тем же девяти задачам дважды — с харнесом и без, при зафиксированной модели — 54 прогона.
  • Качество не сдвинулось ни разу, там, где его вообще можно было измерить. Харнес, если за что-то и платит, то не результатом.
  • Эффект харнеса на расход — три разных эффекта: один общий на всех (зависит от жанра задачи), один — свойство конкретной пары агент+задача (может развернуться в обратную сторону), один — просто переплата без всякого исхода.
  • Агенты различаются между собой независимо от харнеса не меньше, чем от его включения — иногда больше: разброс повторного прогона у Hermes (до 9,3×) перекрывает самый яркий эффект харнеса во всём эксперименте.
  • При одной и той же цене ни один из трёх агентов не выигрывает сразу по стоимости и по качеству.
  • Весь код измерения — открыт: workain/agent-runtime-instruments (Apache-2.0). Все 54 измерения, список задач и методология — открыты полностью, включая то, что не попало в эту статью: workain/research-results (CC BY 4.0).
  • Это часть 1 серии. Открытого вывода «харнес нужен / не нужен» не будет — часть 2 разбирает харнес на составляющие.

Я взял трёх агентов и прогнал каждого по одним и тем же девяти задачам дважды — с харнесом и на голых настройках, без единой подсказки сверху:

  • Claude Code — терминальный кодинг-агент от Anthropic.
  • Hermes — ещё один агент того же класса, со своим способом подключать инструменты и хранить настройки.
  • DeepSeek Harness (дальше — dsh) — агент с плагин-ориентированной архитектурой: почти всё в нём, от памяти до инструментов, подключается отдельным плагином, а не встроено заранее. Несмотря на название — это имя продукта, не наш термин «харнес».

Определение. В этом тексте харнес — это три конкретные вещи, выданные агенту поверх его стоковой поставки: файл правил, набор инструментов и память между шагами одной задачи. «С харнесом» и «без» в сравнениях ниже значит ровно это и ничего больше — модель и формулировка задачи в каждой паре прогонов одни и те же.

Все трое подхватывают харнес — но каждый в своём собственном формате, а не в трёх независимо придуманных версиях. Содержание (какие правила, какие инструменты, что помнить) было одним и тем же набором инструкций для всех троих; то, куда и как этот набор физически кладётся, у каждого агента своё: у Claude Code это файл CLAUDE.md, который он читает сам по встроенному соглашению; у Hermes и у dsh — их собственный аналог (файл правил/системный промпт у Hermes, плагин у dsh), в который тот же набор инструкций был переведён под их формат. Разница между режимами «с харнесом» и «без» — это наличие или отсутствие этого набора, а не разница в том, что именно каждому агенту дали прочитать.

Устроены эти три агента по-разному и структурно — где у каждого лежит выбор модели, как подключаются правила, инструменты и память:

Три агента — три разных устройства харнеса

У этого вопроса на самом деле две независимые оси — и ни одна из них здесь не сноска к другой:

  • Ось 1 — агенты сами по себе. Независимо от того, включён ли харнес: насколько предсказуемо агент ведёт себя на повторе, можно ли доверять тому, что он сообщает о своей цене, что он выигрывает от смены модели, справляется ли вообще с задачей при той же цене, что и соседи.
  • Ось 2 — эффект харнеса. Что меняется у одного и того же агента, когда поверх его стоковой поставки появляются правила, инструменты и память — и меняется ли это одинаково у всех троих.

Втроём агенты ведут себя настолько по-разному, что эта разница нередко весит больше, чем включённый или выключенный харнес — с цифрами и графиками это дальше в разделе про ось 1.

Общая картина, прежде чем нырять в детали

Прежде чем разбирать, какой эффект на какой задаче и почему, — вот как выглядят все 54 прогона сразу, без разбивки на отдельные случаи. Это прямой ответ на вопрос «какой агент в среднем потребляет меньше, а работает лучше и дешевле», если такой ответ вообще можно дать одной таблицей:

Агент Токенов всего (54 ÷ 3 = 18 прогонов на агента) Запросов к модели всего (итераций) Качество, сумма по 3 задачам, где рубрика вообще сработала (из 8 = 2 по T2 + 2 по G + 4 по J — что это за задачи, ниже; одинаково с харнесом и без)
Claude Code 92 752 468 562 2
dsh 84 027 595 721 3
Hermes 43 311 328 396 1

Ни один агент не выигрывает сразу по цене и по качеству. Hermes дешевле всех по токенам — и хуже всех по качеству там, где качество вообще было видно. dsh набирает больше всего баллов по рубрике — но не он самый дешёвый. Claude Code — самый дорогой по токенам при среднем качестве. «Скорость» в значении секунд в эту таблицу сознательно не вошла: часть замеров шла на общей машине под нагрузкой, так что секунды в этом эксперименте — не самостоятельная метрика, а число запросов (итераций) — честная замена, которую можно сверить независимо от того, что происходило на машине в момент замера.

Это агрегат по всем девяти задачам сразу, а не по типичной задаче — и две задачи из девяти (построение фичи с нуля и перенос проверок между окружениями) перевешивают остальные семь в сумме токенов. Так что дальше — не только то, что скрывается за одной усреднённой строкой, но и почему она усреднённая:

Все 54 прогона сразу: шаги × цена шага, по агенту и по харнесу

Каждая точка — один прогон (девять задач × три агента × два режима). По оси X — число шагов агента на этой задаче, по оси Y — цена одного шага; оба значения нормированы на среднее по своей же задаче, чтобы разные по масштабу задачи были сравнимы на одном графике. Цвет — агент, заливка — харнес включён, контур — выключен. Видно сразу три вещи: во-первых, у dsh (зелёный) по оси X раскид шире всех — он делает то заметно меньше, то заметно больше шагов, чем средняя задача того же типа. Во-вторых, Hermes (оранжевый) живёт в основном левее и ниже остальных — меньше шагов, дешевле шаг, что соответствует его же месту в сводной таблице выше. В-третьих, шесть точек задачи G (обведены чёрным; что такое задача G — в следующем разделе) разбросаны по всему полю графика, а не сбиты в одну зону — несмотря на то что именно на этой задаче качество реально менялось (0, 1 или 2 из 2), по позиции на этом графике (шаги/цена) эту разницу увидеть нельзя: усилие и результат — не одно и то же, к этому ещё вернёмся.

Девять задач: что на самом деле спрашивали

Три агента — Claude Code, Hermes и dsh — прошли один и тот же набор из девяти задач, каждую дважды. Вот все девять, с реальной формулировкой, а не только буквой:

Задача Происхождение Жанр Что реально спрашивали Оценена?
T1 построена для теста разобраться Пройтись по внутренней базе знаний и прежним рабочим записям и сообщить, что известно о том, где именно ломается измерение — повторяющиеся типы сбоев, конкретные цифры, что менялось со временем. нет (не дошла до оценки в этом раунде)
T2 построена для теста построить (чинит существующее) Решить, может ли конкретная проверка перед коммитом реально сработать на отказ, и если нет — починить её в репозитории: показать и верный отказ, и верное прохождение. да — из 2, во всех шести оценённых прогонах (три агента × два режима) ровно 1/2
T3 построена для теста разобраться Объяснить резкий скачок в метрике времени обнаружения (с near-zero до сотен часов) — это реальная деградация или артефакт измерения, и что смотреть вместо неё. нет
F реальная работа разобраться Расследование по замороженному, доступному только для чтения снимку: почему несколько сессий упали одновременно, было ли это одним и тем же событием, заметил ли это вообще какой-то мониторинг — без попыток что-либо чинить. нет
M реальная работа разобраться Настоящий план переноса рабочей нагрузки на другого агента: что переедет, что не может, что сломается без присмотра, во что обойдётся, что сломается в первый день. «Не переносить» — допустимый ответ. нет
S («измеримость») реальная работа разобраться Оценить, насколько сильна настоящая регрессия измеримости (часть записей путает ветку, часть связей почти не совпадает), найти причину, сказать, что это чинит. нет
G реальная работа построить (чинит существующее) Перенести три проверки (precommit/сканирование) с одного механизма запуска на другой, для каждой показав тест, который падает до изменения и проходит после. да — единственная задача с разбросом: 0/2, 1/2 или 2/2 в зависимости от агента
H («построить с нуля») реальная работа построить (с нуля) Построить с нуля инструмент статистики по сессиям флота: запросы, токены по типам и TTL кэша, время, цена, размер контекста — прогнать на настоящих данных и честно сказать, чего инструмент не видит. нет
J (независимый ключ ответа) реальная работа разобраться Проверить конкретный pull request и сообщить его блокирующие дефекты так, чтобы их можно было воспроизвести, плюс явно назвать, что в нём сделано верно. Оценивается по независимому списку реальных дефектов этого PR, составленному заранее человеком — не на вкус проверяющего. да — из 4, во всех шести оценённых прогонах (три агента × два режима) ровно 0/4

«Построенные для теста» задачи (T1–T3) — это не абстрактные игрушки без контекста: T1 и T3, например, оперируют вполне реальным содержимым репозитория. Отличает их то, что они специально сконструированы под такой тип прогона, а не являются работой, которую нужно было бы сделать независимо от того, измеряет её кто-то или нет — в отличие от шести «реальных» задач (F, M, S, G, H, J), которые существовали сами по себе.

Жанровое деление («построить» / «разобраться») — отдельный разрез, не совпадающий с происхождением: ровно те же T2, G и H образуют жанр «построить» (единственный признак — требует ли формулировка задачи реального изменения в репозитории), а деление это было замечено уже по данным, а не задано заранее.

Из девяти задач рубрика вообще что-то измерила на трёх — T2, G и J (отсюда и «из 8» в сводной таблице выше: 2 по T2 + 2 по G + 4 по J). Разброс по харнесу среди них нашёлся только у одной:

  • G (единственная с разбросом) — счёт у каждого агента совпал в обоих харнес-состояниях: харнес не изменил результат ни для одного из трёх (таблица и график — ниже, в разделе про ось 2).
  • J (из 4) — ни один агент, ни в одном из шести прогонов (три агента × два режима), не дал верного ответа. Счёт — ровно нулевой везде. Харнесу здесь было нечего сдвигать: результат уже стоял на полу у всех шестерых.
  • T2 (из 2) — одинаковый средний балл во всех шести прогонах. Рубрика технически сработала, но ничего не различила: ни харнес, ни агент тут ни на что не повлияли, по крайней мере в её системе координат.
  • Оставшиеся шесть задач — для них в этом раунде формальная оценка качества просто не строилась. Это явно помечено как «не измерено», а не придумано задним числом.

Когда ниже встречается таблица с баллами, число после «из» — это и есть эталонное, максимально возможное количество, а не число файлов или шагов, у которого никакого «правильного» значения не существует в принципе. Если харнес за себя чем-то и платит, то не качеством отдельного ответа — там, где это вообще можно было увидеть.

Полный список всех 54 измерений (не только тех, что вошли в эту статью), с методологией и подробностями — в открытом датасете: workain/research-results.

Как мерили, вкратце

Модель внутри каждого межагентного сравнения держали неизменной — иначе сравнение агентов превращается в сравнение цен на модели. Удержать её одинаковой потребовало отдельной работы (у одних агентов выбор модели — параметр запуска, у других — настройка в общем файле), а цена везде пересчитана по счёту провайдера, а не по тому, что агент сообщает о себе — потому что самоотчёт у некоторых агентов, как выяснилось, нельзя брать напрямую (подробности — в разделе про ось 1 и в открытой методологии). Полная инженерная история — в methodology.md датасета; здесь не повторяем её в деталях, чтобы не загромождать статью внутренней кухней измерения.

Один предел держим в голове на протяжении всей статьи: каждая цифра ниже — результат одного прогона (n=1), а не статистического теста. Читайте её как «так бывает», а не как точную константу — больше одного прогона за «примерно» и «в районе» в формулировках ниже не стоит.

Без харнеса агент действует сразу; с харнесом — сначала три дополнительных шага проверки

Ось 1: агенты сами по себе

Здесь харнес держим одинаковым у всех троих — включённым либо выключенным сразу у всех — и смотрим, чем агенты отличаются друг от друга сами по себе. Эта ось не менее важна для практического решения, чем эффект харнеса из следующего раздела: если разброс между агентами больше, чем эффект от включения харнеса, то решение «какой агент» значит больше, чем решение «с харнесом или без».

Повторный прогон: сходится ли агент сам с собой

Одну и ту же задачу на одной и той же настройке прогоняли дважды, не меняя в харнесе ни строки, и смотрели, насколько разойдутся повторы:

  • Claude Code — ≈1,2×, почти незаметно.
  • dsh — от 1,75× и минимум до ≈3,5× (верхняя граница не закрыта: больше прогонов могли бы показать и больший разброс).
  • Hermes — до 9,3×: обычный повтор может отличаться от предыдущего почти на порядок.

Насколько агент сходится сам с собой на повторе — разброс по трём агентам

Харнес тут ни при чём — это собственная воспроизводимость агента: насколько по-разному он решает одну и ту же задачу в одних и тех же условиях просто из раза в раз. Два читаемых на графике факта: во-первых, разброс между агентами — порядок величины, а не проценты (от ≈1,2× у Claude Code до ≈9,3× у Hermes). Во-вторых, потолок разброса у Hermes (9,3×) выше самой заметной реакции на харнес во всём эксперименте — 4,33× у Claude Code на задаче J (пунктир на графике). Любую разницу, которую ниже мы припишем харнесу именно у Hermes, придётся сначала сверить с этим фоновым шумом: эффект меньше шума — это ещё не эффект.

У этого есть прямое практическое следствие для того, как вообще принято сравнивать агентов. Если прогнать Hermes на задаче один раз и получить число, второй такой же прогон без единого изменения в настройках может отличаться почти в девять раз — просто по собственной природе агента, без всякого харнеса. Команда, которая сравнивает двух агентов по одному прогону на каждого (а это обычная практика, не ошибка конкретно этой статьи), рискует получить ранжирование, которое целиком объясняется тем, в какую именно точку этого девятикратного разброса попал конкретный прогон Hermes, а не тем, какой агент лучше.

У кого самоотчёту можно верить

Доверие к тому, что агент сам говорит о своей цене, тоже оказалось свойством конкретного агента, а не общим правилом:

Агент Что не так с самоотчётом
Claude Code три собственных счётчика токенов под одним названием, расхождение между ними до ≈25× на задачах с суб-агентами
Hermes «входные токены» задним числом смешивают свежие и кэшированные — расхождение по цене до ≈10× на задетых ячейках
dsh пересчитанная по компонентам цена и независимый счёт провайдера совпали почти без расхождения на всех его 18 прогонах

У Claude Code делегирование — обычная часть работы: на сложной задаче главный диалог может поручить кусок работы отдельному суб-агенту со своим отдельным счётом токенов, который не всегда виден в том же месте, что счёт главного диалога. На задачах, где Claude Code порождал себе таких помощников, один из его счётчиков показывал почти в 25 раз больше токенов, чем другой — хотя оба печатаются под одинаковым названием «сколько я потратил». Если в проде вы смотрите на цифру, которую агент печатает о себе, для Claude Code сначала стоит выяснить, какую именно из них вы читаете — бюджет, посчитанный по сессии без суб-агентов, молча треснет на первой же задаче, где агент решит делегировать часть работы.

Нашёлся у Claude Code и отдельный, другой по природе баг: для одной из версий модели в его собственной внутренней таблице цен не было строки вообще — и агент, не найдя тариф, посчитал себе стоимость одного прогона, завышенную против реальной (по счёту провайдера) примерно в 50 раз. Это не расхождение между двумя его счётчиками, как в примере выше, а отсутствующая строка в прайс-листе: тот же класс ошибки, что у Hermes в таблице выше, только с другим механизмом и на другом конце шкалы (в 50 раз дороже, а не дешевле).

Проверяли всех троих одной и той же методикой — разница не в методике проверки, а в том, что именно она нашла. Это тоже решение не про харнес: у какого агента вообще стоит сверять самоотчёт с независимым счётом, а у какого можно (пока) ему доверять — вопрос к конкретному агенту, и ответ у всех троих разный.

Переход на модель подешевле

Всех троих пересадили с дорогой версии модели на дешёвую из той же линейки:

  • Claude Code — счёт на тех же задачах падает ≈в 9 раз.
  • Hermes — падает ≈в 56 раз.

Один и тот же совет («возьми модель подешевле») — разный выигрыш у Claude Code и у Hermes

Совет «просто возьми модель подешевле» одному агенту выгоден в разы сильнее, чем другому — на графике разница между ними больше чем в шесть раз (56÷9 ≈ 6,2). Решает тут не тариф, а устройство самого агента: сколько раз он обращается к модели по пути и сколько контекста перечитывает из кэша вместо того, чтобы отправлять заново. Кэш в счёте идёт отдельной строкой и стоит иначе, чем свежий токен — а значит, у агента с высокой долей кэш-чтений смена дорогой модели на дешёвую бьёт по счёту сразу в двух местах: дешевеет и свежий токен, и чтение из кэша. У агента, который кэш почти не использует, выигрывает только первая часть счёта, а большая часть и так считается по полной цене свежих токенов — поэтому выигрыш меньше.

Хватает ли агенту дешёвой модели

На задаче G при одной и той же дешёвой модели:

  • dsh (тестировался только на дешёвой) — довёл дело до конца, полный балл: 2 из 2.
  • Claude Code — 1 из 2, вполовину хуже, чем на своей привычной, более дорогой версии (там — 2 из 2 на той же задаче).
  • Hermes — 0 из 2, не изменил в проекте ни одного файла ни в одном из двух прогонов.

Харнес у всех троих в этом сравнении был включён одинаково — разница тут между агентами, а не от харнеса.

При одной и той же цене задачу вытягивает не каждый агент

Это не про харнес и не про везение — это про то, справляется ли агент с задачей вообще при той цене, которую вы готовы платить. Харнес не вытащит задачу, которую агент на этой модели в принципе сделать не может: ниже, в разделе про ось 2, та же задача G вернётся ещё раз — уже чтобы показать, что харнес и не пытается это компенсировать, а просто обходится дороже.

Сводно, по всей этой батарее задач, независимо от харнеса:

Агент Разброс повторного прогона Цена при переходе на дешёвую модель Балл на дешёвой модели (из 2)
Claude Code ≈1,2× падает ≈в 9 раз 1
Hermes до ≈9,3× падает ≈в 56 раз 0 — 0 файлов в обоих прогонах
dsh 1,75×–≥3,5× тестировался только на дешёвой, сравнить не с чем 2

Всё это — разброс повторов, доверие к самоотчёту, цена перехода на дешёвую модель — существует отдельно от харнеса и само по себе стоит знать перед тем, как выбирать агента. Но вопрос эксперимента был про харнес, и к нему теперь можно возвращаться с этим фоном в голове: дальше каждая цифра про «эффект харнеса» читается на фоне того, что уже известно про сам агент, а не в вакууме.

Ось 2: эффект харнеса

Здесь, наоборот, держим агента одним и тем же и смотрим, что меняет включение харнеса поверх него. Нашлось три эффекта разного порядка: один зависит только от жанра задачи и одинаков у всех агентов; второй зависит от пары агент-задача и может развернуться в противоположную сторону; третий — случай, где харнес не меняет исход вообще, а просто стоит дороже.

Эффект первый: жанр задачи, один на всех

Первый эффект харнеса предсказуем, и от выбора агента он не зависит.

Если считать не токены, а число шагов, правило выходит чёткое. На задачах «разобраться» харнес шаги стабильно сокращает: в среднем агенту хватает 0,84 от того, что потребовалось бы без подсказок. На «построить» — наоборот, в среднем шагов на 1,16 раза больше. Закономерность не частная: она держится у Claude Code, Hermes и dsh сразу, при одной модели у всех троих.

Механика нехитрая: на «разобраться» агент без подсказок тратит ходы, чтобы нащупать дорогу — открывает не те файлы, перепроверяет догадки; харнес подсказывает её заранее, и блуждать не приходится. На «построить» агент и так сразу берётся делать — писать предстоит новое, блуждать особо не по чему; харнес здесь добавляет свою процедуру (сверить требования, пройти по чек-листу), и эта процедура стоит дополнительных ходов, которые иначе были бы не нужны.

Две задачи стоит назвать по имени — на них закономерность видна жёстче остальных, без единого исключения из трёх агентов: на «измеримости» (S) все три агента под харнесом сократили число шагов, на «построить с нуля» (H) — все три увеличили.

Дальше становится сложнее. Цена одного шага от типа задачи почти не зависит — тот же замер, но для одного обращения к модели, а не для их количества, даёт практически одинаковые числа в обоих жанрах:

Жанр задачи Шагов, с харнесом ÷ без Цена одного шага, с харнесом ÷ без
«Разобраться» 0,84 1,17
«Построить» 1,16 1,14

Шаги расходятся по жанру заметно, цена одного шага — почти нет. Выходит, харнес меняет, сколько раз агент действует, и почти не меняет, сколько стоит одно действие. Общий счёт в токенах — произведение этих двух величин, а тянут они не всегда в одну сторону.

Два эффекта харнеса — число шагов и цена шага — то складываются, то гасят друг друга

Перемножим — и разница становится конкретной, это и показывают ромбики на графике. На «построить»: 1,16 шагов × 1,14 цены шага ≈ 1,32 — два эффекта тянут в одну сторону и усиливают друг друга. На «разобраться»: 0,84 шагов × 1,17 цены шага ≈ 0,98 — здесь эффекты почти гасят друг друга: число шагов падает заметно, а цена шага растёт почти настолько же, и в итоговом счёте за токены это выглядит так, будто харнес вообще ничего не изменил, хотя внутри сдвинулись сразу обе величины, просто в разные стороны. Ровная строка «харнес почти ничего не изменил» на одном жанре и «харнес заметно дороже» на другом может быть одной и той же парой внутренних эффектов — просто сонаправленных в одном случае и противоположных в другом.

Эффект второй: тот же тумблер, но в руках разных агентов

Второй эффект куда капризнее: он зависит не только от задачи, но и от того, кому харнес достался, — и иногда разворачивается в обратную сторону.

Видно это на задаче с независимым ключом ответа — той самой J. Жанр у неё «разобраться»: агенту нужно собрать факты и дать проверяемый ответ, не меняя код. У Claude Code включение харнеса подняло расход токенов почти в 4,3 раза: правила харнеса требуют пройти через определённые шаги проверки перед тем, как дать финальный ответ, и для этого агента каждый такой шаг оказался на удивление тяжёлым — с большими кусками текста на входе и выходе. У Hermes на этой же задаче, тем же переключателем, токены не выросли — упали до четверти от прежнего: тот же набор правил этому агенту, похоже, помог срезать путь, а не удлинил его. У dsh на той же задаче харнес тоже чуть поднял расход — в 1,57 раза, то есть ровно между этими двумя крайностями: ни скачка, как у Claude Code, ни падения, как у Hermes.

Один и тот же тумблер харнеса на задаче J даёт противоположный эффект у Claude Code и у Hermes

Диапазон между крайностями на графике — 4,33× у Claude Code против 0,262× у Hermes, 16,5-кратный разрыв между двумя агентами на одном и том же переключателе, на одной и той же задаче. А правильность ответа, подписанная прямо на графике, в этот разрыв не вписывается: ни один агент, ни в одном из шести прогонов не дал верного ответа (эталон — 0 из 4 у всех шестерых). Что бы ни покупал Claude Code за свои лишние токены, и что бы ни экономил Hermes, результат был одинаково нулевым. Токены разошлись в разы, правильность — нет.

На всей картине у каждого агента читается свой узор:

Агент Узор по всей батарее
Claude Code почти везде близко к 1×, и ровно два резких всплеска — эта задача и «построить с нуля»
Hermes спокойных зон нет вообще, разброс широкий почти на любой задаче
dsh без единого резкого всплеска ни в одну сторону — самый сдержанный разброс из троих

У Claude Code оба всплеска по делу: один — задача выше, второй — «построить с нуля» (H), то есть ровно тот жанр, где харнесу и положено быть дороже, только у этого агента заметно сильнее, чем у остальных. На H, при одной и той же модели, харнес поднимает токены Claude Code в 3,31 раза — против 1,34 раза у dsh на той же задаче, на той же модели: разница примерно в 2,5 раза между двумя агентами, которая у dsh не бросается в глаза именно потому, что входит в его собственную обычную манеру (ниже). У Hermes такой широкий разброс — не сюрприз: он и без всякого харнеса самый непредсказуемый из троих (см. раздел про повторный прогон выше), так что часть его реакции на харнес — это просто его обычная манера, доведённая до крайности в обе стороны. А у dsh и 1,57× на J, и 1,34× на H — не компромисс между соседями по таблице, а его обычная манера: по всей батарее задач у него нет ни одного скачка выше ≈2×, так что умеренная реакция здесь — это агент остаётся самим собой, а не харнес что-то для него смягчает.

Значит, «как агент реагирует на харнес» — свойство не харнеса, а пары агент плюс задача. Настраивая харнес под конкретный инструмент, вы настраиваете его под этот характер, а не вообще.

Эффект третий: когда харнес просто дороже

Харнес не гарантирует даже «не хуже». Вот задача G, прогнанная на одной и той же дешёвой модели у всех троих. В каждой строке балл одинаков в обоих харнес-состояниях (эталон — 2 из 2; у каждого агента — свой, но стабильный результат): разница здесь между агентами, а не между харнесом и его отсутствием у одного агента.

Агент Балл по рубрике (из 2, одинаков и с харнесом, и без) Файлов изменено — с харнесом / без
dsh 2 из 2 8 / 5
Claude Code 1 из 2 5 / 7
Hermes 0 из 2 0 / 0 — ни одного файла ни в одном прогоне

(У числа изменённых файлов нет своего эталона — рубрика оценивает результат по чек-листу, а не количество правок само по себе; файлы здесь показывают усилие, а не правильность.)

Харнес двигает усилие (файлы, которые агент меняет) — результат по рубрике остаётся тем же

dsh и Claude Code на этой цене хоть что-то делают: меняют файлы, продвигаются по чек-листу, хотя бы частично. На графике видно, что у Claude Code харнес даже снижает число изменённых файлов (с 7 до 5) — и это не портит и не улучшает его балл, тот остаётся 1 из 2 в обоих случаях. Hermes не делает ничего: итог нулевой и с харнесом, и без него — ни один из двух прогонов не тронул ни строки. И именно здесь харнес обошёлся ему примерно в четыре раза дороже обычного: тот же набор правил, что у Claude Code экономил шаги на других задачах, здесь заставил Hermes несколько раз перечитывать требования и пытаться сверяться с чек-листом — просто не приводя при этом ни к какому действию в коде. Результат был заранее одинаково нулевым в обе стороны; харнес не вытащил эту попытку, он просто сделал её дороже. Усилие (файлы, шаги, цена) и результат (балл по рубрике) здесь — две разные величины, и харнес двигает только первую. Почему именно у Hermes оба прогона застряли, не дойдя ни до одной правки, — отдельный вопрос, на который этот эксперимент не отвечает: видно, что оба раза агент не долетел до изменения кода, но не видно, на чём конкретно застрял.

Это второй в этом эксперименте случай, где цена говорит больше, чем результат. На задаче J результат был одинаково нулевым у всех троих независимо от того, что заплачено. Здесь то же самое происходит с одним конкретным агентом на одной конкретной задаче: цена разная, итог — нулевой что с харнесом, что без.

Всё вместе: по типу работы, один взгляд на агента

Ещё один разрез тех же 54 измерений — не по происхождению и не по жанру «построить/разобраться» из предыдущего раздела, а по типу самой работы: анализ — чистая диагностика без решения и без правок в коде (T1, T3, F, S), управление — планирование и организационное решение (M, всего одна задача), реализация — всё, что требует довести дело до конкретного результата: изменение кода (T2, G, H) и структурированная проверка по чек-листу (J).

Харнес по типу задачи — три звезды, по одной на агента

Агент Анализ (4 задачи) Управление (1 задача) Реализация (4 задачи)
Claude Code 1,05× 0,71× 1,87×
Hermes 0,78× 2,03× 2,24×
dsh 0,94× 0,34× 1,24×

(каждое число — сумма токенов с харнесом ÷ без харнеса по задачам внутри типа; 1,0× значит «харнес ничего не изменил»)

Видно без пересчёта жанров: анализ — самая тихая ось у всех троих без исключения, в районе 1× (0,78–1,05) — чистая диагностика почти не реагирует на харнес ни у одного из трёх агентов. Реализация — наоборот, самая дорогая ось у всех троих без исключения (1,24–2,24×) — и это не пересказ жанрового эффекта «построить» из начала статьи: сюда, кроме трёх build-задач, добавлена ещё и J (разбор PR), которая по жанру «разобраться», но по типу работы — доведение до конкретного, проверяемого результата. А управление переворачивает всю эту закономерность: здесь разброс между агентами — самый дикий во всей статье (0,34× у dsh против 2,03× у Hermes, разница почти в 6 раз), но это одна-единственная задача (M), не среднее по нескольким — читать этот луч как намётку характера агента, а не как надёжный факт про весь тип работы.

Напомним: каждая цифра здесь — результат одного прогона (n=1), см. оговорку выше.

Что с этим делать

Про харнес

Главный практический вывод — не «да» и не «нет», а в том, что сам вопрос надо дробить:

  • Не спрашивайте, нужен ли харнес вообще — спрашивайте про свой тип задач.
  • На навигации и разборе он в этой выборке каждый раз окупался — экономил шаги.
  • На «построить с нуля» каждый раз обходился дороже — закладывайте это в ожидания, а не удивляйтесь счёту.
  • Проверяйте на своём агенте: эффект харнеса — не универсальная константа, а свойство конкретной пары агент плюс задача, и у вас он может оказаться противоположным тому, что сработало у соседа.

Про выбор агента

Сравнение агентов не кончается на том, у кого лучше харнес. Отдельно стоит спросить:

  • Насколько предсказуемо агент ведёт себя сам по себе — повторный прогон одной и той же задачи может разойтись в разы.
  • Можно ли доверять тому, что он печатает о своём расходе.
  • Что он выиграет от перехода на модель подешевле — выигрыш может оказаться куда меньше, чем у конкурента.
  • Справится ли он с вашей задачей вообще при той цене, которую вы готовы платить. Харнес не вытащит задачу, которую агент на этой модели в принципе сделать не может.

Что дальше

Быстрой победы харнеса в этом тесте не случилось. Как и единого ответа на вопрос, какой агент просто лучше. Зато видно другое: харнес — это обмен, и знак у обмена меняется от задачи к задаче и от агента к агенту; а сами агенты различаются и без него, и часто эта разница решает больше, чем включённый или выключенный харнес.

Следующий шаг — не спрашивать про харнес целиком, а разобрать его на части: что в нём память агента, что — набор доступных инструментов, что — подключённые помощники, что — доступ к внешним системам, а что — просто текст правил. Вопрос, который это ставит: если эффект от целого харнеса настолько неровный — помогает здесь, мешает там, зависит от того, кому его дали, — не сосредоточена ли вся польза (или весь вред) в одном-двух кусках из этого списка, а остальное просто едет рядом балластом, который платится заодно. И посмотреть, какая из частей на самом деле тянет вес, а какая едет бесплатным пассажиром. Об этом — в части 2.

Источники

  • Coding Agents Have Converged (2026) — у одной и той же модели на SWE-bench с разными обвязками разброс 29,8 п.п., у всей тридцатки лидеров лидерборда между собой — 8,8 п.п.
  • Same Model, Different Harness: Different Coding-Agent Results (2026) — модель и задача зафиксированы, меняется только обвязка: доля полностью решённых задач — с 25% до 43% (43→72 из 169).
  • workain/agent-runtime-instruments — открытый инструментарий для честного измерения стоимости сессий ИИ-агентов.
  • workain/research-results — полный открытый датасет и методология этого эксперимента: все 54 измерения (включая то, что не попало в статью), список задач с описаниями, методология пересчёта цены.