Nobody has figured out how to bill a coding agent

In the past year most of the companies selling AI coding tools have changed how they charge for them, and most of those changes went badly.

Cursor switched from unlimited use to a metered credit pool in the middle of 2025. For heavy users the effective price jumped sharply, the rollout was explained poorly, and it ended with a public apology and refunds. In June 2026 GitHub moved Copilot to token-metered credits. The monthly sticker price stayed the same, but usage now draws down a balance priced on tokens, and people quickly found that a single change request could cost several dollars and that one session could eat a low double-digit percentage of a month's allowance. Anthropic sells Claude on rolling five-hour windows plus a weekly cap, ran a temporary limit increase through the summer, let it expire, and is now facing a proposed class action arguing that the Max plans deliver far less than the number on the label.

Four companies, four different billing schemes, the same churn. When one company fumbles its pricing that is a mistake. When all of them do it at once, in the same direction, something structural is going on.

The tools changed from something with a bounded cost per use into something with an unbounded one, and the billing never caught up.

The unit of work moved

Autocomplete has a predictable cost. You accept a suggestion, the model generated a few hundred tokens, done. Chat is looser but still bounded. You ask a question, you get an answer, maybe a follow-up. In both cases the compute behind one thing you did is roughly knowable ahead of time, and it does not swing by two orders of magnitude between two things that felt the same to you.

An agent is not like that. Tell it to make the failing test pass and it reads files, forms a plan, runs a command, reads the output, edits code, runs the test, reads the failure, and tries again. One instruction from you becomes a loop, and how long the loop runs depends on how well the model happens to do. Three steps if it gets lucky, forty if it does not.

So the cost of a request is now a function of the path the agent took through the problem, and that path is not something you can see coming. It also correlates only weakly with anything you care about. A trivial task where the model gets confused and thrashes can cost more than a hard task it nails on the first try. You are not paying for the difficulty of the work or the value of the result. You are paying for how much the model flailed, which is the one thing neither of you controls.

There is a mechanical reason the numbers get large. Every step in the loop resends the conversation so far, and the conversation keeps growing. The files it read, the command output it got back, the stack traces, all of it becomes input on the next turn. The model's own reasoning is output you pay for whether the reasoning helped or not. Context piles up faster than the step count, and you pay for it again each turn. Caching claws some of that back when it engages, which you usually cannot confirm from the outside.

Every pricing model is a decision about who eats the variance

Once you see the cost as a high-variance number stapled to each request, the recent history stops looking like a run of unrelated blunders. It starts looking like four answers to one question. Given that one user's monthly compute might be ten times another's, and that nobody can predict it beforehand, who carries that risk, and how do they find out they are carrying it?

Per-token billing, which is where Copilot landed and what you get from a raw API key, hands the variance to the user. You pay for exactly what the machine did. That is fair and also useless for planning, because what the machine did is unknowable until it has done it. The old feel for "a request costs about a dollar" is gone and nothing replaced it. That empty space is what people mean when they say the bill was a surprise. It has a nasty side effect too: it makes agents, the workflow the vendor is pushing hardest, the single most expensive way to use the product.

Subscriptions with rolling windows, which is how Anthropic sells Claude, move the variance into a different currency. The price is fixed and knowable. The availability is not. You hit a wall partway through the afternoon because a five-hour counter rolled over, not because you spent a budget and not because you finished anything. Windows are a way to shape load. They let a company advertise a generous allowance while quietly capping the users in the tail, and they hold up fine until the advertised number and the delivered number drift far enough apart that someone sues.

Flat-rate, all you can eat, is the model everyone wants and the one that cannot survive agents. The moment a single user can point an unbounded amount of compute at a problem, one price means the heavy few are subsidized by everyone else, and the subsidy grows until it cannot. Then the vendor degrades quality quietly, or starts capping, or reprices in the open. Cursor in 2025 did all three.

None of these is dumb. They are three places to put the same unavoidable variance. Per-token puts it on your bill as a shock. Windows put it on your afternoon as a wall. Flat-rate puts it on the vendor until they shove it back to you all at once. The variance is real and it is large, and no scheme makes it disappear. They only differ in how the bad news gets delivered.

The fix is legibility, not a smarter scheme

If the trouble is that nobody can see the number, the thing that helps is not a new formula. It is showing the number.

Most of the anger in these episodes is not about the amount. It is about finding out afterward. A meter you can watch while the agent runs, counted in dollars, turns an unpredictable cost into a decision you get to make: keep going, or stop, I have seen enough. The prediction problem does not get solved, because it cannot be. It gets handed to the one party actually able to judge whether the next step is worth it, which is the person sitting there.

The same holds at the ceiling. When you run out, there are two honest moves and two dishonest ones. Asking what you want to do is honest. Cutting you off is honest. Charging you more without telling you is not, and quietly swapping in a worse model is not, and both happen constantly because they skip an awkward moment. The products people end up trusting are the ones willing to have the awkward moment.

Caching belongs on that list too, since on a long session it is a big part of the real cost. If most of your tokens are cache reads, you want to see that, because it changes what the session actually cost by a lot.

None of this removes the variance. It stops hiding it, and it turns out that hiding it was most of the problem.

Where this goes

The repricing is not close to done, because the thing driving it has not been fixed. An industry built its billing around chat, shipped agents, and is working out in public, one refund thread and one lawsuit at a time, that the meter no longer matches the thing being sold. The companies that come through this with users who still trust them will not be the ones with the cleverest pricing page. They will be the ones who showed you the meter and let you decide, instead of managing how you felt about a number you were never allowed to see.

Disclosure: I work on typed, one of the tools in this market. I kept this about the problem and not the product, because the problem is the interesting part and the product is not the point here.