LLM Token Economics Is Textbook Monopoly Behaviour

Hey everyone, welcome to the forty-first issue of The Main Thread. Let me ask you a simple question: have you ever thought your LLM bill is a microeconomics problem set? If not, this article will dive deep into that.

When you open any provider’s pricing page, the numbers look like a menu someone made up on a whiteboard. Input tokens cost one thing, output tokens cost 4x-5x more. There’s a model for almost every price point, separated by mysterious quality tiers. Prompt caching has its own line item. The biggest context windows cost extra per token, not just in aggregate. Batch jobs get a discount for being patient. It reads like arbitrary product management.

It is not arbitrary. Every one of those decisions comes straight out of the chapters in Varian’s Intermediate Economics on monopoly behaviour: 2-part tariffs, three degrees of price discrimination, bundling, versioning. The LLM-API business is a near-perfect natural experience in how a firm with market power and near-zero marginal cost sets prices. The economists wrote the playbook decades ago. The labs are running it, mostly without saying so.

This matters beyond trivia. If you build on these APIs, your cost structure is their pricing strategy reflected back at you. Understanding the strategy tells you which costs are negotiable, which are structural, where the prices are headed, and when you are being added into a segment you did not choose. The same lens that lets an economist read a pricing page lets an engineer make a build-vs-buy decision that is still right in months to come.

Let’s see what the pricing page looks like once you read it as economics.

Start with the most basic oddity: why do output tokens cost so much more than input tokens?

Across providers the ratio is remarkably stable, around 4x-5x the input. It doesn’t matter if your model is cheap or expensive, the ratio remains constant. OpenAI, Anthropic, Google all follow the same pattern. When an entire industry independently converges on the same price ratio, that ratio is encoding something real.

Part of it is cost. Input and output tokens are not the same good. Processing a prompt is prefill where the model ingests every input token in parallel in a single forward pass, GPU utilization is high, and the work is cheap per token. Generating a response is decode which is strictly autoregressive, one token at a time, each requiring a full forward pass that mostly reads weights from memory while the arithmetic unit sits idle. Decode is memory-bandwidth-bound and sequential; prefill is compute-bound and parallel. Output tokens genuinely cost more to produce. So far this is just marginal-cost pricing.

But cost symmetry doesn’t explain a 5x ratio: the underlying GPU-second gap is smaller than that. The rest is the demand side, and that is where it becomes economics rather than engineering. Look at the structure: to get any output at all, you must first pay to load your context. You can’t generate without prefilling. The input charge behaves like an entry fee: an admission price you pay for the privilege of using the model on your problem. And the output charge behaves like the per-unit-price of what you actually came to consume.

That’s two-part tariff. Walter Oi formalized it in 1971 as the “Disneyland dilemma”: a monopolist facing consumers with different appetites can extract more surplus by charging a fixed admission fee plus a per-ride price than by charging either alone. The fee captures the baseline willingness-to-pay; the per-unit price meters the heavy users. Splitting one product into an access charge and a consumption charge is a textbook way to price-discriminate without knowing each customer’s demand curve in advance.

This is not a stretch but it is worth being honest about where the analogy is loose. Input pricing is not a flat fee, it scales with prompt size, so it’s a metered admission, not a turnstile. The cleaner 2-part tariffs live elsewhere in the same pricing page:

This is the most literal version. You pay a premium to write a prefix to the cache (the admission), then pay a fraction (~10% of normal input price) to read it on subsequent calls (the cheap per-unit rate). The provider has reproduced Oi’s structure exactly: a higher up-front charge in exchange for a low marginal rate, which is precisely the deal that is optimal when usage is repeated and predictable.

The $20/month consumer tiers are textbook 2-part tariff with per-unit price hidden inside rate limits. You pay the fee; “usage” is rationed by caps rather than metered by price. When the cap binds, you have hit the per-unit wall.

They offer a ~50% discount for async, latency-tolerant jobs. This is not generosity but second-degree price discrimination by time preference, letting the provider fill troughs in GPU demand with price-insensitive workloads while charging real-time users a premium for the peak.

Practically, your bill has an access component and a consumption component, and they respond to different optimizations. Bloating context to “give the model everything” inflates the admission charge on every single call. Verbose output inflates the consumption charge. These are different levers because the provider deliberately priced them as separate goods.

Now, interesting stuff. Why does every provider ship a ladder: Haiku, Sonnet, Opus, Fable/Mythos; nano, mini, full instead of one model at once price?

Because a monopolist with one product leaves money on the table at both ends. Price high and you lost price-sensitive customers entirely. Price low and you forfeit the surplus of customers who would have paid more. Pigou’s classic taxonomy gives three escapes, and the labs use two of them.

