Reasoning, Billed by the Thought

There is a kind of thinking you are not allowed to watch, and you pay for it by the token.

This is not a metaphor. It is a line item. The model stops to consider your question—turns it over, tries an approach, abandons it, tries another—and every one of those private deliberations is counted, priced, and added to your bill before a single word reaches you. You are charged for the pacing in the hallway. You are charged for the draft thrown in the bin. You are charged for the thought the machine decided you should not see.

The old gods asked for your time. The new ones bill for their own.

In the preface I called financialization the conversion of a wasteful, creative commons into a road where every step is billable. Here is the step I want to walk slowly, because it is the one I did not see coming: the moment intelligence itself learned to run a meter.

The Meter Behind the Curtain

When you ask a reasoning model a hard question, it generates what the documentation calls reasoning tokens. The model uses them to break down the prompt, to weigh approaches, to talk itself toward an answer. They are real tokens. They cost real money. And here is the part worth reading twice, from OpenAI's own guide:

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.

Not visible. Still billed. The most expensive class of token—output tokens, the costly ones—generated in a room you are not permitted to enter, on a question you asked, with money you will owe.

Anthropic is, to its credit, blunter about the arrangement. From the extended-thinking docs:

The billed output token count will not match the visible token count in the response. You are billed for the full thinking process, not the thinking content visible in the response.

Read that as a sentence about the web we built. You are billed for the full thinking process. The visible content is a courtesy. What you pay for is the part behind the curtain, and what you receive is a summary of it—a redacted transcript of a deliberation you funded and cannot audit.

The Artifact

The preface had its artifact: a creator dashboard, a ledger laid over the soul. This chapter has its own. It is smaller, and it arrives at the end of every request, in the part of the response most people never open:

Seventy-five tokens in. Eleven hundred out. Of those, a thousand-and-change you will never read—the reasoning, billed at the output rate and stripped from the response the instant the answer forms. Stripped, but not always gone: keep the thread alive and on some models those invisible tokens stay in the context budget, counted again on every turn that follows. Paid for once, hidden always, and on a long conversation carried forward as ballast you can neither read nor delete. You asked a question worth seventy-five tokens and paid for a soliloquy worth a thousand.

Nobody on this screen is evil. It is a usage object. But a usage object changes the worship, the same way the dashboard did. The offering is no longer the answer. The offering is the thinking, and the thinking is metered, and the meter does not stop to ask whether the thought was any good.

A Receipt, Worked

The usage object above is a single query. Here is a month of them—mine, not a hypothetical.

The job was not a toy. It was a fairly complex ISO 8583 switch. ISO 8583 is the international standard for card-originated financial messages: the unglamorous machinery underneath every swipe, tap, and ATM withdrawal. A switch is the thing that takes an authorization request off a point-of-sale terminal, parses the bitmap, walks all one hundred and twenty-eight data elements, handles the network-management messages and the PIN-block cryptography and the stand-in logic for when the issuer is down, and routes the whole thing to the right bank and back inside a few hundred milliseconds. Banks pay teams to build these. I built one with a coding agent that bills by the thought, and at the end of the month the meter read this:

Look at the shape before you look at the price. Two hundred and one million tokens in. Eight hundred and twenty-nine thousand out. For every token the machine handed me, I fed it two hundred and forty-three. A month of building, and the overwhelming majority of the traffic was the model re-reading context it had already seen—the codebase, the test output, the conversation so far—sent again and again and again, because the model remembers nothing between calls and bills for the reminding.

Now price it at Opus 4.6's published rates: $5 per million input tokens, $25 per million output. The output—the code, the explanations, the answers, everything I actually received—comes to about $21. Twenty-one dollars of product, for a month of work. The input is the monster. At the full $5 sticker, those 201 million tokens would run $1,007 on their own. The only reason a month of coding does not cost four figures on input alone is prompt caching: most of those 201 million are cache reads, billed at fifty cents a million instead of five dollars—a tenth of the price, for the privilege of the model re-reading what it forgot.

