The Non-Linear Rise of AI Tokens: Why Cheaper Intelligence Creates More Demand

The Smallest Unit in the Largest Buildout in Tech

The most important unit in artificial intelligence is almost invisible.

A token is a small piece of data processed by a model: part of a word, a number, a punctuation mark, a fragment of code, or a patch of an image. Model providers use tokens to measure how much information enters and leaves their systems. Developers use them to estimate cost. Infrastructure companies ultimately have to turn them into computation, memory traffic, networking demand, and electricity.

For the first generation of generative AI products, tokens behaved like metered messages. A user asked a question, a model returned an answer, and the interaction ended. It was natural to imagine demand growing with the number of users: twice as many users, roughly twice as many prompts, roughly twice as many tokens.

That model is already obsolete.

Token usage does not rise in a smooth line because the way tokens are used keeps changing. A chatbot may make one model call. A coding assistant may read ten files, propose a patch, inspect an error, and try again. An agent may spend an hour planning, browsing, calling tools, checking its own work, and handing pieces to other agents. What looks like one request to the user can become hundreds of model interactions behind the interface.

At the same time, the price of inference—the act of running a trained model—has fallen dramatically. Competition, better chips, quantization, distillation, caching, batching, speculative decoding, and better serving software have all reduced the cost of producing useful model output. But lower prices have not made the token market shrink. They have made entirely new workloads economical.

That is the central argument of this article:

Token demand is not one curve. It is a sequence of usage regimes, and each regime can multiply the number of tokens required to complete what a person experiences as a single task.

This is why falling token prices and rising AI infrastructure spending are not contradictory. It is also why the 160-year-old Jevons paradox has become one of the most useful—and most frequently oversimplified—ideas in the current AI debate.

First, What Exactly Is a Token?

Large language models do not read and write exactly as people do. Before text reaches a model, a tokenizer breaks it into numerical units. A common word may be one token. A long or unusual word may be several. Code, tables, JSON, and non-English text can have very different token densities.

The basic billing equation is simple:

Inference cost = input tokens × input price + output tokens × output price + any tool or service charges

Input and output are priced separately because they stress the system differently. Reading a long prompt involves processing and storing its context. Generating an answer is sequential: each new token depends on what came before it. That is one reason output tokens have often carried a higher price.

But the posted price per million tokens is only the beginning. The effective price can change with:

• prompt caching, which avoids repeatedly processing the same context;
• batch or asynchronous processing, which lets providers use capacity more efficiently;
• model routing, which sends easy tasks to cheap models and hard ones to expensive models;
• context length, because very long prompts can require different infrastructure and pricing;
• reasoning effort, since some systems generate substantial hidden or intermediate computation;
• tool calls such as search, code execution, image generation, or computer control.

This matters because a token is not a standardized unit of intelligence. One million tokens from two models can differ enormously in usefulness, accuracy, latency, and the difficulty of the task they can solve. Comparing token prices without holding capability constant is like comparing the price per kilogram of two different materials and ignoring what each material can do.

The more useful economic measure is therefore not simply dollars per token. It is cost per successful task.

The Price of Intelligence Is Falling

The direction of travel is unmistakable, even if any single token-price index should be treated cautiously.

When GPT-4 launched in March 2023, OpenAI priced its standard 8K model at $30 per million input tokens and $60 per million output tokens. Since then, cheaper model families, open-weight competition, specialized inference providers, and small-model routing have pushed many useful workloads far below that baseline.

Raw price comparisons actually understate the improvement because model capability has risen at the same time. Epoch AI's analysis of quality-adjusted inference prices asks a better question: how quickly did the cost of reaching a fixed benchmark performance fall? Depending on the task and performance threshold, it found annual declines ranging from roughly 9-fold to 900-fold. The spread is wide because there is no single market price for intelligence. Cheap, mature capabilities commoditize much faster than the newest frontier capabilities.

Several forces push the cost down:

1. Hardware improves. More memory, higher memory bandwidth, lower-precision arithmetic, and faster interconnects increase the number of requests a system can serve.
2. Serving software improves. Better scheduling, continuous batching, kernel optimization, and speculative decoding extract more output from the same installed hardware.
3. Models become more efficient. Distillation, mixture-of-experts architectures, quantization, and better training methods can deliver similar capability with less computation.
4. Workloads are routed. A frontier model no longer needs to answer every request. A system can use a small model for classification, a medium model for drafting, and reserve the expensive model for the difficult final step.
5. Competition transfers efficiency to customers. Open-weight models and a growing field of API providers make it difficult to preserve high prices for capabilities that have become widely available.

