The retry you pay for twice

Per-token pricing is sold as the fairest arrangement in software: you pay for what you use. It is fair in one direction only. The meter counts tokens in and tokens out, and it has no field for whether the answer was any good. A reply that misreads the question costs exactly what a correct one costs, and asking again costs that much a second time, plus the conversation you had to resend. We read the Claude, OpenAI and Gemini pricing pages on October 20, 2026. This essay is about the line item nobody budgets, which is the attempt that did not work.

The meter has no field for wrong

Start with the rates, because the arithmetic is the argument.

Claude Opus 5.5 is listed at $4 per million input tokens and $20 per million output tokens. Claude Sonnet 5.5 is $2 and $10. On OpenAI's page, gpt-6-astra is $10.00 and $50.00 in the short-context columns, and gpt-6.1-sol is $2.00 and $10.00.

Take a modest call: a 12,000-token prompt and a 2,000-token answer. On Claude Opus 5.5 that is about 4.8 cents of input and 4 cents of output, roughly 8.8 cents. On gpt-6-astra it is about 12 cents and 10 cents, roughly 22 cents. That is our arithmetic from the published rates.

Now suppose the answer is wrong. Nothing on either page reduces either figure. You ask again and pay again, and the second bill is the one the budget never contained.

The second attempt costs more than the first

A retry is not a repeat. It is usually a larger request than the one before it.

In a conversation, the history goes back with every turn, so the failed answer is itself input the next time unless you delete it. In an agent loop the tool results accumulate as well.

Anthropic's extended thinking documentation adds a wrinkle for the newest models: "Claude Opus 4.5 and models numbered 4.6 and higher keep prior turns' thinking blocks in context and bill them as input", where earlier models "stripped them".

So on current models the reasoning behind the attempt that failed is carried forward and charged again at the input rate. The improvement in continuity is also a cost.

Caching does not undo this. Anthropic prices a five-minute cache write at 1.25x the base input rate and a one-hour write at 2x, and notes that caching "pays off after one cache read for the 5-minute duration". A prompt that changes on each retry is a prompt you keep rewriting.

Reasoning is output, and that is where a bad run spends money

The most expensive tokens in a failed attempt are usually the ones you never see.

OpenAI's reasoning guide states that while reasoning tokens "are not visible via the API, they still occupy space in the model's context window and are billed as output tokens". Output is the dearer column on every page we read.

Google has stopped pretending otherwise in its table headers. On the Gemini API pricing page the column is literally labelled "Output price (including thinking tokens)".

For Gemini 4 Argon that column reads "$10.00 through November 30, 2026" and "$20.00 starting December 1, 2026", against input of $2.00 rising to $4.00. The doubling is printed on the page we read.

Anthropic exposes the same split for inspection rather than for mercy. Its documentation tells you to monitor a field that "reports how many of the billed output tokens were internal reasoning". Billed is the operative word.

OpenAI then states the worst case plainly. If generation hits the context limit or your max output setting, the response comes back incomplete, and "this might occur before any visible output tokens are produced, meaning you could incur costs for input and reasoning tokens without receiving a visible response".

That is a full-price attempt that returns nothing at all. It is also the cheapest warning in any of these documents, and it sits several screens below the price table.

Vendors do waive some charges, and never the tokens

The pricing pages are not indifferent to failure in general. They are indifferent to failure of the model.

Anthropic's page states that "If an error occurs during web search, the web search will not be billed", where a search otherwise counts at $10 per 1,000 uses. A tool that breaks is free.

Two paragraphs later the same page goes the other way on compute: "If files are included in the request, execution time is billed even if the tool is not called, because files are preloaded onto the container."

Put the two sentences together and the rule emerges. The vendor waives a charge when its own component returned an error, and bills everything that consumed capacity, including capacity consumed on your behalf by a decision you did not make.

A wrong answer is not an error in that sense. It is a successful request with an unsatisfactory payload, which is a category the meter cannot see.

The retries you did not write

Some retries are already happening in your stack without appearing in your code.

OpenAI's rate limits guide notes that "Each official OpenAI SDK automatically retries eligible 429 and 503 responses, subject to its retry settings", and warns that if you also manage retries yourself you should disable the SDK's "so nested retry loops don't multiply requests".

Anthropic's errors page gives the same advice for its own failure codes: a 500 should be retried "with exponential backoff", and a 529 means "The API is temporarily overloaded".

A refused request produces no tokens, so those retries are mostly a latency problem rather than a billing one. The dangerous combination is a nested retry loop around a prompt that returns incomplete, because that one bills on every pass.

What belongs in a retry budget

If you are pricing a workload rather than a request, four lines are missing from most estimates:

• A success rate. Divide your per-call cost by the share of attempts you actually ship. At 70 per cent, an 8.8 cent call is a 12.6 cent result.
• The resend. Each retry carries the history, and on Claude 4.6 and later the previous turn's thinking blocks are billed as input rather than stripped.
• Reasoning as output. Thinking tokens are billed at the output rate on all three pages, and Gemini 4 Argon's output rate doubles on December 1, 2026 per the pricing page.
• The incomplete response. OpenAI's own guide says you can be billed for input and reasoning with no visible output, so reserve headroom rather than discovering the ceiling in production.
• The batch alternative. Anthropic lists a 50 per cent discount on both input and output for asynchronous batch processing, which is cheaper than a synchronous second guess.

None of that requires new information from the vendor. All five numbers are on pages they publish.

Why pay per token sounds fairer than it bills

Metered pricing earns its reputation honestly. It removes the seat you were not using and the tier you had outgrown, and it lets a small team start at nothing.

What it cannot do is price quality, because the unit it counts has no opinion about correctness. A taxi meter at least stops when you arrive. A token meter runs the same whether the car reached the address or not.

This is the same structural point we made about capacity words in unlimited is a pricing word: the unit on the invoice decides what the vendor is accountable for. Tokens make throughput the product and leave outcomes outside the contract.

What follows in practice

Price a job, not a call. Run the real task, count how many attempts it took, and multiply. The number you get is the only one that matches an invoice.

Then look at where the attempts are being spent. The refill arithmetic sits in what a context window costs you, and the reason a tool that works in a demo needs three tries in a real process is the subject of the tool is not the workflow.

Per-seat and per-credit alternatives, with the dates we read them, are set out in our primer on AI assistant pricing for small teams and in our subject pages for ChatGPT, Claude, Cursor and GitHub Copilot. The two coding tools are set against each other in Cursor versus GitHub Copilot.

A retry is not an edge case. It is the normal cost of using a probabilistic tool, and it is the one cost no pricing page quotes.

Sources, read October 20, 2026: platform.claude.com pricing, extended thinking and errors documentation; developers.openai.com pricing, reasoning and rate limits guides; ai.google.dev Gemini API pricing.