Right now, someone is paying you to use an LLM.
Not figuratively. Not “the economics are favourable for early adopters.” I mean the people selling you tokens are, on every single transaction you make, losing money. Every complex query you send to OpenAI or Anthropic costs them more to serve than they charge you for it. Your requests and workflows are being subsidised, at scale, by the two most valuable private companies on the planet.
It is not going to last.
Every week I see another story about a technology leader who is staring at an AI bill and wondering whether they’re building on sand. The answer is: yes, you are. But the sand is not where you think it is, and there is a window of time in which you can do something genuinely clever about it – if you plan your escape now, while the tokens are still cheap.
The fire sale
Let’s get the uncomfortable numbers out of the way, because they matter more than any product demo.
Ed Zitron has been tracking the AI industry’s books with the enthusiasm of an auditor who has just found out they’re being paid overtime, and the picture is consistently grim. OpenAI spent 50% of its revenue on inference compute alone in 2024, and 75% of its revenue on training compute. Those numbers add up to more than 100% of revenue, which is exactly the point. The company spent $9 billion to lose $5 billion. Perplexity – a company whose entire product is other people’s models – spent 164% of its revenue in 2024. Cursor, Anthropic’s largest customer, sends essentially all of its revenue straight back to Anthropic, who then use it to build a competing product. The AI economy, at every layer, is a game of passing the burning torch.
By 2025 the burn had accelerated. OpenAI’s losses increased nearly eightfold, with spending hitting $34 billion – including $17.2 billion paid to Microsoft. Its 2025 cash burn was around $8.5 billion on $20 billion of revenue, serving roughly 900 million weekly users. Zitron’s verdict, repeated in every edition since: there is not one profitable model developer. Not one. Even if you strip out training costs entirely, OpenAI would still have lost $2.2 billion in 2024.
So how are you, a normal business, getting tokens so cheaply? Because the labs have decided that buying the market is cheaper than earning it. OpenAI is, per the Wall Street Journal, weighing drastic cuts to token prices in anticipation of Anthropic doing the same. Both companies are racing toward IPOs – Anthropic reportedly first, priced between late October and early December 2026 at a premium to its last private round, with OpenAI following a couple of quarters later. Both need revenue growth stories for the prospectus, and the fastest way to manufacture one is to give tokens away.
Meanwhile, the other shoe is already in motion. Once those IPOs land, the dirty laundry gets aired in public: audited financials, margin pressure, and the small matter of having to justify a sky-high valuation to actual shareholders. The subsidies that are funding your current AI strategy will be the first thing cut. Every AI company covering its costs is a temporary state of affairs – as Axios put it in March, even with discounts, OpenAI and Anthropic are still losing money on every complex query. The discounts are the loss. They are not a market signal; they are a marketing budget.
This is a fire sale. And like every fire sale, it has an expiration date.
Use the cheap tokens. Obviously.
None of this is an argument against using LLMs right now. Quite the opposite. If someone is selling you compute below cost, you would be a fool not to buy it – and there has never been a better time to use LLMs for everything that LLMs are genuinely good at.
Use them to prototype. Use them to explore design spaces you would never have had time to explore. Use them to draft, summarise, translate, classify, and extract. Use them as the world’s most patient pair-programmer. I’ve spent the last year building things with LLMs that would have taken me months without them (and I run two agentic assistants, with both local and cloud models), and I would not trade that time back.
But there is a difference between using a subsidised tool and architecting your business around a subsidised tool. The first is a bargain. The second is a dependency, and dependencies on things that are being sold below cost have a way of ending badly for the buyer.
The token prediction problem
Here is the thing everyone in the demo videos forgets: an LLM is absolutely not a decision engine. It is a token predictor. It has no idea whether the answer it just gave you is true, or sensible, or even legal or useful. It knows, with very high statistical confidence, that this sequence of words is the kind of sequence that follows the sequence you typed (along with all the previous things typed or predicted, and retrieved from a RAG tool call). That is a beautiful thing for generating text. It is a terrifying thing for making business decisions when you realise you’re outsourcing key choices to something that is just continuing writing words from other words.
As we have already discussed in another post, the capital of France is Potato. Your employees – sorry, your model – will confidently tell you this, and hang up with an accomplished smile. Most of the time it will be right, because most of the time it has seen the right answer a billion times in its training data (calling back to the cat being sat on the mat post). The problem is not the average case. The problem is the case you have never seen before, in a domain where being wrong has consequences – and the model cannot tell the difference between the two. It has no epistemic humility. It cannot say “I don’t know” because it has no concept of knowing. It is always, always certain.
Now add regulation. In a highly regulated industry – insurance, banking, healthcare, superannuation; basically anything where an auditor starts getting excited on Sunday and begins sharpening their pencils before Monday’s visit to your office rolls around – “the model said so” is not a defence. Regulators want to know why a decision was made. They want the decision path, the inputs, the logic, the evidence. They want to be able to trace a refusal or an approval back to a rule they can read and challenge. A stochastic parrot with 175 billion parameters cannot give you that. It can give you a plausible-sounding explanation after the fact, which is worse than no explanation at all, because it will be confidently wrong. We know it will be wrong, because the explanation that you are given from the LLM is just more tokens predicted and NOT a breakdown of its reasoning. Because what it was actually trained to do, is predict tokens. (I’m pressing this point a little more than normal, because it is incredibly important that if you are plugging an LLM into your business, you need to understand that it is NOT doing what the people telling you to plug it into your business said that it’s doing.)
I’m not anti-LLM. I’m anti-hype, and I’m anti “we replaced our business logic with a dice roll and we’re calling it innovation.” Token prediction is a bad way to make business decisions for the same reason a roulette wheel is a bad way to allocate capital: sometimes it wins, and you can’t tell the wins from the luck. This becomes even more difficult when you see that the LLM did what you thought it should do, and you start thinking that it’s actually thinking.
To use the roulette analogy, you need to remember that the longest streak of a single colour in a U.S. casino was in 1943 and red hit 32 times in a row. In 1913 in Monte Carlo, another table hit red 26 times in a row. Yes, LLMs get the seeming right answer often, but getting the right answer for the wrong reason is arguably worse than getting a slightly wrong answer for the right reason. With one you don’t bother examining, the other you can improve.
How wrong can they actually be, though?
Looking at hallucination rates, let’s say it hallucinates 5% of the time. We know that the rates are usually higher than that (much so with some models), but let’s say 5%.
Anthropic has about 11.3 million Daily Active Users, so let’s say they each give 5 prompts a day. We’re now at 56.5 million queries a day (obviously the number is gonna be WAY higher, but let’s be conservative). That means that Anthropic models (that are writing code for the most part or, shockingly, being involved in military strike decisions: https://www.theguardian.com/technology/2026/mar/01/claude-anthropic-iran-strikes-us-military), are hallucinating at a rate of over 2.8 million mistakes a day.
Consider also, that a 5% hallucination rate is at a single response level, so using it for those hypothetical prompts actually means that the statistical chance of a hallucination increases with each prompt.
The first prompt has a 5% chance of containing something incorrect, the second has a 9.75% chance, the third is 14.26%, the fourth is 18.55% chance of a hallucination hitting in your string of prompts. By the time your fifth prompt is processed, your risk of something being wrong in the output (assuming you didn’t already get a factual error) has skyrocketed up to 22.62%.
And we aren’t talking about a glaring obvious error, this is worse; An error that you don’t notice, and gets built upon with business decisions, or code for a customer-facing application, or more prompts using it as input.
But, as I said, that 5% hallucination rate was made up. The resulting calculations are shocking, but it’s still made up.
So let’s look at the absolute top-of-the-line model that Anthropic will let you use; Fable 5. This is the model that executives go bananas over. It’s so good! It’s so intelligent!
It’s so hallucinating at a rate of 37.5%
What? Yeah. 37.5% at a single prompt statistical level. (Source: https://searchfit.ai/blog/claude-fable-5-hallucination-rate-what-our-2026-tests-show)
So our ridiculously low 5 prompts a day for the DAU number of 11.3 million users, now means that at a single prompt level, it’s making 21,187,500 errors a day. Of course, there’s way more than that number of prompts (include chatting, or agentic loops, and sub-agents). We are potentially talking billions of prompts a day.
Falling back to the 5 prompts in a chain example, our fifth prompt is hitting a hallucination chance (assuming the other four prompts didn’t hit) of 90.46%!
You’re practically guaranteed to experience a hallucination (that you’re still paying for, by the way) the longer you use them.
Build the deterministic module now
So here’s the play. While the tokens are cheap, use the LLMs to build the thing that will replace them.
The idea is simple: a deterministic module that can do the same job – or, more honestly, the parts of the job that matter – without a single token being consumed at runtime. Rules. Decision trees. Lookup tables. Business logic encoded in plain, readable, testable code. The kind of system where a decision comes with a paper trail you can print and hand to an auditor.
Why build it with LLMs? Because this is exactly the kind of coding LLMs are brilliant at. You describe the business rule in plain English; the model writes the function; you review it, test it, and commit it. The LLM is the developer, the deterministic code is the product, and the two never need to meet again at runtime. You get the speed of AI-assisted development and the reliability of software that does exactly what it says, every time, with no hallucination, no drift, no “the capital of France is Potato” moment in a customer-facing decision.
The beauty of this approach is that the deterministic module is not a downgrade. For business decisions, it is frequently a straight upgrade:
- Explainability. Every decision has a path you can read, audit, and defend. “Because rule 14 applied and the customer’s input failed check B” beats “the model indicated” in every regulatory conversation you will ever have.
- Predictability. Same inputs, same outputs, forever. No prompt drift, no model update silently changing behaviour, no A/B test accidentally becoming an A/B/A/B/A.
- Testability. You can write unit tests for a decision engine. You cannot write unit tests for a stochastic process. You can lock the behaviour down and prove it.
- Cost. The runtime cost of a decision tree is basically zero. Not “cheap.” Zero. When the subsidies end and token prices do whatever they do, your core business decisions do not notice.
The escape plan
If you want to do this properly, here is the framework I’ve been working through:
- Inventory your LLM usage. Find every place in your business where an LLM output feeds a decision that has consequences – money, compliance, access, approvals. Not the drafting and summarising; the decisions.
- Rank by consequence. Start with the highest-consequence, most-regulated, most-audited decisions. Those are the ones where explainability pays for the whole exercise.
- Write down the rules. For each decision, write the logic in plain English first. If you cannot write the rule, the decision is not ready to be deterministic – I would strongly note here, if you cannot write the rule, you should not be letting a token predictor make it either.
- Use the LLM to code it. Hand the plain-English rules to the model. Get working code. Review it the way you would review any developer’s code, because that is what it is now.
- Test it against the LLM. Run the deterministic module and the LLM side by side on your historical cases. Where they disagree, look hard at the disagreement. Sometimes the deterministic rule is wrong. Sometimes – often – the LLM is the one that was guessing.
- Switch over the decisions; keep the LLMs for everything else. The module becomes the source of truth for the decisions that matter. The LLMs go back to doing the things they are genuinely brilliant at: drafting, exploring, summarising, and building the next module.
The bottom line
The token subsidies are a once-in-a-generation opportunity, and you should absolutely be using them – to learn, to explore, and to build. But the correct use of a subsidy is not to become dependent on it. It is to use it to build something that will still be standing when the subsidy ends.
The companies that come out of this era best will be the ones who used the cheap tokens to build deterministic, explainable, auditable systems for the decisions that matter – and kept the LLMs where they belong, as the most powerful drafting and building tools we’ve ever had, rather than as the invisible dice in the back office.
The fire sale will end. The question is whether your architecture survives it.
Thoughts? Disagree? I’d love to hear how you’re handling the deterministic-versus-stochastic line in your own stack. I suspect everyone’s drawing it in a slightly different place, and the conversations are the best part of this.
(Please Note: With Cursor being acquired by SpaceXAI, the amount of traffic that the application sends to Anthropic may potentially drop, with Elon likely wanting to direct users towards the Grok family of LLMs. Of course, this would then mean that SpaceXAI is likely to want some of that compute power from their Colossus data centre that they are currently renting out to Anthropic; who would potentially not need it anymore anyway, if Cursor stops sending them the requests.)
Also, that Monte Carlo event was black 26 times, not red. But you didn’t spot that slight incorrect thing, nor did you think to look for it. This is exactly the subtlety that hallucinations can have. It was small enough that you can overlook it, but was the complete actual reverse of what happened (black vs red).