The result is persistent deflation at a given capability level. Yet total demand keeps climbing. To understand why, we have to stop treating all token usage as more of the same activity.

Token Growth Comes in Steps, Not a Straight Line

There are two independent sources of non-linearity.

The first is supply. Inference capacity does not appear continuously. Chips arrive in batches. Datacenter buildings, electrical connections, cooling systems, and network fabrics take time to complete. A provider can be constrained for months and then release much more capacity as a new cluster enters service or a serving stack becomes substantially more efficient.

The second is demand. New product patterns change the number of model calls required per task. Chat, coding assistance, tool-using agents, persistent workflows, and multi-agent systems are not points on one smooth adoption curve. They are different consumption regimes.

Supply determines how many tokens the industry can produce. Product architecture determines how many tokens users and software want to consume. The observed market is the interaction of both.

That distinction matters. A flat period in token volume does not necessarily mean demand has stalled; it may mean capacity, latency, or budget is binding. A sudden jump may reflect a popular product, a new model, a price cut, new infrastructure, or several of them arriving together.

The Supply Side: Capacity Arrives in Waves

The giant AI clusters that attract headlines are often described as if they were interchangeable. They are not. Training a frontier model and serving millions of inference requests use many of the same underlying components, but the operational requirements differ. Training emphasizes sustained, tightly synchronized computation. Inference has to balance throughput, latency, memory capacity, unpredictable traffic, and large numbers of concurrent users.

For the token economy, the most relevant supply story is therefore broader than any one supercluster.

Before mapping hardware to the token curve, one distinction is essential: a GPU class is a generation of accelerator built around a particular architecture, memory system, and set of numerical formats. A product announcement says the silicon exists. It does not say that meaningful inference capacity is online. Chips still have to become complete servers and racks; datacenters need power, cooling, and networking; and serving software such as vLLM, SGLang, TensorRT-LLM, or Dynamo has to use the new hardware efficiently. The lag from announcement to material token production can be six to twelve months, and sometimes longer.

That produces overlapping serving fleets rather than clean replacement cycles. A100 systems remain useful for smaller or latency-tolerant workloads while H100 and H200 systems handle more demanding jobs. Blackwell racks enter at the high end without making Hopper disappear. AMD's Instinct line provides a smaller but increasingly credible second source, especially where memory capacity is the constraint. Hyperscaler accelerators—including Google's TPUs, AWS Trainium and Inferentia, and Microsoft's Maia—add substantial capacity inside their owners' ecosystems even though they are less visible in the open API market.

Training builds the model; inference uses it

Training and inference can run on the same accelerator, but they are different jobs.

Training is how a model learns. A lab sends enormous batches of data through the model, measures its errors, calculates how every parameter contributed to those errors, and updates the weights. The work repeatedly moves forward and backward through the network. It favors large, tightly connected clusters that can sustain heavy computation for days or months without one machine holding up the others.

Inference begins after those weights are trained. A user or application sends input to the model and asks it to produce an answer, classify an item, call a tool, or take another action. The weights usually remain fixed. The operational challenge changes to serving many unpredictable requests with acceptable latency. Memory capacity and bandwidth become crucial because the system has to hold model weights and each request's growing context, or KV cache, while generating tokens sequentially.

In plain language, training is constructing and educating the engine; inference is operating a fleet of engines for customers. Training may be a smaller number of enormous scheduled jobs. Inference is a continuous service made of millions of differently sized jobs. Both need computation, memory, networking, software, power, and cooling, but they optimize for different bottlenecks.

How a GPU generation moves from training into inference

New hardware rarely flips from training to inference on one date. The same GPU class can serve both at once, and different owners allocate identical systems differently. Still, a recognizable lifecycle appears across generations:

This is a rule of thumb, not a depreciation schedule. Several forces can shorten or lengthen it:

• Inference-oriented refreshes move faster. H200 kept Hopper's basic compute architecture but added much more memory, making its serving value obvious from the start. Blackwell Ultra similarly emphasized reasoning and inference economics.
• Software can be the real clock. Quantization, continuous batching, paged attention, disaggregated prefill and decode, and optimized kernels determine how much of the theoretical hardware gain becomes usable tokens.
• The next generation triggers reallocation. When Blackwell took the highest-priority training slots, more H100 capacity could be assigned to inference without physically moving the machines.
• Ownership changes the path. A lab or hyperscaler that owns a cluster can reschedule it quickly. A neocloud may receive the hardware later but deploy it primarily for inference from its first day online.
• Mixed use can persist. Fleets are pools of capacity, not single-purpose appliances. Schedulers can assign training, post-training, research, and inference jobs to different portions of the same hardware class.

The “inference online” markers in the chart therefore mean the point when a hardware class plausibly begins contributing meaningful production-serving capacity. They do not mean its announcement date, first shipment, or first successful inference request.

The H100-to-H200 transition illustrates the quiet kind of supply expansion. NVIDIA says the H200 provides 1.8 times the memory capacity and 1.4 times the memory bandwidth of the H100. Those changes matter because inference, especially the generation phase, is frequently constrained by moving model weights and cached context through memory. More memory also allows larger batches and longer contexts.

The dates show why “online for inference” is the useful milestone. NVIDIA announced H200 in November 2023 and expected systems to begin shipping in the second quarter of 2024, making late 2024 through 2025 the more plausible window for broad token impact. AMD made MI300X available in December 2023, while MI325X production shipments were scheduled for late 2024 with widespread system availability beginning in early 2025.

Blackwell added another step through lower-precision inference, larger memory domains, and faster interconnects. Production shipments began ramping into 2025; Blackwell Ultra partner systems were expected from the second half of that year. AMD launched MI350 and MI355X in June 2025 with 288GB of HBM3E and FP4/FP6 support, followed by broader availability. By August 2026, the installed base is therefore still a mix: large volumes of H100 and H200, a growing high-end fleet of B200/B300-class systems, and MI300- and MI350-class alternatives.

The next wave needs the most careful label. NVIDIA said Vera Rubin's component set was in full production in March 2026, but production is not the same thing as material inference volume. Treat the second half of 2026 as the first-cloud window and 2027 as the broader token-impact window unless deployments show up sooner. AMD's MI400 and Helios systems sit on a similar 2026-to-2027 serving horizon. They belong in a projection, not in the historical explanation.

Hyperscalers simultaneously continued building their own accelerators and expanding regional capacity. Neoclouds and specialized inference companies added another layer of supply, often focused more directly on serving models than on training them.

These improvements do not translate mechanically into the same multiple of billable tokens. Utilization, model size, latency targets, power availability, and software all intervene. But they lower the production cost and raise the feasible volume of inference.

The useful mental model is a staircase:

• capacity becomes tight as a new use case grows;
• providers ration access, raise limits slowly, or tolerate worse latency;
• new hardware and datacenter capacity arrive;
• prices fall or usage limits rise;
• developers redesign products around the newly available economics;
• demand fills the capacity again.

Supply is the accelerator and the ceiling. The larger jumps in token intensity, however, come from the demand side.

Phase 1: One Question, One Answer

The first mass-market regime was conversational AI.

A person opened a chatbot, entered a prompt, and received a response. Follow-up questions added context, but the interaction still resembled messaging. Token demand was largely visible to the user: longer prompt, longer answer, larger bill.

An illustrative conversation might include 500 input tokens and 800 output tokens. Even ten such exchanges remain understandable as ten exchanges. The application may add a system prompt or resend some conversation history, but the unit of consumption is still recognizably the message.

This phase proved that millions of people wanted access to generated intelligence. It did not reveal the eventual token intensity of software acting on their behalf.

Phase 2: Coding Assistants Turn the Prompt Into a Work Session

Coding assistants changed the unit of demand from an answer to a workflow.

Autocomplete was only the beginning. A modern coding system may inspect a repository, search for symbols, read several files, reason about dependencies, edit code, run a test, parse the failure, revise the patch, and summarize what changed. Each step can require another model call, and relevant context may be sent repeatedly.

The user still experiences one task: “fix the authentication bug.” The model sees a chain:

inspect → search → read → plan → edit → test → observe → revise → test → explain

That sequence has three effects on token consumption.

