Cost Per Finished Task

An earlier post here worked out the true cost of one LLM call. That number still matters, but it has stopped being the number that decides anything. Over the last quarter enough real projects published their actual bills that a better unit is now available: what did the finished thing cost.

Three published figures, all from the same window.

Bun paid 165,000 dollars to rewrite itself

On 8 July 2026 the Bun team published the accounting for porting their runtime from Zig to Rust. The work ran eleven days, 3 May to 14 May.

| | | | --- | --- | | API cost | 165,000 dollars | | Uncached input tokens | 5.9 billion | | Output tokens | 690 million | | Cached input reads | 72 billion | | Commits | 6,502 | | Lines in the merged diff | 1,009,272 | | Tests skipped or deleted | 0 |

Look at the cache line before anything else. 72 billion cached reads against 5.9 billion uncached ones. Roughly ninety-two percent of the input was served from cache. At uncached rates that job does not cost 165,000 dollars, it costs something closer to an order of magnitude more, and it probably does not get approved.

Caching was not an optimisation applied at the end. It is the reason the project was affordable enough to attempt.

The structure is the other half. They ran four workflows at once, each in a separate worktree, sixteen agents per workflow, peaking around sixty-four agents in parallel. Each implementer was paired with two or more adversarial reviewers in split context windows, and the existing TypeScript test suite acted as the conformance oracle. Nothing was graded on vibes. Either the old tests passed against the new implementation or they did not.

That last detail is what makes the number transferable. This was not an open-ended agent loop with a large budget. It was a mechanical translation with a machine-checkable definition of done, and that is the shape of task where spending six figures on tokens is a rational trade rather than a gamble.

Uber caps each engineer at 1,500 dollars a month

Around 2 June 2026, Uber set a limit of 1,500 dollars per employee per month, per AI coding tool.

The interesting part is the ratio. That cap is roughly eleven percent of median Uber engineering compensation. A company with every reason to be careful with vendor spend concluded that a tenth of a senior salary in tokens is defensible.

Read those two numbers together. Bun's rewrite, at 165,000 dollars, is about nine engineer-months at Uber's cap. It replaced a workload that would have taken considerably longer than nine engineer-months by hand, and it did it in eleven days of wall clock.

The comparison worth making is not tokens against zero. It is tokens against the salaried alternative and the calendar.

Smaller projects published their bills too

Two more, for scale:

• Firefox compiled to WebAssembly: roughly 25,000 dollars
• sqlite-utils 4.0rc2: 149.25 dollars

The sqlite-utils figure is the useful one for most readers. A release candidate for a real, widely used tool, for about the price of a nice dinner. The distribution of these costs is very wide and the low end is lower than people assume.

The benchmarks moved to the same unit

This is not just a vibe among practitioners. The evaluation work followed.

Harbor-Index, published 29 June 2026, distils 82 tasks from 6,627 candidates across 54 benchmarks, and it plots pass rate against reconstructed cost per run, priced at each provider's public API rates, with cost on a log scale. Not accuracy alone. Accuracy per dollar.

Senior SWE-Bench, 16 July 2026, grades code quality on under-specified real pull requests, and publishes cost per task alongside the score. The spread is the story:

| model | score | cost per task | | --- | --- | --- | | Claude Fable 5 | 29.1% | about 29 dollars | | GPT-5.6 Sol | about 63% of the leader's score | about 3 dollars | | Grok 4.5 | 17.2% | about 1 dollar |

The leader costs roughly ten times the runner-up to score about sixty percent more. Whether that is worth it is not a question a leaderboard can answer for you. It depends entirely on what a wrong answer costs you downstream, which is a property of your system and not of the model.

That is the whole argument for the unit change. Cost per token is a vendor fact. Cost per finished task is a fact about your system, and it moves when you change your retries, your review structure, your cache strategy or your definition of done.

What actually moves the number

From the published work, roughly in order of leverage:

1. Cache hit rate. Bun's ninety-two percent is the single largest factor in that bill. Anthropic shipped Prompt Cache Diagnostics to general availability on 8 September 2026, which reports why a given miss happened rather than only that it missed. Caching stopped being a footnote and became something you can observe and debug.
2. A machine-checkable definition of done. An existing test suite is worth more than a better model. Without one you pay for the work and then pay a human to find out whether you got it.
3. Adversarial review inside the loop. Two reviewers per implementer costs more per attempt and less per accepted change, because the failures are caught before they compound.
4. Task decomposition. Sixty-four agents in parallel only helps if the work splits. Mechanical translation splits well; open-ended design does not.
5. Model choice per step, not per project. The Senior SWE-Bench spread only pays off if you are willing to route cheap steps to cheap models.

One pricing divergence worth knowing

I have seen long-context surcharges described as an industry trend. They are not. They are a split between vendors, and it is a real one.

Anthropic made a one-million-token context window generally available on 13 March 2026 with no long-context price premium. OpenAI bills at two times and one and a half times above 272,000 tokens on GPT-6 Astra. xAI bills two times above 200,000 tokens on Grok 4.6.

If your workload genuinely lives in a large context, that is not a rounding difference. It is a structural difference in the bill, and it is a live disagreement between vendors about what long context should cost rather than a settled market rate.

The number to put on your own dashboard

Stop reporting tokens per day. It is a measure of activity, and activity is not the thing you are buying.

Report cost per accepted change: total spend over the period, divided by the number of changes that passed review and shipped. It falls when your cache improves, when your tests get better, when your review structure catches failures earlier. It rises when you are burning budget on work that gets thrown away.

It is also the only version of the number you can take to someone who controls a budget, because it is denominated in the thing they actually wanted.