AI Got Cheaper. Your AI Bill Did Not.

The price of machine intelligence fell by roughly ninety percent. Almost nobody’s bill went down.

Both halves of that sentence are true, and the space between them is where enterprise AI programmes are quietly losing money. The consensus is right about the first half. Inference genuinely got cheaper: dramatically, repeatedly, faster than most infrastructure ever has. The consensus is wrong about what follows from it. It assumes a falling unit price produces a falling invoice, and it does not, because the unit price was never the thing driving the invoice.

Volume was. Model choice was. Context length was. Verbosity was. Retries were. And above all, the absence of anyone measuring which of those was responsible.

So the question I keep being handed across the table, why is this so expensive when everyone says it is getting cheap, is the wrong question asked in good faith. The right one is shorter: what are we buying, and how would we know if it worked?

Most organisations cannot answer either half. Not because they are careless, but because they bought machine intelligence using the mental model they had for software licences. That model has no vocabulary for what they actually purchased.

The Flat Rate Was Never the Product

For two years, generative AI arrived dressed as software-as-a-service. One employee, one licence, one predictable monthly line. Finance understood that shape immediately, which is why it spread so fast, and why it is now failing so quietly.

A traditional licence costs the same whether the user opens the application twice a month or four hundred times. The marginal action is free. That is what a seat is.

Machine intelligence has no free marginal action. Every prompt is tokens. Every document dropped into context is tokens. Every reasoning step, every tool call, every retry, every validation loop the user never sees: tokens, counted and invoiced. Nobody is billed for computation; the meter reads in tokens, and the meter never stops. The cost is not a function of how many people have access. It is a function of how those people work: which model they reach for, how much context they hand it, how long it thinks, how much it writes back, and how often it runs again because the first result was not good enough.

Old: one seat, one predictable cost, usage irrelevant.
New: one seat, cost unbounded, usage is the entire variable.

The flat-rate subscription with effectively unlimited access was never an economic steady state. It was an acquisition price, underwritten by capital that expected the market to be captured before the accounting caught up. That phase is visibly ending. Credits, overage charges, usage-based tiers: providers are not becoming greedier. They are removing an abstraction that was hiding the real shape of the cost.

The abstraction never changed the economics. It only delayed the day you had to look at them.

Cheaper Per Unit. More Units. Many More Units.

Falling prices do not reduce spending on something people want more of. They increase it. Cheaper inference means more use cases clear the bar. Longer context windows mean bigger inputs become reasonable. Better models mean work that was not worth attempting last quarter is worth attempting now.

Cost per action falls. Number of actions rises faster.

But AI does something older efficiency stories did not. It does not only make existing work cheaper. It manufactures work that did not previously exist. A developer who wrote one implementation now asks for five and compares them. A legal function that sampled contracts now reads all of them. None of that was in last year’s budget, because none of it was possible last year.

Then there is the part almost nobody models. A chat exchange is legible: one prompt, one answer, one price. An agent is not. The user types a single instruction, update this feature, test it, prepare it for deployment, and sees one task. The infrastructure sees something else entirely. Analyse the request. Read the repository. Plan. Search the documentation. Generate. Run the tests. Interpret the failures. Repair. Re-run. Ask a second model to review. Repair again. Summarise. Twelve machine steps behind one human sentence, and the human has no idea whether that was four model calls or four hundred.

Three consequences follow, and each one breaks a different assumption in the business case.

Consumption multiplies. Agentic work consumes on the order of a thousand times the tokens of a chat exchange. Not thirty percent more. Three orders of magnitude.

Cost stops being a number and becomes a distribution. The same task, run twice, can differ by a factor of thirty depending on the path the agent chose. Your average looks reasonable. Your tail is where the money went.

The expensive part is not the answer. Roughly sixty percent of the cost of an agentic task is not producing the first result. It is checking, repairing and re-verifying it. This is the same shift I have written about in software engineering: generation became cheap and review became the work. Agents do not repeal that. They move part of the review into the machine, where you now pay for it in tokens, and leave the accountability with the human, where you still pay for it in salary.

You pay the machine to produce. You pay the machine to check its own work. Then you pay a person to decide whether to trust the result.

That can be an excellent trade. It is only an excellent trade if the business case counted all three.

A Token Is the Bill. It Is Not the Value.

The token became the unit of this conversation because it is the unit of the invoice. That is understandable, and it is a trap.

Two interactions cost the same. The first drafts an internal email somebody could have written in ten minutes. The second surfaces a contractual exposure that would have cost seven figures. Identical consumption, and no system in the building can tell them apart, because the only property they share is the one the invoice measures.