First, input grows. Source files, build logs, issue descriptions, diffs, and prior attempts become context. Second, the number of calls grows. The system no longer tries to solve everything in one generation. Third, failure becomes consumption. A wrong approach is not merely a bad answer; it creates another observation and another turn through the loop.

The shift is visible in one large but partial dataset. OpenRouter's 100-trillion-token study found that programming-related requests rose from roughly 11% of its token volume in early 2025 to more than half in recent weeks of the study. OpenRouter is a multi-provider gateway, not the whole market, and its customer mix cannot be treated as global share. But the direction shows how quickly a new workload can reshape a platform's traffic.

Coding also previews the economics of agents. Software repositories provide unusually good environments for autonomy: the files are machine-readable, tools expose clear actions, and tests provide feedback. Developers became the first large group to see how rapidly tokens multiply when a model is allowed to work rather than merely answer.

Phase 3: Tool-Using Agents Create a Loop

The next regime adds agency.

A tool-using agent can browse the web, query a database, call an API, execute code, operate a computer, or write files. The key change is not the tool itself. It is the loop around the tool:

plan → act → observe → update the plan → act again

Every observation becomes new input. Every decision may create output. The context accumulates. If a webpage returns irrelevant information or a command fails, the agent consumes more tokens recovering.

Early agent harnesses, including OpenClaw-style systems, made this pattern accessible to developers. They demonstrated that a model can keep working across multiple steps if the surrounding software stores state, exposes tools, and decides when to stop.

This is where token demand becomes hard to infer from user activity. One person clicking “research this company” may trigger searches, page reads, document extraction, calculations, cross-checks, and a final synthesis. Counting users or prompts no longer captures the workload. The more relevant measures become:

• model calls per task;
• input and output tokens per call;
• retries and failed branches;
• duration of the workflow;
• proportion of context served from cache;
• success rate at the end.

A well-designed agent can still be cheaper than a poorly designed chatbot if it uses small models, compact state, and good tools. Agentic architecture does not guarantee waste. It expands the range of possible consumption.

Phase 4: Frameworks Turn One Agent Into a System of Agents

Agent frameworks formalize the loop. They add roles, state, branching, checkpoints, memory, and hand-offs. For non-developers, four common patterns explain most of the market.

One worker with a toolbox

Imagine one employee who can search, use a calculator, open documents, and send work to a database. The employee decides which tool to use and continues until the task is complete.

This is the simplest agent. It consumes tokens whenever it decides what to do, reads a result, or produces an answer.

A supervisor with specialists

Now imagine a manager who divides the job among a researcher, an analyst, a writer, and a reviewer. Each specialist receives instructions and reports back. The manager reads the reports and may request revisions.

That is a role-based crew. It can improve quality through specialization, but it duplicates context and creates hand-off traffic. The manager's coordination is itself a token-consuming workload.

A stateful flowchart

Some tasks follow explicit branches: if the invoice matches the purchase order, approve it; if it does not, investigate; if the discrepancy exceeds a threshold, escalate to a human.

That is a stateful graph. It is more controlled than an open-ended agent and often more appropriate for enterprise work. But loops inside the graph—research again, request missing data, retry the action—can produce large and variable consumption.

A team that debates and verifies

For difficult tasks, multiple agents may propose solutions, challenge one another, run independent checks, and ask a final judge to choose. This resembles a team reviewing a high-stakes decision.

It can reduce certain errors, but the token multiplier is obvious. The system pays not only for the answer but also for competing answers, critiques, evidence, and adjudication.

These patterns explain why agents can make usage jump discontinuously. A product update can change a workflow from one call to fifty without adding a single new user.

The Current Shift: Agents Move From Developers to Everyone

Developer tools were the laboratory. Consumer and enterprise products are the distribution channel.

Search engines increasingly answer complex questions by collecting and synthesizing information. Office tools can prepare documents, analyze spreadsheets, summarize meetings, and act across calendars and email. Customer-service systems can retrieve policy, inspect an account, initiate a refund, and document the interaction. Personal assistants are beginning to carry state across sessions and act through browsers or connected services.

This shift matters because the addressable population changes. Coding agents serve a valuable but limited professional group. Agents embedded in search, productivity suites, commerce, education, healthcare administration, and customer support can touch billions of users and a much larger share of daily work.