Third-degree price discrimination charges different observable groups different prices for the same good via student discounts, regional pricing, enterprise contracts. The labs do this through enterprise agreements, volume commitments, and startup credit programs: same model, different price, sorted by who you are.

The model ladder itself is a second-degree price discrimination which is more elegant. Here the firm can’t observe your type, so instead of sorting customers, it builds a menu and let customers sort themselves. Varian said: design a product line so that each customer, choosing in their own self-interest, reveals their willingness to pay through which version they pick. The high-value customer who needs frontier reasoning self-selects into Opus and pays Opus prices. The high-volume classifier self-selects into Haiku. Nobody was told which segment they belong to; the menu extracted that information for free.

This is versioning, and Shapiro and Varian wrote about it in Information Rules (1998). Their insight, drawn from a world of information goods where the marginal cost of a copy is essentially zero, is uncomfortable: the optimal product line is built by degrading your best product to create the lower tiers. A faster, cheaper model isn’t only cheaper to serve; it is a fence. Its existence stops the price-sensitive segment from buying the frontier model, and its inferiority is what makes the fence hold. If the cheap tier were so good, your high-value customers would defect down to it, and the discrimination collapses. Economists call the binding requirement the incentive-compatibility constraint: each tier has to be just unattractive enough to the segment above it.

Deneckere and McAfee made this sharp in their 1996 paper literally titled “Damaged Goods”: sometimes a firm spends extra money to produce a worse version (for example: a chip manufacturer disabling working cores) because market segmentation is worth more than the cost of the damage. The LLM analogue is subtle, because the smaller models are genuinely cheaper to run so the labs aren’t paying to damage anything. But the placement of capability tiers, the decision about exactly how much worse Sonnet is than Opus and at what price gap, is a versioning decision governed by incentive compatibility, not just a cost plus calculation. The gap between tiers is set where it best sorts the customer, not where it reflects the FLOPs.

The tell is the price gaps themselves. They don’t track capability linearly. Opus might cost 5x Sonnet for a benchmark improvement that's nowhere near 5x on most tasks. This is the menu doing its job, pricing the willingness-to-pay of the segment that needs the top tier, which is far higher than the marginal capability would suggest. Basically, you are paying for being the kind of customer who needs it.

The versioning menu only works because demand for intelligence has a particular shape. The question that governs the whole market is: how elastic is demand for capability? When the price of the top model rises, who trades down, and how fast?

Price elasticity of demand is the percentage change in quantity demanded per percentage change in price. Demand is inelastic when buyers keep buying despite price hikes (for example: insulin, the frontier model your coding agent depends on) and elastic when they flee at the first increase (interchangeable commodities, the model doing bulk sentiment classification). The single most important fact about the LLM market is that elasticity is wildly different across use cases for what looks like the same product.

For a high-stakes, low-volume task - a coding agent making changes a human will merge, a legal document analyzer, a medical triage assistant - demand for the frontier model is steeply inelastic. The cost of a wrong answer dwarfs the token bill. Doubling the price barely moves the users, because the next best model is not a real substitute; the capability gap is load-bearing. This is where the labs earn their margin.

For a high-volume, error-tolerant task - classification, tagging, first-pass extraction, synthetic data generation - demand is brutally elastic. The token bill is the dominant cost, the quality difference between tiers is invisible in aggregate, and a 20% price cut from a competitor triggers instant migration. This is where labs have no pricing power.

Core Economics gives the rule that ties price-setting to elasticity directly. A firm with market power sets a markup over marginal cost that is inversely proportional to the elasticity of demand. It is called the Lerner Index.

The more inelastic the demand (ε), the fatter the markup a firm can sustain. This equation explains the modern ladder. The frontier tier serves inelastic demand and carries a huge markup over its GPU-second cost. The commodity tier serves elastic demand and gets priced toward marginal cost because anything higher sends customers to a competitor. Same company, same datacenter, opposite pricing logic because the elasticity of the served segment is opposite.

The interesting dynamics are at the kink; the point where a user actually downgrades. A few forces push users across it:

When the price gap between Sonnet and Opus widens, some marginal Opus users would substitute down. The labs watch this substitution carefully; it’s exactly the incentive-compatibility constraint from versioning, observed in the wild.

This is the under-appreciated one. A team that has built a rigorous eval harness can measure whether the cheap model is good enough for a given task, instead of guessing. Good evals make demand more elastic by turning “I am scared to downgrade“ into “the data says Haiku passes at 98% - switch”. Every team that invests in evals is, in economic terms, increasing its own price elasticity and weakening the labs’ pricing power over it. Evals are a commoditization engine.

For an individual query, nobody downgrades to save a thousandth of a cent. But at a billion queries a month, the token bill becomes a real budget line, and the firm starts behaving like a price-sensitive buyer, routing aggressively to smaller models, fine-tuning open-weights. Volume converts an inelastic per-query preference into an elastic aggregate one.