Which is why a dashboard showing spend by provider and business unit feels like control and is not. It reports consumption precisely and says nothing about whether it was warranted, and every lever that actually moves the number is invisible at that altitude.

The token is not even a consistent economic unit across the work you are doing. Text is billed by input and output tokens. Speech is billed by audio duration. Vision is billed per image or per feature. The moment a workflow spans more than one, token-to-token comparison stops being like-for-like, and real workflows always span more than one. Price the same task across providers and the spread runs to four or five times, with the cheapest option frequently not the one producing worse output. That difference is architecture, not quality.

Which brings me to the least visible price increase in this market. Newer model generations tokenize the same text into roughly thirty percent more tokens than their predecessors. Same document, same task, same headline rate per million: thirty percent more billable units. That figure appears on no pricing page. It appears in the migration notes of the developer documentation: precisely where a procurement team will never look, and precisely where an engineering team should have.

The rate held. The unit moved.

It is not the only clause of its kind. Caching discounts repeated input to roughly a tenth of the full rate. But the minimum prompt length that caches at all varies by model, so the same prompt caches on one model and silently does not on its successor. No error, no warning, full price.

Nobody hid either of these. Both are published, accurately, where the people integrating the model will meet them. That is my point. The information asymmetry in AI purchasing is not between vendor and buyer. It is between the people who read release notes and the people who sign contracts. In most organisations those are different people, and they do not meet.

Nobody Ever Climbs Back Down the Ladder

Almost every model catalogue has the same shape: a flagship at the top, a workhorse in the middle, something small and fast at the bottom. Roughly a factor of ten separates the ends of that ladder.

Almost every organisation defaults to the top of it and stays there.

The reasons are human rather than technical. The flagship is the one in the announcement, and the safe pick for an engineer who does not want to defend choosing something weaker. So the default silently becomes the standard, and now classification, extraction, summarisation, tagging and routing, high-volume work with low ambiguity, all run through the most expensive reasoning system on the market.

It is the procurement equivalent of taking the truck to go and buy bread rolls. The vehicle works perfectly. The economics are absurd.

The correct question is never which model is best. It is: what is the smallest, cheapest model that reliably meets this requirement? That has a different answer for every workload, which is why it has to be answered in architecture rather than in a one-off procurement decision. Small models carry the bulk. A confidence check identifies what is uncertain. Only the uncertain escalates. The most expensive model is reserved for the fraction of tasks where its additional capability produces additional value, and in that fraction it earns its price several times over.

Routing is not a cost trick bolted on afterwards. It is the difference between allocating intelligence deliberately and allocating it uniformly, and uniform allocation is the expensive kind. Nor is it theoretical. Routing has halved costs in controlled tests with no measurable quality loss. Context discipline has cut token use by more than half while reliability went up. Batch processing carries a flat fifty percent discount most organisations never claim. The levers multiply; pulling none of them means paying several times over for the same result.

The same discipline settles the self-hosting question, usually argued as conviction and actually arithmetic. Open weights are not free; the cost moved. Instead of a token invoice you hold GPUs, capacity planning, platform engineering, security, observability and an on-call rota. Model it honestly, including the roughly half of infrastructure cost that is not the GPU, and the break-even against managed APIs sits in the region of billions of tokens per month. Below that line self-hosting is more expensive and slower to operate; above it, materially cheaper.

Most organisations asking me whether they should self-host are well below the line. The honest answer is that they should not. Not yet. And that sovereignty, latency or data residency, not cost, are the arguments that would justify moving earlier.

The Question Before the Model Question

Everything so far assumes generative AI is the right instrument. Frequently it is not, and that assumption is the most expensive one in the category.

The pattern is easy to spot once you look for it. A team sees text and reaches for a language model. Sees an image and reaches for a multimodal model. Sees a repetitive process and reaches for an agent. None of that is architecture. It is fashion with a budget attached.

An anomaly in a metric series is statistics. A stable, well-labelled classification problem is usually better served by traditional machine learning, which carries its own training, hosting and retraining costs but answers each decision at a small fraction of what a general-purpose model charges for the same call. A scanned invoice is document AI. A defect on a production line is computer vision. A semantic lookup needs embeddings and retrieval, not generation.

The sequence in front of every use case is not which model, but this:

1. Is this a software problem?
2. Is it a rules or arithmetic problem?
3. Is it a statistical or classical machine-learning problem?
4. Does it need a specialised model rather than a general one?
5. Does it genuinely need generative AI?
6. If yes: what is the smallest model that clears the bar?
7. Which cases, specifically, justify the flagship?

Seven questions. Most projects start at six and never look up.

Using a frontier model to solve a deterministic problem is not innovation. It is architectural laziness with a monthly invoice.

The same test applies to agents. Several steps in a workflow does not make that workflow agentic. If the sequence is known, the rules are stable and the outcome is deterministic, a workflow engine is cheaper, faster, more reliable and auditable in a way an agent is not. Agents earn their cost when the system must handle genuine uncertainty: interpret changing context, choose tools dynamically, adapt when the first approach fails. That is a real and valuable category, and it is far smaller than current deployment numbers imply: of the companies running agents today, the share reporting tangible value from them lands repeatedly between a tenth and a sixth.

None of this is an argument against generative AI. I build with it every week. It is an argument for knowing what you are holding.

The Best AI Is the One You Never See

Handing an entire workforce a chat window is not an operating model. It is tool distribution, and the two get confused constantly.

General-purpose assistants are genuinely useful. But individual productivity and enterprise productivity are different quantities, and only one of them shows up in a result.

A person builds the presentation in an hour instead of a day. If the organisation still needs three alignment rounds and two approvals, the process did not get faster. A marketing team produces a hundred campaign variants. If the company can test five, the other ninety-five are not value. They are inventory.

And this is the finding I would put in front of every board that has already approved an AI budget. Wherever perceived productivity gains have been measured against real ones, the perceived gains come out larger. In one controlled trial, developers estimated they had worked around twenty percent faster than the measurement could support; the effect size has since been revised and remains unsettled, but the gap between belief and evidence did not close. Executives report the same asymmetry about their own firms, and I have yet to see a steering committee that accounts for it.

That gap is not dishonesty. It is what absorption looks like from the inside. The time was genuinely saved, and it went somewhere: into more output, more iterations, more review. Freed capacity that nobody deliberately redirected does not become margin. It becomes more work.

And tool distribution has a second cost that compounds quietly. Give everyone the capability and everyone builds: the same summarisation workflow, the same contract check, five times in five departments, by people who do not know the others exist. Every version burns its own tokens and none is reusable, because none was ever visible. Shadow AI is a silo with an invoice attached. Build the use case once, centrally, hand it to everyone: consolidation cuts build spend by thirty to fifty percent, and the solution stops being rebuilt and starts being improved.

A tool makes a person faster. Only a process makes an organisation faster.

Which is why the best AI in an enterprise is usually the AI nobody sees. Not a window where an employee negotiates with a model, but something inside the process at the point where work happens. It receives a defined input. It knows which context is relevant, because that was designed rather than pasted. It selects the model itself, against the requirement rather than against fashion. It respects quality and cost limits set in advance. It routes the exception to the person who should see it. It records what it did, and what happened next.

Invisible AI does not require every employee to become fluent in model selection, context engineering and token economics. The system makes those decisions once, by design, correctly.

Old: give people access to intelligence and hope productivity follows.
New: put intelligence in the process and measure what came out of it.

That is the difference between distributing a capability and changing how work is done, and only one of the two appears in the accounts.

You Are Measuring One Number. Four Are Missing.

Ask a room of executives what their AI costs and most can answer to the euro. Ask what it bought and the room goes quiet.

Roughly a third of organisations can track AI costs properly at all; more than one in ten first learn the number when the invoice arrives. And across roughly six thousand executives in four countries, nine in ten report no measurable impact on employment or productivity over the past three years. The same executives forecast significant gains for the next three. Both halves matter. This is not a technology that does not work. It is a technology whose effects nobody has yet found in their own numbers.

The visible figure, total spend, is the only one most organisations hold. Four others decide whether it was worth having.

Who. Consumption is not normally distributed, and budgeting as though it were is the first mistake. Roughly a tenth of your users will generate something like two thirds of your consumption; the top few percent will out-consume everyone else combined. Everyone who measures this finds roughly the same shape. A per-head average is therefore not a control. It is a number that is wrong for almost every individual it claims to describe.

Which. Which model served which request. Without this, an expensive-because-necessary call and an expensive-because-nobody-changed-the-default call look identical on the invoice.

What for. This is the one nobody has. Not the tool, not the team: the purpose. Which business process, which step in which workflow. I have yet to meet an organisation that can break its AI spend down by purpose across the enterprise. An entire product category is forming to sell exactly this visibility, which tells you it does not exist yet.