Google's disclosures show the scale that one integrated platform can reach. Across its surfaces, the company reported monthly processing volume rising from 9.7 trillion tokens in May 2024 to more than 3.2 quadrillion in May 2026—more than 300 times the original level in two years and seven times the prior year. Google also said its model APIs were processing roughly 19 billion tokens per minute.

The time unit is easy to miss. Google's 3.2 quadrillion per month is approximately 105 trillion per day when divided by an average month. The 360.4 trillion figure later in this article is already a daily global estimate: it corresponds to about 11 quadrillion per month. The 692.6 trillion-per-day scenario for 2027 Q3 would correspond to roughly 21 quadrillion per month, or about 6.5 times Google's May 2026 company-wide run rate. Converting everything to the same period removes the apparent contradiction.

Those figures should not be mislabeled as global token demand. They include Google's particular products, accounting, and definition of a processed token. They are valuable for a different reason: they show how quickly consumption can grow inside one ecosystem when AI moves across search, consumer applications, developer APIs, and enterprise products at the same time.

The next increase may come not from another sudden expansion in the number of users but from more delegated time per user. A chatbot is active while a person is typing. A persistent agent can work for minutes or hours after the instruction is given. Once software is allowed to continue in the background, human attention is no longer the direct ceiling on token consumption.

A Four-Quarter Token Scenario—and What It Actually Tests

Historical estimate and methodology: Tokens Per Day — the AI inference demand index. The site publishes its assumptions, source disclosures, uncertainty range, and underlying data; R40 uses its quarterly midpoint series through 2026 Q3 and clearly separates the subsequent projection.

The chart above turns the thesis into a falsifiable exercise. It reproduces an estimated series that rises from 0.8 trillion tokens per day in 2023 Q4 to 360.4 trillion in 2026 Q3, then extends it for four quarters. These are not observed global totals. No provider reports a complete market denominator, token definitions differ, and first-party consumer usage is mostly hidden.

The 360.4 trillion figure is therefore not “correct” in the sense of a measured global counter. It is the July 16, 2026 midpoint published by the independent Tokens Per Day index, whose model gives a range of 308.4 trillion to 477.1 trillion tokens per day. The index constructs its midpoint from a reported-usage floor plus estimates for providers that do not disclose complete volumes, and explicitly calls the result “a modeled count, not a meter.” The historical curve in this article reproduces that model's quarterly midpoints; R40's contribution begins with the four projected quarters.

There are reasons to treat even the stated range cautiously. Disclosures come from different dates and may count input, output, cached, reasoning, image, or video tokens differently. A July 2026 research paper using OpenRouter data instead placed global consumption at roughly five to seven quadrillion tokens per month, equivalent to about 165 trillion to 230 trillion per day. A separate industry estimate cited in a Hong Kong listing document put the market at more than 200 trillion per day in December 2025. Together they support the broad order of magnitude, but they also show meaningful disagreement: 360.4 trillion should be treated as a scenario anchor, not today's known total.

Google offers the cleanest scale check. Its May 2026 disclosure is roughly 105 trillion tokens per day across Google's own surfaces, approximately 29% of the modeled 360.4-trillion global midpoint. That concentration is possible for a company operating Search, Gemini, Cloud, Workspace, and model APIs, but Google's figure cannot validate the global estimate: its scope and token accounting are not necessarily comparable with other providers.

The event labels are overlays on the reconstruction:

One correction to the original event map is important. Stargate's September 2025 announcement is evidence of planned infrastructure scale, but it is not a clean timestamp for Abilene inference switching on. OpenAI described the flagship site and additional developments as part of nearly seven gigawatts of planned Stargate capacity. The chart therefore uses the broader label “large-site and Blackwell capacity ramp” rather than assigning the 2025 Q3 jump to one facility.

For the next four quarters, the scenario assumes that growth stops decelerating and initially reaccelerates—but that physical infrastructure begins pushing back during 2027.

That constraint is more than a generic disclaimer. The IEA estimates that grid constraints could delay around 20% of planned global datacenter capacity by 2030. Its 2026 analysis says advanced rack power density could rise another fourfold by 2027 and that a shortage of high-bandwidth memory is expected to persist through at least the end of 2027. The exact quarter cannot be known, but 2027 Q2 is a reasonable point to introduce the risk into the scenario: Rubin- and MI400-class systems may be available while powered sites, grid connections, transformers, cooling, and HBM limit how quickly they become productive inference fleets.