The strategic upshot for anyone building: your elasticity is a choice, not a fact. Lock yourself to one frontier model with no evals and no abstraction layer, and you have made your demand inelastic, which is great for the lab and bad for you. Build a router, an eval suite, and a provider-agnostic interface, and you have made yourself elastic, which is where buyer power lives. The labs price against your elasticity. Decide what it should be on purpose.

Why is the context window (a capacity, not a quantity consumed) a pricing lever at all? Why do the largest windows often carry a per-token premium above a threshold tiers rather than just costing more in total because you used more tokens?

Because a large context window is a bundle, and bundling is its own chapter in monopoly-behaviour playbook.

The foundational result is Bakos and Brynjolfsson's 1999 work on bundling information goods, building on Stigler (1963). The counterintuitive finding is when marginal costs are near zero, a monopolist can extract dramatically more surplus by selling a large bundle at one price than by selling the components separately even to customers who only want a few components. The mechanism is statistical. Customers have heterogeneous, idiosyncratic valuation for individual items, but by the law of large numbers their valuation for a big bundle converges toward the average. Heterogeneous demand for parts becomes homogeneous, predictable demand for the whole; and predictable demand is precisely what lets a monopolist set a single price that captures nearly all the surplus.

A long context window bundles capabilities you can’t easily price separately: the ability to stuff in an entire codebase, a long document, a fat RAG payload, a multi-hundred turn conversation, a pile of few-shot examples, and a sprawling tool catalog… all at once. No customer wants all of these. But across the customer base, the valuation for the bundle is high and tight, so “200K tokens of context, use it however you like” is a cleaner thing to price than à-la-carte capabilities would be. The provider sells one fence-line, the window size, instead of metering a dozen distinct uses.

The threshold premium on the largest windows is then mixed bundling (Adams and Yellen, 1976): a base bundle for everyone, a premium bundle for the segment whose valuation justifies it, and a price step at the boundary. It is also partly real cost (attention is quadratic in sequence length, so the longest contexts are genuinely more expensive to serve at the margin) but the discontinuity at the threshold, the sudden price step rather than a smooth ramp, is bundling-and-discrimination decision sitting on top of the cost curve. The labs are using window size as a fence between the segment that occasionally needs long context and the segment whose entire product depends on it. The latter is inelastic. Guess which one pays the premium.

For builders, the lesson mirrors the 2-part tariff one: context window is sold to you as an all-you-can-eat bundle, and pricing is designed to make you over-consume. The discipline of trimming context, summarizing instead of dumping, and retrieving the right 4K tokens instead of stuffing 200K isn’t only a latency win but it’s refusing to value the bundle the way the pricing wants you to.

Pricing power above marginal cost can’t survive competition unless something stops customers from leaving. In a market where the underlying good (next token prediction) in increasingly replicable, what keeps a customer paying a premium? The answer is the same one industrial-organization economics give for why dominant platforms persist: network effects and switching costs.

Katz and Shapiro’s 1985 work on network externalities describes goods that become more valuable as more people use them. Classic direct network effects (the telephone) don’t quite apply to a model, i.e, your Claude calls aren’t more valuable because mine exist. But the indirect, ecosystem-mediated network effects are powerful and growing:

Every framework, IDE plugin, agent harness, and orchestration library that supports a provider's API first makes that provider more valuable to the next customer. This is a two-sided market in the Rochet–Tirole sense: developers build for the model with the most users, and users pick the model with the most tooling. Each side subsidizes the other's growth.