With what result. Cost per completed task rather than cost per token. Whether a human accepted the output, corrected it, or threw it away.

Uber burned its annual engineering AI budget within a few months, went looking for the corresponding gain, and could not establish a clear link between what its developers were spending on a coding assistant and any improvement reaching its customers. That is a sophisticated engineering organisation that could not connect spend to outcome. If they could not, the assumption that you can, without having built the measurement first, is not confidence. It is optimism.

None of this telemetry is technically hard. A gateway. A trace identifier that survives the call chain. A convention for tagging every request with the process it belongs to. That is a fortnight of engineering, not a research programme. It is missing because nobody specified it before the rollout, and retrofitting is expensive: attribution cannot be reconstructed for traffic that has already happened. The spend is in the ledger and the meaning is gone.

Cost monitoring is not a reporting exercise you add later. It is an architecture decision you make before the first prompt.

One distinction carries the whole discipline. Most cost controls sold today are alerts, and alerts are not controls.

An alert tells you money was spent. A guardrail decides whether it may be spent.

A budget that notifies somebody at seventy percent has prevented nothing. A guardrail sits in the request path and acts: downgrade the model, trim the context, cap the retries, stop the agent. For agentic systems this is not optional. An autonomous process without a spending limit, a step limit and a stopping rule is not autonomy; it is an open liability with a friendly interface.

And the cheapest token remains the one the model was never asked to read. Most context windows are packed the way a suitcase is packed the night before a flight: everything in, because sorting takes longer. Sending an entire repository or an entire conversation history is not context engineering. It is context dumping. Input is the bulk of the bill and output is billed at several times the input rate, which makes the two most effective levers available to you embarrassingly simple: send less, and ask for less back.

The Partner Test

Everything described here is buildable. Almost none of it gets built. That is a procurement problem as much as an engineering one.

An AI project is never only an AI project. It is an architecture project, an integration project, a data project, a security project and a change project, with a model somewhere in the middle, and the model is rarely the hardest part. That is the argument I made at book length in Strategy is Good. Execution is Better., and the two years since have not softened it. Organisations do not struggle to scale AI because the models are weak. They struggle because everything around the model was treated as somebody else’s job.

The barrier to demonstrating AI has collapsed. Anyone can connect a model API in an afternoon, produce a convincing agent demo in a week, write an AI strategy in a fortnight. The demo has stopped carrying any information about whether the supplier can operate the thing.

So the questions worth asking have changed. Not can you build it. Rather:

Can you tell me this does not need a language model, when it does not? Can you defend the choice between deterministic logic, classical machine learning, a small model and a frontier one, on cost as well as capability? Can you name where a human stays in the loop and price that honestly, rather than assuming it away? Can you put a guardrail in the request path instead of a notification in an inbox? And will you still own the economics when the pilot is forgotten and the fourth invoice arrives?

A supplier for whom every problem is a generative AI problem has not assessed your problem. They have described their own capability.

The most valuable thing an implementation partner can say is: you do not need AI for this. It costs them revenue in the moment and it is the clearest available evidence that they understood the problem. I have said it to clients; it is usually the reason the next conversation happens.

Mature buyers already ask for this. Tenders now carry explicit requirements for cost governance, token monitoring, guardrails and a documented model-selection rationale, evaluated rather than annexed. The market is correcting itself faster than most suppliers have noticed.

The Verdict

AI will keep getting cheaper. Models will get smaller and better, hardware will improve, competition will keep pressure on prices. None of it will fix this, because none of it touches what is actually broken.

Cheaper intelligence produces more consumption. More consumption produces more machine work. More machine work produces more output, more code, more agents, more things requiring review, and every one of those is a cost that arrives before the value does, if the value arrives at all.

Ten percent of your users will spend two thirds of your budget. Sixty percent of your agentic cost is the machine correcting its own work. Thirty percent of your token count may be a tokenizer nobody in the procurement chain has read about. None of those three numbers is on your dashboard today.

The organisations that come out of this well will not be the ones using the most AI. They will not hold the most agents, copilots or tokens. Those are vanity metrics, and mistaking them for achievement is how a budget disappears without leaving a trace.

They will be the ones that know which work should exist. Which work should disappear. Which work should stay human. Which problems need generation, and which needed a rule and a database all along. Which model is sufficient. What the process is allowed to cost. And who signs for the result.

The AI cost problem was never a pricing problem. It is an execution problem wearing a pricing problem’s clothes, and execution is where this was always going to be settled.