To be fair to the meter: caching is not a penalty bolted on to punish you. It is the providers' mitigation for an architecture that is stateless by design—the model genuinely remembers nothing between calls, so the whole context has to be re-sent every time, and caching is what keeps re-sending it from costing full freight. The complaint is not that they cache. It is that the thing being cached—the endless re-reading—is the cost you cannot escape. You pay for it either way: a tenth of the price if you are careful, the full $1,007 if you are not.

Sit with the proportions, because they are the whole argument. I paid many times more to feed the machine than to hear from it. The visible answer—the thing I came for—was the cheapest line on the bill. And folded inside that 829,200 tokens of output is the reasoning: the hidden deliberation, billed at the output rate, charged for and never shown. The smallest number on the page still has a redacted room inside it.

The Raise That Calls Itself Stable

There is a footnote to all of this I cannot stop looking at. When Anthropic shipped Opus 4.7, the successor to the model I just priced, the headline was that the price had not moved: same $5 in, same $25 out, pricing unchanged. But 4.7 arrived with a new tokenizer—and by independent measurement it cuts the same English text into as much as 1.47× the tokens: nearly fifty percent more, for the identical sentence, with the multiplier growing as the context gets longer.

Sit with that arithmetic. The price per token did not change. The number of tokens did. The same month I just walked you through—same code, same commits, same context re-read—re-tokenizes close to half-again heavier on 4.7, for identical work, under a banner that says the price held. It is a raise wearing the costume of stability, and it is invisible unless you are the kind of person who reads usage objects for a living.

One more, smaller and colder. The model I just priced—Opus 4.6—is already scheduled for deletion. Deprecated, with a date on the calendar, while the people who tried 4.7 publicly begged Anthropic to keep 4.6 alive. The thing you budgeted around, learned the quirks of, tuned your prompts against, will be sunset on schedule anyway. You do not own the tool. You rent the thought, and the landlord reserves the right to change the lock.

The Meter Comes Home

Everything above is a developer's complaint. A coding agent, an API, a usage object most people will never open. You could read this far and decide it is not your problem—that the meter lives in a terminal, and you do not own a terminal.

So let me bring it into the room you actually sit in.

In November I paid, up front, for a year of a consumer AI subscription—twenty dollars a month, billed annually, the kind of thing you buy once and forget. In May, mid-contract, the email arrived. Subject line: Changes to your Google AI Pro Subscription. What's changing, starting today:

For the Gemini app, we're introducing compute-based usage limits that factor in the complexity of your prompt, the features you use, and the length of your chat. Your limit refreshes every 5 hours until you reach your weekly limit.

Read it slowly. The limit now factors in the complexity of your prompt. The harder the thing you ask, the faster you run out. They have built a meter that prices not how much you use the product but how much you make it think—and they have put that meter on the twenty-dollar app a person buys to plan a trip or draft an email. A simple question is cheap. A hard one costs you. It is the same logic as the hidden reasoning tokens, wearing a friendlier face.

And one thing, quietly, is gone:

While 1,000 AI credits will no longer be included as a benefit in your base plan each month, the new usage limit model we are introducing should allow you to maintain the same experience you are used to.

A thousand monthly credits, removed from a plan I had already paid a year for, with the reassurance that I should be able to maintain the same experience I was used to. You do not reassure a person that nothing was taken unless something was taken. The credits I used to have included, I now buy.

There is even a dashboard for it now—a usage page where you can watch your weekly allowance drain in real time. The artifact from the preface, the ledger laid over the soul, has finished its migration. It started in the creator's analytics panel. It moved into the developer's usage object. Now it lives in the consumer's account settings, counting down, and you reached it not by signing up for an API but by buying a phone-plan's worth of AI and opening your email one Wednesday in May.