A team's prompt library, fine-tunes, eval suites, cached prefixes, distilled student models, and hard-won prompt-engineering intuition are all calibrated to a specific model's behavior. These are switching costs, and switching costs are the same lock-in mechanism we see across infrastructure (it's why session affinity is so sticky, why a database migration never happens). Moving providers means re-tuning all of it. The cost is abandoning the investment in the old one.

Two models at identical benchmark scores still "feel" different: different verbosity, different failure modes, different prompt sensitivity. A product tuned against one model's quirks doesn't transfer for free. Capability parity does not imply substitutability, which is exactly why the Bertrand price-collapse (next section) is slower here than in a true commodity market.

Network effects and switching costs are what let the labs price above marginal cost in equilibrium. Without them, the near-zero marginal cost of inference would compete price straight down to the floor. With them, the market looks less like a commodity exchange and more like monopolistic competition: many sellers, different products, differentiated products, each holding a little island of pricing power carved out by its ecosystem.

The defensive move for a buyer is, again, to refuse the lock-in deliberately: keep an abstraction layer, keep evals portable, keep at least one credible alternative warm. Every switching cost you decline to accept is pricing power you keep for yourself.

Now the prediction, and it falls out of market-structure theory rather than vibes.

The LLM market is a high-fixed-cost, low-marginal-cost industry: the defining shape of information goods. Training a frontier model costs hundreds of millions; serving one more token costs a fraction of a cent. Shapiro and Varian’s central observation about information economics applies directly: “information is costly to produce but cheap to reproduce”. Industries with that cost structure don’t settle into tidy perfect competition. They tend toward concentration, differentiation, and persistent markups, because nobody can recover the fixed cost by pricing at marginal cost. That’s the gravitational field every prediction has to respect.

Within that field, the market is bifurcating, and the two halves obey opposite laws:

The commodity floor races toward marginal cost. For well-defined, eval-able tasks where multiple models clear the bar, the goods become near-perfect substitutes and the Bertrand model kicks in: with homogeneous goods and price competition, equilibrium price collapses toward marginal cost even with only two sellers (Bertrand paradox). We are already watching it. Per-token prices at fixed capability have fallen roughly an order of magnitude per year, driven by competition and by a hardware-and-algorithms cost curve that keeps pushing marginal cost down. Open-weight models are the Bertrand competitor that never blinks; they pin the price of “good enough” near the cost of GPUs to run them. At the floor, expect the race to zero to continue, and expect the labs to stop trying to make money there.

The frontier ceiling sustains monopoly rents. Capability is a moving target, and whoever holds the current best model holds a temporary monopoly on the tasks only it can do. This is called Schumpeterian "creative destruction", where the reward for innovation is a transient monopoly that the next innovation destroys. As long as the frontier keeps advancing, there's always a fresh band of inelastic, must-have-the-best demand carrying a fat Lerner markup. The rents are real but impermanent; they belong to whoever shipped the latest leap, and they evaporate the moment a competitor matches it. The frontier is a monopoly you have to re-win every few months.

From that structure, concrete bets:

Per-token pricing keeps falling at fixed capability, and stays expensive at the frontier. The two trends are not contradictory, but they are the floor and the ceiling separating. "GPT-5-class intelligence" gets cheaper every quarter; "the best model that exists" stays priced for inelastic demand.

Pricing shifts from tokens toward outcomes and subscriptions. Metering raw tokens is a commodity-market behavior, and commodities have thin margins. Expect more value-based pricing like per-seat, per-resolved-ticket, per-agent-run, per-successful-task, because outcome pricing decouples the bill from the collapsing token cost and re-anchors it to the customer's willingness-to-pay. This is the labs fleeing the Bertrand floor by changing the unit of sale.

Two-part tariffs and bundling intensify. As marginal token prices approach zero, the per-unit charge can't carry the business, so the fixed component grows: platform fees, committed-use contracts, "Pro" tiers, ecosystem subscriptions. When the per-ride price falls, you raise the admission.

Vertical integration and ecosystem lock-in deepen precisely because differentiated competition rewards it. The moat is the tooling, the agents, the memory, the distribution. Expect the labs to compete on ecosystem stickiness as aggressively as on benchmarks, because that's where durable pricing power lives once the model itself commoditizes.

LLM pricing looks arbitrary because most people don’t understand the vocabulary that makes it legible. Once you have it, the pricing page stops being a menu and becomes a strategy document. Input-versus-output is a two-part tariff. The model ladder is second-degree price discrimination through versioning, fenced by incentive compatibility. Context windows are bundling. Enterprise deals are third-degree discrimination. The whole markup structure is the Lerner index, pricing each segment by its elasticity. And the future of the market is written in the gap between Bertrand competition at the floor and Schumpeterian monopoly rents at the ceiling.

None of this is hidden. The labs didn't invent a new economics. They are running a very old one at a new scale, against a cost structure (enormous fixed cost, near-zero marginal cost) that economists have studied since the first software company shipped the first floppy disk.

When you pick a model, you are choosing which segment the menu sorts you into. When you fill a context window, you are accepting a bundle priced to make you over-consume. When you lock to one provider, you are handing them inelastic demand and the markup that comes with it. When you build evals and an abstraction layer, you are manufacturing your own elasticity, i.e., buyer power, in economic terms.

Your LLM bill is doing microeconomics whether or not you are. The only question is whether you are reading the same playbook the people who set the prices are reading.

What's the most economically-loaded LLM cost decision you have made without realizing it? I am collecting examples: model selection, context budgets, provider lock-in, the moment a team finally built evals and discovered the cheap model was fine all along. The patterns are everywhere once you start pricing them.

Hit reply. I read everything.

Namaste!

If this clicked, forward it to someone who lives in the API bill and someone who lives in a microeconomics textbook, they are looking at the same thing from different sides. And if you want more of this kind of cross-domain thinking, subscribe to The Main Thread: practical engineering from unusual angles, one essay per week.