Memory and power constrain different parts of the curve

It is useful to separate the two risks. HBM constrains the quality and economics of the marginal token first; electricity constrains the absolute number of tokens the system can produce later. They can reinforce one another, but they do not operate through the same mechanism.

High-bandwidth memory has to hold model weights, the key-value cache created by the active context, and other runtime state. As context windows, reasoning traces, batch sizes, and the number of concurrent agents grow, that working set expands. When it no longer fits comfortably inside one accelerator or a small high-speed memory domain, the provider must split the workload across more GPUs, accept lower concurrency, truncate context, or route it to a smaller model. Each response may still be generated, but it becomes slower or more expensive—and fewer high-value workloads fit into the same fleet.

Blackwell Ultra and MI355X provide a temporary relief valve. NVIDIA lists 288GB of HBM3E per Blackwell Ultra GPU, while AMD lists 288GB of HBM3E and 8TB/s of bandwidth for MI355X. That does not eliminate the memory problem. It raises the point at which larger mixtures of model weights, batches, and cached context spill across devices. Rubin's move to HBM4 is the next prospective step, so the 2027 risk is a mismatch: models and agent workloads could expand faster than HBM4 systems enter serving fleets.

Power is the broader physical ceiling. A memory-bound request can sometimes be rescued with quantization, cache compression, a smaller model, or another GPU. A datacenter without an available megawatt cannot install the next rack at all. Local substations and interconnections can bind first; regional generation and transmission follow; cooling becomes harder as rack density rises. Training also competes with inference for the same best-powered campuses.

Neither constraint implies that token use reverses. HBM pressure first tilts growth toward shorter-context, quantized, or highly optimized workloads. Power pressure then raises the cost of the marginal token and can create temporary plateaus while new sites and grid capacity come online. If both tighten together, always-on agents and large multi-agent graphs may be delayed even while ordinary chat volume keeps rising.

This suggests three practical signals. A memory warning appears when the best broadly available inference accelerators cannot hold a frontier model's weights and KV cache at a commercially useful batch size and context length. A power warning appears when deployment schedules are governed by interconnection and energized megawatts rather than GPU deliveries. A token-growth warning appears if quarterly growth remains below roughly 1.3× to 1.4× for several quarters even while agent adoption and inference demand continue rising. That last range is an analytical threshold for this scenario, not an industry law.

This is intentionally more conservative than extending the 1.7× to 2.2× quarterly multipliers seen during 2025. It produces roughly 1.9× year-over-year growth by 2027 Q3. The projection assumes the market finds a new demand regime, but also that memory pressure begins degrading the economics of demanding workloads before power and grid limits restrain total volume more visibly from 2027 Q2.

Does the chart prove the thesis?

No. It shows that the thesis is internally consistent, not that it is causal.

The supportive evidence is the timing: token intensity rises as products progress from chat to coding agents to tool loops, while successive hardware classes expand the supply ceiling. The chart also produces a testable prediction. If growth lifts toward 1.18× to 1.20× through 2027 Q1 and then slows while inference prices remain low and demand indicators stay strong, the supply-constraint thesis gains support. If powered capacity and HBM expand without token growth responding, the weakness is more likely demand-side.

The strongest challenge is already visible in the supplied numbers. The QoQ multiplier peaks at 2.21× in 2025 Q3 and falls in every subsequent quarter to 1.16× by 2026 Q3—even as Blackwell capacity ramps. That means hardware availability alone cannot explain the curve. Either demand is normalizing, the reconstruction overstates earlier growth, or the next agent distribution wave has not arrived yet. The four-quarter forecast is a bet on the third explanation.

The clean verdict is therefore: the staircase thesis is plausible, the historical magnitudes remain assumptions, and the next four quarters can distinguish a demand slowdown from a market whose appetite for tokens is running into electricity and memory.

Jevons Paradox: The 160-Year-Old Version of the Token Story

In 1865, economist William Stanley Jevons observed that improvements in the efficiency of steam engines did not necessarily reduce Britain's coal consumption. Greater efficiency made coal-powered work cheaper and economically useful in more places. The market expanded so much that total coal use rose.

After DeepSeek's efficiency claims shook the market in January 2025, Microsoft CEO Satya Nadella summarized the modern analogy: “Jevons paradox strikes again.” His argument was that more efficient and accessible AI would cause usage to skyrocket.

