How Many Tokens Will a Power User Burn in 2028?

The simplest prediction about AI usage is also the least useful one:

Tokens will get cheaper, so developers will use more of them.

True. But it hides the interesting part. A developer does not have one token budget. They have two.

There is the foreground stream: the chats, edits, completions, debugging sessions, and agent runs you are actively steering. This stream is bounded by attention. You can make models cheaper, faster, and smarter, but you still cannot supervise a thousand serious foreground turns per hour.

Then there is the background stream: overnight refactors, async PR drafters, fuzzers, test writers, repo explorers, migration agents, eval sweeps, and “go try seven approaches and come back with a ranked memo” jobs. This stream is bounded by money and by result-bandwidth. How many diffs can you review? How many generated plans can you actually read? That ceiling is much higher than the ceiling on foreground chat.

The claim of this model is:

By 2028, the interesting growth in inference usage for AI-heavy developers is not the chat box. It is the background work queue.

Here is the live widget. It is a single static HTML file: no backend, no tracking, no external JS. The URL hash encodes the sliders, so you can link to a scenario.

Open the full-page widget if the embed feels cramped.

The Model

The identity is deliberately plain:

tokens/day = T_fg(t) + T_bg(t)
$/day      = sum(tokens_segment * price_segment(t))

Foreground:

T_fg(t) = H_fg(t) * q_fg(t) * k_fg(t) * tau_fg(t) * (1 + r_reason(t))

Background:

T_bg(t) = J_bg(t) * d_bg(t) * tau_bg(t) * (1 + r_reason(t))

Where:

Symbol	Meaning	Why it matters
H_fg	Hours/day actively driving LLMs	Soft-capped by working hours and focus.
q_fg	Foreground queries/hour	Chat turns, edits, completions, manual agent launches.
k_fg	LLM calls/query	Subagents, verifier loops, tool calls, retries.
tau_fg	Non-reasoning tokens/call	Context plus visible output before hidden reasoning.
J_bg	Background jobs/day	The Jevons lever.
d_bg	Calls/background job	Depth times fan-out.
tau_bg	Tokens/background call	Usually more context-loaded than foreground work.
r_reason	Reasoning-token multiplier	Hidden or thinking tokens as a multiple of ordinary tokens.

The model uses May 2026 as t = 0 and May 2028 as t = 24 months.

The price side is:

p(t) = p_0 * f_hw(t) * f_algo(t) * f_margin(t)

But it is tracked per tier:

Tier	What it stands for in the widget	Why separate it
Frontier	Best generally available reasoning/coding models	Expensive tokens dominate cost.
Mid	strong hosted models and fast open-ish models	Where much of the useful work may land.
Small/open	cheap open-weight, distilled, and narrowly routed models	Cheap tokens dominate volume.

The default current price sheet is not a live scrape. It is a transparent approximation built from public API price pages as of May 27, 2026: OpenAI pricing, Anthropic pricing, DeepSeek pricing, and fast hosted/open-model providers.¹²³⁴⁵ The widget’s default blended prices are:

Tier	Input, $/M tokens	Output or reasoning, $/M tokens	Role in model
Frontier	5.00	28.00	OpenAI/Anthropic frontier-ish blend.
Mid	1.50	8.00	Good coding models below the frontier.
Small/open	0.22	0.85	DeepSeek/open-weight hosted ballpark.

Reasoning tokens are billed like output tokens in the model. That is not always exactly how a provider’s bill is itemized, but it is the right economic simplification: hidden thought tokens consume scarce decode capacity.

Prompt caching is modeled as a share of input tokens served at 10% of ordinary input price. That is close to the discount structure several providers have converged toward, though cache writes, TTLs, and cacheability vary by provider.¹²³

The Jevons Part

The widget does not treat background demand as exogenous.

If price falls, J_bg rises:

J_bg(t) = softcap(
  lerp(J_bg_0, J_bg_target, t) *
  (blended_price(t) / blended_price_0) ^ -elasticity,
  review_bandwidth_cap
)

And agent depth also has a saturation curve:

d_bg(t) = softcap(lerp(d_bg_0, d_bg_target, t), useful_depth_cap)

This is where the rebound lives. If the blended price falls 10x and elasticity is 0.75, the model does not just say “same jobs, cheaper bill.” It says “some of the savings become more jobs.”

This is also why the answer is not obvious. In the Base preset, tokens go up much more than spend:

