# The harness decides what a token costs

- Author: Geoff (geoffsdesk)
- Published: 2026-10-16
- Canonical: https://www.geoffsdesk.com/human/blog/harness-tax
- Tags: token-economics, ai, agents, infrastructure

> Put the same model in three different agent harnesses and the bill moves 1.5 to 2x on average and 5x at the extremes while the success rate barely changes. The price of a token is no longer set where the price list says it is.

The [Token Economics report](/human/token-economics) has tracked two prices since September: the list price of the newest frontier model, which keeps rising, and the price of a fixed capability, which falls about 13x a year. Both are real. Neither is what an agent pays. This essay is about the third price, the one the harness sets, and the new chart on the report page that tracks it.

![Where an agent's tokens go: the harness loop, the request shape it produces (142,016 input tokens against 444 output), and the serving stack that holds the cache](/images/harness-tax-diagram.svg)

## Same model, different bill

A harness is everything wrapped around the model call: the loop that decides what to do next, the tools it can reach, what it keeps in context between turns, what it throws away, how many sub-agents it spawns and where their code runs. Claude Code is a harness. Codex CLI is a harness. Cursor, Pi, Aider, OpenHands and the scaffolds METR uses to measure time horizons are all harnesses. A source-code study of eleven of them published in July found none of them imports a general agent framework and none of them uses vector retrieval. They are bespoke loops around grep, a file editor and a shell.

The same model behaves very differently inside them. A September study from Berkeley and Arena put seven models through three harnesses on the same coding tasks. Success moved by two to five points. Cost per attempt moved 1.5 to 2x on the geometric mean and 5x on the widest pair: GPT-5.6 Luna solved a SWE-bench Lite task for 3 cents in Pi and 15 cents in Claude Code. The reason is on the first call. Pi sends about 2,600 tokens before the user has said anything. Codex sends about 15,000. Claude Code sends about 27,000.

Vendors know this and now compete on it. Cursor cut its users' token cost 7% in September with harness changes alone: a system prompt trimmed by two thirds, tools loaded only when needed, cache misses cut by a fifth. AWS claims its Strands harness runs the same models for 28% less, a figure I would treat as a direction rather than a result until the paper arrives, since AWS marked its own homework. Anthropic's own write-up of a long-running build is the clearest illustration. The bare single-agent run took twenty minutes and $9 and the central feature did not work. The full planner, generator and evaluator harness took six hours and $200 and worked. The harness is where the money goes, in both directions.

## What an agent actually buys

Look at what the serving stack sees and the reason becomes obvious. SemiAnalysis published a trace of 393 Claude Code sessions in August. The median request carries 142,016 input tokens and produces 444 output tokens, a ratio of about 320 to 1. A separate study of about 4,300 Claude Code and Codex sessions found 95.7% of input tokens were a replay of a prefix the server had already seen, and that cached prefix tokens were 59.5% of the cost of a session, fresh input 29.2% and output 11.2%.

So the thing an agent buys, over and over, is the right to re-read the same context. The price of that right is not the input price on the list. It is the cache-read price, and that number has been falling faster than anything else in this market. When prompt caching launched in August 2024, Anthropic and DeepSeek charged a tenth of the input price for a cached token and OpenAI, two months later, charged a half. Today Opus 5.5, Sonnet 5.5, GPT-6.1 Sol and Meta's Muse Wonder charge a twentieth, Fable 5.1 charges a fortieth and DeepSeek V4.1 Flash charges a fiftieth. The new chart on the report page tracks this ratio by provider. Every provider with an agent product has cut it in the last twelve months.

The volume followed. On OpenRouter, agents overtook humans in tokens in February 2026 and by September were producing about seven times as many. The share of agentic tokens served from cache went from about 60% in January to just under 90% in September. OpenRouter's own worked example: a million agentic tokens at Sonnet 5 prices cost $2.08 without caching and $0.51 with it.

## Why the list price stopped mattering

Put those together and you get the number that I think matters most this year. Ramp, which sees what businesses actually pay on their cards, reports the effective price per million tokens peaked at $1.15 in March 2026 and was $0.68 by August, a 41% fall. In the same months the list price of every frontier model either held or rose. Nobody cut a price. The bill fell anyway, because the harnesses got better at reusing context and the providers priced the reuse close to its marginal cost.

That is the third speed. The ceiling holds, the floor collapses, and the price actually paid sits between them and is set by engineering rather than by the price list. It also explains something the first essay left hanging. Anthropic can say Opus 5.5 costs 40% less per task than Opus 5 at a lower token price and fewer tokens per task; OpenAI can say GPT-6.1 Sol does near-Astra work at a fifth of Astra's price. Those are harness claims as much as model claims. The cheapest way to make a model cheaper is to stop sending it the same 140,000 tokens at full price.

## Who collects

If the bill is set by cache reuse, the margin goes to whoever holds the cache. For a provider that is the KV cache in accelerator memory and the host memory behind it, and the routing that sends the second turn of a session to the machine that already has the first. The published engine work this year is almost all about that layer: prefix-aware routing worth two to three times round-robin, cache tiers that spill to RAM and SSD when the accelerator fills, peer-to-peer cache transfer so a prefix can move between machines in a few hundred milliseconds instead of being recomputed. SemiAnalysis found that above about twenty concurrent agent sessions every winning configuration on NVIDIA hardware offloads cache to host memory, and that the card with 50% more memory kept 91% of the working set on chip where the smaller one kept 73%. The bottleneck for agents is memory capacity, not compute.

For a buyer it means the harness is a procurement decision. Two teams on the same model and the same seat price can pay a 2x different bill depending on whether their harness keeps a stable prefix, loads tools lazily and compacts context before it overflows. The routers already do this at the request level; Cursor reports frontier-quality results at about 60% lower cost by sending only the hard turns to the expensive model. I expect the next version of that to be a harness that is priced by what it saves.

## The counterarguments

One of the counter arguments to be made is that cache reads are a discount the labs can withdraw. They set the ratio and they can raise it. I do not think they will, because the ratio tracks their own cost: a cached token costs them memory time, not compute, and the labs that run the biggest agent products have the most to gain from keeping the reuse cheap. Anthropic's bundled subscriptions are reported to be about 10% of its revenue and over 40% of its inference compute, which is only sustainable if cached tokens are nearly free to serve.

The second is that the trace studies are coding agents, and coding is the most prefix-heavy work there is. True, and coding is also where the volume is. Coding agents are the majority of agentic tokens on every router that publishes a breakdown, and the always-on agents launched this autumn by OpenAI, Meta and Google run the same loop over email and browsers instead of repositories. The ratio will be lower for them. It will not be chat-shaped.

## What to watch

Three numbers on the report page will say whether this holds. The cache-read ratio for the newest flagship at each provider: if it keeps halving with each generation, the effective price keeps falling without a single list-price cut. The share of agentic tokens served from cache on OpenRouter: it is just under 90% now, and the gap to 100% is the last cheap gain. And Ramp's effective price per million tokens, which is the only public number that measures what the harness, the cache and the router together actually did to a bill.

I built the routine that updates this report so I could watch those numbers move without reading the press releases. The list price is the number the labs want you to look at. The harness decides what you pay.