The phrase is useful, but it is often used too casually. A price decline followed by any increase in usage is not automatically Jevons paradox. The increase must be large enough to overwhelm the efficiency gain in the resource being measured.

For the commercial token market, start with a simple identity:

Token revenue = average price per token × billable token volume

If the average price falls by 80%, it ends at 20% of its previous level. Volume must rise more than fivefold for token revenue to increase.

The middle row matters. Tokens can become cheaper and usage can grow substantially while total spending still falls. Jevons is not a law guaranteeing higher revenue for every model provider or chip company. It is a hypothesis about demand elasticity.

Strictly speaking, rising token revenue is not the classical Jevons test. Jevons was describing physical resource consumption. The closest AI equivalent asks whether improvements in tokens per unit of computation are followed by enough additional inference that total computation, energy, or infrastructure use still increases. The price-and-revenue table is the commercial counterpart: it shows the hurdle token volume must clear for provider spending to grow despite deflation. The two often move together, but they are not identical.

AI nevertheless has several characteristics that make a strong rebound plausible:

• Latent demand is enormous. Many desirable workloads are not run today because they are too expensive, too slow, or not reliable enough.
• Software can create its own demand. An agent can generate follow-up work, tests, critiques, and retries without another human prompt.
• Quality can consume the savings. Developers may spend a lower cost per token on more reasoning, more candidates, or stronger verification rather than accepting a cheaper version of the same workflow.
• Lower prices cross adoption thresholds. A use case that fails at $1 per task may become attractive at ten cents. When it crosses that threshold, the entire workload can arrive at once.
• New products expand the market. Cheap inference is not only substituted into old software. It enables products that did not exist at the higher price.

The threshold effect is especially important. Demand may appear flat while cost falls from $1.00 to $0.20 because a workflow needs to be below $0.10 to work economically. A further reduction to $0.08 does not produce a small increase; it switches on the entire application. Across thousands of potential applications, those thresholds create the staircase shape.

Why Lower Token Prices Can Still Produce Higher Bills

The apparent paradox disappears once the unit of work changes.

Suppose a support chatbot once used 2,000 tokens to draft a reply. A new agent reads the customer's history, searches documentation, checks order status, proposes a remedy, verifies policy compliance, executes the action, and writes an audit note. Optimizations may cut the price per token by 90%, but the new workflow may use 50 or 100 times more tokens and pay for several tools.

The business is not buying a cheaper reply. It is buying more of the job.

The same mechanism appears in coding. A model that once suggested the next line now works across a repository. In research, a short answer becomes a sourced report. In analytics, a generated formula becomes an iterative investigation. In consumer search, one query can fan out into multiple searches and reasoning passes.

This is why corporate AI budgets can exceed forecasts even when procurement negotiates lower unit prices. Three quantities are moving at once:

1. the cost of a token is falling;
2. the number of calls within each task is rising;
3. the number of tasks considered suitable for AI is expanding.

Finance teams often model the first and underestimate the other two.

Not Every Token Is Equal—and Not Every Token Creates Value

Exploding volume is not the same as exploding economic value.

Tokens can be spent on useful reasoning, repeated boilerplate, oversized context, failed tool calls, circular agent conversations, or outputs nobody reads. A system that burns ten times more tokens to achieve the same success rate has increased infrastructure demand, not productivity.

This creates a measurement problem for both operators and investors. Raw volume can flatter systems that are inefficient. Posted price can flatter models that fail often. Revenue can rise while customer economics deteriorate. The metrics have to move up one level:

Caching makes the issue even more subtle. A persistent agent may process an enormous logical context while the provider bills cached input at a fraction of the standard rate. Reasoning models can also spend computation in ways that raw visible output does not capture cleanly. Multimodal systems translate images, audio, and video into model-specific units that are difficult to compare with text tokens.

The token remains useful as a measure of activity. It is not a universal measure of intelligence or value.

Who Benefits From the Expansion?

Jevons-style demand does not distribute value evenly across the stack.

Infrastructure suppliers

If token volume grows faster than hardware and software efficiency, aggregate demand for accelerators, memory, networking, datacenter capacity, and power can rise. This is the most direct version of the Jevons thesis.

But the relevant measure is not tokens alone. Smaller models, custom chips, lower precision, and higher utilization can reduce infrastructure required per token. The bullish case requires workload growth to outrun all of those efficiencies together.