Preset	Today tokens/day	2028 tokens/day	Today $/day	2028 $/day	Read
Bear	9.75M	89.94M	$101	$164	Tokens rise, spend rises modestly.
Base	9.85M	2.18B	$102	$315	Background agents eat most of the savings.
Bull	9.88M	33.36B	$101	$64	Hardware/algorithmic gains outrun rebound.

Do not read those as forecasts. Read them as three internally consistent machines. If your own current retail-equivalent usage is $20/day rather than $100/day, scale the starting point down. The point is the interaction.

What Is Actually Known?

Provider pricing is the cleanest input. Public pricing pages are explicit, even though they move quickly.

Usage telemetry is much murkier. Cursor, Claude Code, Devin, OpenAI Codex-style agents, and internal company agents do not publish clean public tables of “tokens per developer per day.” Anthropic’s Claude Code docs expose cost controls and monitoring, and report that enterprise deployments average around $13 per developer per active day, with 90% below $30.⁶ That is useful, but it is not the same thing as a leading-edge power user’s retail-equivalent API burn. The broader agent literature reports token/cost traces on benchmark tasks, but those are not the same thing as daily power-user telemetry either.⁷

So the model starts from ranges, not certainties:

Stream	May 2026 rough range	Widget default
Foreground attention	3-6 hours/day	4 hours/day
Foreground queries/hour	30-100	50
Calls/query	1-5	2.2
Tokens/foreground call	5k-20k	9k
Background jobs/day	0-5	2
Calls/background job	10-100	35
Tokens/background call	10k-50k	22k
Reasoning multiplier	0.5x-3x	0.8x

Those numbers imply about 10M tokens/day for a very heavy current user. That is not the median Copilot user. It is the person who keeps an agent running, tests models against their own codebase, and treats LLMs as a second terminal.

The most important thing the widget does is let you move the uncertain variables instead of asking you to believe mine.

Scene 1: Bear

Bear is not “AI stops.” It is “AI keeps improving, but the speed of real substitution is slower than the hype.”

In Bear:

• Frontier hardware only gets to 0.5x today’s cost.
• Mid-tier hardware gets to 0.3x.
• Algorithmic efficiency only improves to 0.7x.
• Provider margins stay sticky.
• Reasoning tokens stay roughly flat.
• Background jobs grow, but not explosively.

The resulting shape is boring in the right way. Tokens grow about 9x, but spend only grows about 1.6x. Foreground remains visible. Background grows, but does not dominate everything.

This is the world where models get cheaper, but organizations still need high-trust review, background agents do not reliably compose, and providers keep a lot of the margin because demand exceeds available high-quality serving capacity.

Scene 2: Base

Base is the “cheap enough to become wasteful” world.

In Base:

• Frontier hardware falls to about 0.22x.
• Mid-tier serving falls to 0.10x.
• Algorithmic efficiency falls to about 0.32x.
• Margins partially compress.
• Reasoning tokens rise to 2x ordinary tokens.
• Background job launch and depth both rise strongly.

The model gives about 2.2B tokens/day at month 24 and about $315/day of retail-equivalent API spend. The eye-catching bit is not the final spend. It is the composition. Background tokens are basically the whole story.

That matches how I expect serious developers to behave if agents become tolerably reliable:

• Ask one foreground question.
• Launch five background attempts.
• Let each attempt branch.
• Let each branch run tests, inspect errors, and revise.
• Review the two diffs that survive.

The human still spends attention. The machine spends tokens.

Scene 3: Bull

Bull is not just “everyone uses more AI.” Bull is “tokens become so cheap that even absurd background fan-out costs less than today’s careful use.”

In Bull:

• Mid/small model serving cost collapses.
• Algorithmic efficiency hits 0.1x.
• Provider margins compress hard.
• Reasoning tokens explode to 5x.
• Background jobs and depth both hit soft caps.

The result is deliberately strange: 33B tokens/day, but lower spend than today. This is the world where cheap specialized hardware, distillation, caching, and open-model competition convert model calls into something closer to CPU cycles: still metered, still not free, but no longer psychologically expensive.

I do not think this is the median case. But it is a useful stress test, because it shows why “tokens get cheaper” is not enough. You also need to know how much demand rebounds.

Hardware Is Not One Thing

The hard part is f_hw.

It is tempting to ask, “How much cheaper will inference hardware get?” But hardware wins are not fungible. A chip that is amazing for a stable 70B dense model may be irrelevant for a frontier MoE with fast-changing architecture. A chip that is perfect for edge wake-word-plus-local-agent work may not matter for a 1T parameter coding model. A wafer-scale engine can remove networking overhead, but only if the model and memory layout fit the machine.

A useful hardware forecast has to ask four questions:

