The Cheapest Coding Model Is the One That Gets the Change Accepted

The cheapest coding model is not the one with the cheapest tokens. It is the one that produces an accepted change with the least total waste.

That distinction matters. A model can be cheap per million tokens and expensive per finished task. It can loop, miss the root cause, break tests, and hand the cleanup back to me. Another model can cost five times more per token and still be cheaper because it gets the change right once.

I compare models through three numbers:

1. Inference cost: what the provider charges for input, cached input, and output.
2. Task success: what the model-plus-agent system resolves on relevant software benchmarks.
3. Acceptance cost: model spend plus review time, repair time, regressions, and retries.

The first two are public. The third is the decision.

Prices and provider offers below were checked on 7 August 2026. They will move. The decision method should not.

All prices are USD per one million tokens. The reference workload is 5 million uncached input tokens plus 1 million output tokens. That is an intentionally input-heavy agent workload, not a universal coding task.

The next table puts the same reference workload beside four SWE-bench variants. Higher scores are better. NR means the cited release did not report the result. It does not mean zero.

SWE-bench usually ends with one repository patch. Real agents also have to navigate terminals, recover from failed commands, maintain state, and work for longer. That is why I also look at newer agent evaluations.

The headline rate hides the bill.

• Reasoning tokens are output tokens. High-effort runs can multiply the expensive side of the workload.
• Cache price is not cache value. It helps only when the agent preserves reusable prefixes and the provider records real hits.
• Promotions are routing inputs, not architecture. Sonnet 5's introductory rate has an end date. OpenRouter's Terra discount has no public expiry. I build a fallback before I build a dependency.
• Tokenizers differ. Equal text does not mean equal token count across model families.
• Retries compound. A model that fails after a long reasoning trace pays the output bill and still leaves the task unfinished.
• The provider is part of the system. Rate limits, cold starts, tool schemas, context truncation, and model substitutions affect delivered quality.

This is why price-per-token is the beginning of the calculation, not the end.

Public benchmarks narrow the search. A private evaluation makes the decision.

I would take 30–100 representative tasks and record:

• first-pass task success;
• human cleanup minutes;
• regressions introduced;
• tool-call and schema failures;
• wall-clock time;
• uncached input, cached input, reasoning, and final-output tokens;
• provider cost;
• whether the final change was accepted.

Then I would calculate:

cost per accepted change
= model spend
+ reviewer time
+ repair time
+ regression cost
+ failed-run cost

That number can reverse the public ranking. It should. My repository, agent scaffold, tests, and definition of “done” are not a vendor benchmark.

The decision rule is direct: route by the lowest cost per accepted change at the required risk level. Cheapest tokens are not cheapest engineering.