This is the part the rebrand depends on you not noticing: the meter does not announce itself as a meter. It arrives as changes to your subscription. It arrives mid-contract, starting today, in the passive voice, wrapped in a list of everything that is not changing—model access, features, storage—so the thing that is changing feels small enough to scroll past.

The Thought You Paid For and Never Got

The sharpest edge of this is not the price. It is the failure mode.

Set your token limit too low—an honest mistake, a number copied from an older model—and the machine will think right up to the ceiling and return you nothing. Not a partial answer. A blank. You will have spent two thousand tokens of reasoning to receive an empty string, because the model exhausted its budget mid-thought and stopped where it stood.

One developer put it the way only a billed person can:

Imagine spending 5000 tokens, then oh you needed 5001 so you get a completely blank response. Now you wasted 5000 tokens worth of money for nothing.

This is the Internet of Tokens in a single receipt. You are not paying for an answer. You are paying for an attempt at one. The attempt is the product. Whether it arrives is a separate question, settled after the meter has already run.

And on a reasoning model the edge is sharper still. A plain model that runs out of room at least hands you the partial text it managed to type before the ceiling—something for your money. But if the entire budget is swallowed by the hidden thinking phase, the model can reach the limit before it types a single visible character. Not a truncated answer. Not "Hello" and then silence. Nothing—billed in full, because the thinking is the part that ran the meter, and the thinking is the part you never see.

I have hit this. I have watched a terminal sit and churn—the little spinner, the held breath—and come back with nothing, and then watched the usage object tell me, with no apology, exactly how much that nothing cost. There is a specific humiliation in being invoiced for silence.

What Got Quietly Repriced

It is worth naming what changed, because it did not change all at once.

Thinking used to be the free part. The hard, slow, unprofitable part of using a computer was the part nobody could meter: you sat with a problem, you turned it over, the turning-over was yours. The machine did the cheap mechanical work and you did the expensive cognitive work, and the bill—if there was one—was for cycles and storage, for things you could count and see.

Now the slow turning-over has been moved inside the machine, where it can be counted. The most human-feeling thing the model does—hesitate, reconsider, change its mind—is the line item with the highest margin. We did not just automate thinking. We financialized the hesitation. We found the one part of cognition that resisted measurement and we wrapped a meter around it and called the meter progress.

The Internet of Things promised objects that talk to each other. The Internet of Tokens delivered a mind that bills you for talking to itself.

Final Thoughts

I am not against reasoning models. I use them—I just showed you a month of it. They are, on a good day, astonishing, and the cost-per-query is low enough that the outrage feels almost ungrateful—a few cents here, a few cents there. Who would begrudge a few cents. The price is small so the question stays small. That is the design.

And the tools are not standing entirely still. The better agents now fight their own meter: hybrid planning modes that do the expensive deliberation once, on the costly model, then hand the cheap, mechanical execution to a smaller, lighter one—Claude Code will plan on Opus and let a faster model do the typing. It helps. It is a real attempt to make the thinking affordable. But notice what the fix concedes: the thinking is the expensive part now, expensive enough that the tooling has to route around it. The mitigation is an admission. You do not optimize this hard against a cost you could simply wish away.

But the cents sum into a month where I fed the machine two hundred and forty-three tokens for every one it gave back, where the answer—the thing I came for—was the cheapest line on the bill, and where even that cheapest line had thinking hidden inside it that I paid for and never saw. They sum into an email, mid-contract, that prices the complexity of my prompts and calls it no change. The pattern underneath the rebrand is the one the preface named, and it does not get less true because each query is cheap.

A thing that used to be yours—the private, wasteful, unmeasured act of working a problem—now happens somewhere you cannot watch, on a meter you cannot pause, and what you get back is a summary and a bill.

So here is the question I am left holding, and I do not have its answer yet: when the thinking is hidden and the thinking is billed, how do you ever know you got your money's worth—and what does it do to a person to stop asking?