1. Where do the weights live?
2. Where does the KV cache live?
3. How much of the computation is predictable enough to schedule ahead of time?
4. How much model architecture churn can the hardware tolerate?

NVIDIA, AMD, and TPU: the boring floor-setters

The incumbents still matter most for frontier serving.

NVIDIA Blackwell/GB200-style systems are expensive, power-hungry, and supply constrained, but they are also the default target for frontier model serving because they combine HBM capacity, mature kernels, networking, software, and deployment familiarity.⁸ AMD’s MI300/MI350 family pushes memory capacity and price competition, especially where buyers can tolerate more software work.⁹ Google’s TPU generations matter for Google, and for any external Cloud TPU users, because vertical integration lets the hardware, compiler, serving stack, and model architecture co-evolve.¹⁰

The key economic point: incumbents set the frontier floor even if they do not set the mid-tier floor. If specialized chips fail, the Base case does not collapse to zero progress. It falls back to better GPUs, better batching, better attention kernels, and better model routing.

Cerebras: wafer-scale digital compute

Cerebras is the cleanest example of “make the chip enormous and kill off-chip movement.” The WSE-3 is a wafer-scale processor with about 4 trillion transistors, 900,000 AI-optimized cores, 44 GB of on-wafer SRAM, and enormous on-wafer bandwidth.¹¹

Compute substrate: digital wafer-scale array. The bet is that a single wafer-scale fabric avoids the latency and bandwidth tax of stitching together many small chips.

Memory architecture: large on-wafer SRAM plus external memory/system-level sharding when models exceed on-wafer capacity. The 44 GB number is impressive, but frontier model weights and KV caches are still much larger than that, so the system story matters as much as the chip story.

Model-size regime: excellent for dense models that can be served efficiently across the wafer-scale fabric; interesting for high-throughput inference on open models; less obviously magic for huge frontier MoE models unless routing and memory placement cooperate.

Economic story: wafer-scale yield is the central question. Cerebras argues redundancy and wafer-level design make it viable; skeptics ask whether volume economics can match packaged GPU systems. The cloud API and public pricing are real, which matters more than abstract chip claims.⁴

Timeline read: already purchasable as systems/cloud access, not commodity-purchasable like a PCIe card. By 2028, Cerebras-style serving can matter for mid/frontier-adjacent workloads if it keeps winning on latency and throughput.

Groq: deterministic SRAM-heavy dataflow

Groq’s LPU/Tensor Streaming Processor story is the opposite of “throw a giant GPU memory hierarchy at it.” It is a deterministic dataflow machine: compile the model into a schedule, keep execution predictable, and avoid a lot of runtime overhead.¹²⁵

Compute substrate: digital dataflow, with deterministic scheduling as the core product claim.

Memory architecture: SRAM-heavy, with the economic tradeoff that SRAM is fast and predictable but expensive and capacity-limited compared with HBM or DRAM.

Model-size regime: very good for moderate, stable dense models where the graph can be compiled and served at low latency. The public GroqCloud experience has made “fast open-model inference” feel different from ordinary hosted inference.

Economic story: if the workload is stable and the compiler/runtime can keep utilization high, the speed story can translate into cost. But SRAM capacity and system scaling matter. Low latency alone does not guarantee low price if the silicon is underutilized.

Timeline read: cloud-accessible now. Commodity card availability is not the main question for developers; API price and model coverage are.

Can Groq absorb MoE routing? Partly. If routing is top-k but batched, capacity-limited, and predictable enough to compile into bounded schedules, a deterministic machine can make it work. If every token creates highly irregular expert traffic with poor batching, it fights the premise of deterministic scheduling. My 2028 guess: Groq-like systems are strongest for stable dense and carefully engineered sparse models, not arbitrary frontier-routing chaos.

Mythic: analog in-memory compute

Mythic’s pitch is analog matrix multiplication inside memory arrays. Store weights in analog cells, move less data, and get high energy efficiency for inference.¹³¹⁴

Compute substrate: analog in-memory compute, wrapped in digital control and conversion.

Memory architecture: weights live in non-volatile memory arrays close to the multiply operation. That is the point: reduce data movement.

Model-size regime: edge, embedded, low-power, smaller models, vision/audio/local agents, maybe narrow LLM components. It is not obviously a direct frontier server replacement.

Economic story: the upside is power and cost for fixed models at scale. The costs are analog calibration, ADC/DAC overhead, accuracy drift, toolchain maturity, and the fact that fast-changing model architectures are awkward when the hardware is optimized around fixed operations.