Hyperscalers and inference platforms

Cloud providers benefit from owning the scarce systems that convert capital into available inference. They can also capture value above raw compute through routing, databases, security, observability, and application services.

Their risk is capital intensity. Capacity has to be built before demand is fully known, and a newer chip or more efficient model can change the economics of existing assets.

Model developers

Model labs may see volume surge while pricing power weakens. If comparable intelligence becomes a commodity, revenue can grow without margins expanding. Premium models can preserve higher prices at the frontier, but mature capabilities face pressure from open weights, distillation, and routing.

This is why “more tokens” is not by itself an investment thesis for any one lab.

Application companies

Applications may capture the largest value if they turn cheap intelligence into a differentiated workflow, proprietary data advantage, distribution channel, or system of record. Falling inference cost can expand their gross margin—or it can be entirely consumed by more ambitious agents and customer expectations.

The winners will not necessarily minimize token use. They will maximize value created per dollar of inference.

The Next Scaling Step Is Already Visible

The next regime has three features: persistent state, parallel work, and verification.

Persistent state allows an agent to remember goals, prior attempts, permissions, and relevant context across sessions. This lengthens the useful life of a task beyond a chat window.

Parallel work allows several agents or model calls to explore different branches at the same time. A research system can search several hypotheses; a coding system can ask specialists to inspect different components; a planning system can compare multiple strategies.

Verification adds critics, tests, simulations, or judges before an action is accepted. It is one of the most promising ways to make agents dependable—and one of the clearest token multipliers.

Together, these features change AI from a tool that waits for a prompt into a process that continues toward an objective. They also make demand more variable. A simple task may finish in three calls. A difficult one may branch, fail, recover, ask for approval, and continue for hours.

That variability will force a change in pricing. Flat per-seat subscriptions are easy to understand but dangerous when a small group of power users can consume orders of magnitude more inference than average users. Expect more products to combine subscriptions with quotas, credits, task-based charges, priority tiers, or explicit limits on background agents.

What to Watch Instead of a Single Token Forecast

No global token counter exists. Providers define and disclose tokens differently, first-party applications hide much of their usage, and multimodal workloads resist clean comparison. A precise forecast of worldwide daily tokens can therefore create more confidence than knowledge.

A better approach is to watch signals from each part of the system.

Supply signals

• accelerator shipments and cloud capacity additions;
• memory and networking availability;
• tokens per second at a fixed latency target;
• utilization and inference gross margins;
• power capacity brought online for datacenters;
• the share of compute allocated to inference rather than training.

Demand signals

• model calls and tokens per completed task;
• the share of traffic involving tools;
• coding and agentic workloads as a share of platform volume;
• background-agent runtime per user;
• enterprise budget revisions and quota exhaustion;
• adoption beyond developers in search, office work, support, and commerce.

Efficiency and value signals

• cost per successful task;
• cache-hit rates and context reuse;
• routing share handled by smaller models;
• retry rates, abandoned runs, and human escalation;
• economic value created per inference dollar.

The most important question is not whether token prices continue to fall. They probably will at many established capability levels. The question is whether new use cases, longer workflows, and wider distribution cause useful demand to grow even faster.

Conclusion: The Market Is Deflating and Expanding at the Same Time

The token economy looks contradictory only when viewed through one variable.

Prices can fall while volume rises. Volume can rise while provider revenue falls. Revenue can rise while margins compress. Infrastructure demand can grow while computation per token becomes more efficient. All of these can be true at once because the product, the workload, and the competitive structure are changing together.

The first era of generative AI was measured in prompts. The second is being measured in tasks. The next will be measured in delegated time: how long software can work, how many branches it can explore, how much it can verify, and how much of a process it can complete without constant human direction.

That transition is unlikely to produce a smooth curve. Chat created one level of consumption. Coding assistants created another. Tool-using agents added loops. Stateful and multi-agent systems add duration, parallelism, and verification. Consumer distribution can apply those multipliers to billions of people.

Jevons paradox does not guarantee that every company exposed to AI wins. It gives us the right question: when intelligence becomes cheaper, how much entirely new demand becomes economical?

So far, the answer has not been “slightly more.” It has been a succession of new regimes, each capable of making the previous token forecast look linear, cautious, and obsolete.