Timeline read: relevant to edge inference and local always-on intelligence sooner than to frontier API pricing. It can still matter by shifting small/open tokens off the cloud.

Can Mythic’s analog cells scale into a Cerebras-style monolithic die? I would bet against a literal version. Analog noise, calibration complexity, yield, drift, and conversion overhead compound as area grows. A more plausible hybrid is digital control plus analog matmul tiles, with redundancy and calibration at the tile level. Analog can interlock with wafer-scale ideas, but probably as chiplets/tiles rather than one heroic analog wafer.

Taalas: model-specific silicon

Taalas, spelled with two a’s, is the most radical claim in the set: “the model is the computer.” The public story is model-specific AI silicon, with very high claimed throughput for fixed model families.¹⁵

Compute substrate: custom digital silicon specialized to a model or model class.

Memory architecture: not publicly specified in enough detail to model honestly. The economic story depends on hardwiring enough of the model/dataflow to gain efficiency without freezing yourself into yesterday’s architecture.

Model-size regime: stable, high-volume models. If a Llama-like architecture becomes a durable deployment target, this gets interesting. If the frontier keeps changing every six months, model-specific silicon gets stranded.

Economic story: ASICs love volume and hate churn. The bet works if enough inference demand concentrates on a small number of architectures for long enough to amortize design and manufacturing.

Timeline read: high-upside, high-uncertainty. I would put it in the Bull tail for small/mid model price collapse, not the Base case for frontier serving.

Tenstorrent: programmable, tile-based, sovereignty-friendly

Tenstorrent is not a one-trick inference ASIC. It is a programmable AI architecture with RISC-V cores, mesh/tile ideas, and a visible attempt to offer a more open hardware/software stack.¹⁶

Compute substrate: programmable digital accelerator with a developer-facing software stack.

Memory architecture: depends on product generation, but the relevant point is not one huge SRAM trick. It is a more flexible accelerator path that can be sold as cards/systems.

Model-size regime: mid-tier and private deployments where buyers care about cost, control, and not being locked to one hyperscaler stack.

Economic story: the advantage has to come from price/performance and ecosystem. Hardware without a boringly reliable software stack does not become cheap inference for developers.

Timeline read: potentially meaningful for open-model serving economics by 2028, especially in private clouds and sovereign deployments.

SambaNova: reconfigurable dataflow systems

SambaNova’s RDU is a reconfigurable dataflow architecture aimed at enterprise AI systems, not a cheap developer API first.¹⁷

Compute substrate: dataflow accelerator with reconfigurable fabric.

Memory architecture: system-level dataflow and memory orchestration, sold as integrated platforms.

Model-size regime: private enterprise inference and fine-tuned deployments, particularly where customers want a full stack.

Economic story: may lower total deployment cost for some enterprises, but it only changes public API token prices if it reaches enough serving volume or pressures competitors.

Timeline read: relevant as competitive pressure and private AI infrastructure, less likely to be the thing that makes your hobby agent 100x cheaper.

Etched: transformer ASIC

Etched’s Sohu is a direct bet on transformer inference: throw away generality, optimize for the dominant architecture, and win if the transformer remains the main workload.¹⁸

Compute substrate: digital ASIC specialized for transformer-shaped computation.

Memory architecture: public material emphasizes serving transformer models at high throughput; the real competitiveness depends on HBM, interconnect, and compiler/runtime execution.

Model-size regime: mid to large transformer models if architecture stability holds.

Economic story: enormous upside if transformers stay stable; painful downside if model architectures move away from what the chip assumes.

Timeline read: this belongs in the Bull/Base boundary. If it works and ships in volume, it can move mid-tier pricing hard. If it slips or architecture churn wins, it becomes an interesting footnote.

Can These Approaches Interlock?

Yes, but mostly through systems, not by stapling fantasies together.

The useful hybrids look like this:

Hybrid	Why it could work	What breaks it
Digital router plus analog matmul tiles	Keeps analog where it is strongest: fixed matrix multiply.	Conversion overhead, calibration, low precision failures.
Wafer-scale or chiplet MoE expert sharding	Put experts near memory/compute, route tokens across a controlled fabric.	Dynamic routing, load imbalance, KV-cache movement.
SRAM-heavy fast path plus HBM bulk path	Use SRAM for hot weights/KV slices, HBM for capacity.	Software complexity and utilization.
ASIC for stable small/mid model plus GPU frontier fallback	Cheap background volume, expensive frontier escalation.	Routing quality and operational complexity.
Edge analog/small accelerators plus cloud frontier	Local always-on work, cloud for hard reasoning.	Privacy, sync, developer tooling, local model quality.

My 2028 map:

Model regime	Likely serving winners	Cost implication
Tiny/on-device	Apple/Qualcomm/NPU, Mythic-like analog niches, small GPUs	Many local tokens disappear from API bills.
Small open models	Groq-like SRAM/dataflow, Tenstorrent-like cards, GPUs, edge NPUs	Prices compress hard; volume explodes.
Mid dense models	Cerebras/Groq/Etched/Tenstorrent/GPU competition	Biggest public API price war.
Frontier dense	NVIDIA/AMD/TPU plus some Cerebras-style systems	Cheaper, but less dramatic.
Frontier MoE/reasoning	Hyperscaler systems, GPUs/TPUs, carefully engineered sparse accelerators	Expensive tokens still matter.

That is why the widget gives mid-tier hardware a more aggressive Bull path than frontier hardware. The frontier moves. The mid-tier industrializes.

Practical Planning

I would plan as if three things are true at once.

First, foreground AI will saturate. Your chat box can get better, but the scarce resource is still your attention. The biggest productivity changes come from better UI, better memory, better evals, and better taste in what to ask.

Second, background AI is the budget risk. If you run a team, the surprising bill will not be “Alice chatted with the model all day.” It will be “every issue now launches a search tree.” Make the queue visible. Count jobs, not just tokens.

Third, tier routing is going to matter more than model loyalty. The right stack will look like:

• small/open model for search, classification, formatting, and first-pass edits
• mid model for most coding and repo work
• frontier model for architectural judgment, hard debugging, and final review
• prompt caching and context compaction everywhere
• evals that measure whether extra depth still adds signal

The operational question is not “Can I afford tokens?” It is:

Which tokens deserve frontier decode capacity, and which can be safely wasted?

That is a strange sentence. It is also probably the next two years of AI developer tooling.

Bibliography

Provider pricing and usage references:

• OpenAI API pricing
• Anthropic Claude pricing
• DeepSeek API pricing
• Cerebras Inference pricing
• GroqCloud pricing
• Anthropic Claude Code cost tracking
• SWE-agent paper and repository

Hardware references:

• Cerebras WSE-3 product page
• Groq technology overview
• Mythic analog compute technology
• Mythic M1076 analog matrix processor
• Taalas public thesis
• Tenstorrent Wormhole hardware page
• SambaNova RDU/dataflow technology
• Etched Sohu announcement
• NVIDIA Blackwell architecture
• AMD Instinct MI300X
• Google Cloud TPU documentation

Footnotes

1. OpenAI, “API pricing.” https://platform.openai.com/docs/pricing/ ↩ ↩²

2. Anthropic, “Claude pricing.” https://docs.anthropic.com/en/docs/about-claude/pricing ↩ ↩²

3. DeepSeek, “API pricing.” https://api-docs.deepseek.com/quick_start/pricing ↩ ↩²

4. Cerebras, “Inference pricing.” https://inference-docs.cerebras.ai/support/pricing ↩ ↩²

5. Groq, “GroqCloud pricing.” https://groq.com/pricing/ ↩ ↩²

6. Anthropic, “Manage costs effectively” in Claude Code docs. https://code.claude.com/docs/en/costs ↩

7. Princeton NLP, “SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering.” https://github.com/SWE-agent/SWE-agent ↩

8. NVIDIA, “Blackwell architecture.” https://www.nvidia.com/en-us/data-center/technologies/blackwell-architecture/ ↩

9. AMD, “AMD Instinct MI300X accelerators.” https://www.amd.com/en/products/accelerators/instinct/mi300/mi300x.html ↩

10. Google Cloud, “Cloud TPU documentation.” https://cloud.google.com/tpu/docs ↩

11. Cerebras, “WSE-3.” https://www.cerebras.ai/product-chip/ ↩

12. Groq, “Groq technology.” https://groq.com/technology/ ↩

13. Mythic, “Analog compute technology.” https://www.mythic.ai/technology/ ↩

14. Mythic, “M1076 Analog Matrix Processor.” https://www.mythic.ai/products/m1076/ ↩

15. Taalas, “The path to ubiquitous AI.” https://taalas.com/path-to-ubiquitous-ai/ ↩

16. Tenstorrent, “Wormhole.” https://open.tenstorrent.com/hardware/wormhole ↩

17. SambaNova, “SambaNova technology.” https://sambanova.ai/technology/ ↩

18. Etched, “Announcing Etched.” https://www.etched.com/announcing-etched ↩