We’ve Built 1% of the AI Compute the World Needs

We’ve Built 1% of the AI Compute the World Needs

The world needs a hundred times more compute than exists. The companies that build it are already worth trillions, and they will have to get far bigger to deliver this future.

Connect on LinkedIn: https://www.linkedin.com/in/patrick-toulme-150b041a5/

Follow on X: https://x.com/PatrickToulme

Code reproduction: https://github.com/patrick-toulme/justabyte/blob/main/ai_compute_1_percent_post/compute_model.py

What happens when a software engineer stops using one AI agent and starts commanding a swarm of fifty? When a quarter of adult Americans each have an AI that staffs a team of agents the way a manager staffs a project? In this scenario you don’t get one agent per person. You get a planet trying to run billions of always-on agents, with nowhere near the silicon to do it.

This article will argue that the US and world economies are changing rapidly, that AI silicon is the bedrock of that change, and that we have built very little of the compute this future requires.

Today the world has roughly 19 million H100 equivalent AI chips. That is every Hopper, every Blackwell, every Google TPU, AWS Trainium, Meta MTIA, AMD, Cerebras, Groq etc. ever shipped and still racked, added up and normalized to one unit. It is the core of the AI economy: about 38 zettaFLOP/s of FP8 compute, most of it built in the last eighteen months.

Here is the thing people get wrong about the demand side. They picture one agent per human and ask whether that is realistic. No human is going to manage a hundred agents by hand. You talk to one AI, and it runs the swarm of agents for you. It plans, spawns subagents, runs them in parallel, and hands back a result. The human stays in a single conversation; the machine fans out into hundreds. That is already how the best agentic coding tools work, and open-source models such as GLM-5.2 and Kimi K3 are now capable of orchestrating these massive swarms of agents.

So take a grounded case, and a deliberately partial one. Not all 8 billion humans. Not even all of the world’s roughly 1 billion knowledge workers, because not everyone will adopt this or afford it. Just half of them, about 500 million people, each with an AI that runs a modest 50-agent swarm. How many chips does that need?

About 830 million chips. Roughly 44 times every AI chip that exists.

This article shows the math behind that number, and the scale at which the world has to build compute to make this future real.

That 830 million is not the aggressive case. It is a conservative reading, on a cheap open model, for a deliberately narrow slice of the workforce. I picked one legible group on purpose, as a frame of reference: analysts, engineers, and lawyers using a team of agents at work, and only half of them. One ordinary slice already needs 44× every chip on Earth, and the slices I left out stack fast. The other half of knowledge workers: another 44×. Three billion consumers with even a five agent helper for daily life: another ~26×. The floor climbs past 100×, of which we’ve built about 1%. We are not oversupplied on AI compute. We are not even close.

I want to make this concrete and reproducible, so I built a small parametric model and sourced every input to SemiAnalysis numbers where they exist. The experiment is ~150 lines of Python, linked at the end. This code powers the graphs in this article, and you can change any assumption you disagree with and watch the conclusion move.

The conclusion does not move much.

The unit, and the question

Everything here is in H100 equivalents (H100e), FP8 throughput convention: a Blackwell counts as ~2.3 H100e because it does ~2.3× the FP8 work.

The thought experiment has one assumption worth stating upfront: what does “running AI” mean per person? I model always-on agents: not chats you prompt a few times a day, but workers that generate tokens continuously. And every frontier model people actually use now is a reasoning model, one that generates a long hidden chain of thought before it answers, roughly 8× the tokens of a non-reasoning model. So I count generated tokens, reasoning included, at a sustained 40 tokens/sec per agent, averaged over the full day, with a floor of 15 and an aggressive case of 100.

The unit of demand is the swarm, not the person. Here’s how that actually works. A user opens one session and states a goal. An orchestrator model reads it, breaks it into pieces, and spawns subagents (a planner, a handful of coders, reviewers, test writers, researchers) that run in parallel, each in its own context, and report back. Chain those steps and you have a workflow: the orchestrator fans work out, gathers the results, and decides what to do next. No human is monitoring the 50 agents. The human is managing one agent, and that agent is managing the rest. So the thing that scales isn’t how many people adopt AI. It’s how many agents each person’s AI is running, and that number is climbing from one toward the hundreds.

I sweep that swarm size across grounded populations: all software engineers (~28 million, per JetBrains/SlashData), a fraction of adult Americans, and half the world’s ~1 billion knowledge workers. I sweep one more axis underneath everything: model size, from 10B to 100T parameters because the entire argument bends on it.

What the world has now

The installed compute base is ~15–20M H100e (Epoch put global capacity at ~15M in early 2026, and it’s doubling roughly every seven months). NVIDIA’s own fleet, its millions of Hopper GPUs plus the fast-ramping Blackwell, comes to roughly 11M H100e, but it does not own the whole fleet. The custom accelerators are not a rounding error: Google is in fact the single largest owner of AI compute, holding about a quarter of the world’s total, mostly its own TPUs (Ironwood does 4.6 PFLOPS FP8 with ~4.3M TPUs shipping in 2026). AWS has 1.4 million Trainium chips deployed across three generations, over a million of them running Anthropic’s Claude; AMD’s Instinct is at a $10B-a-quarter run rate, and Microsoft’s Maia, Meta’s MTIA, and Huawei’s Ascend add more. Let’s call the world total ~19M H100e.

AI compute production is rapidly growing. NVIDIA went from ~3.5M datacenter GPUs in 2024 to ~6.5–7M in 2025, up ~55% in units and ~68% in revenue, and the fleet’s compute is roughly doubling every nine months. Across every vendor, that’s ~16M H100e added per year and rising.

Here is the part that matters: you cannot simply print these. The binding constraint on AI chip production is not logic dies; those are abundant, and AI silicon vendors just outbid everyone else for leading node wafers. The constraint is advanced packaging (CoWoS) and HBM. In 2025 the four largest AI chip designers consumed ~90% of global CoWoS capacity and HBM supply while using only ~12% of advanced logic production. CoWoS has roughly doubled every year (16k → 40k → 70k → 130k wafers/month from 2023 to 2026), and HBM has been sold out through 2026, with SK Hynix at 62% share supplying ~90% of NVIDIA’s stacks.

The supply of AI chips is a physical pipeline with significant resource constraints.

What one model costs to serve

To serve a model you need two things from your chips: enough memory to hold the weights, and enough memory bandwidth to stream them per token. For frontier models, bandwidth is the wall.

Three facts set the per-chip economics, and all three are well grounded in real 2025 deployments:

1. Frontier models are sparse, and getting sparser. No one serves a dense 10T model. Frontier models are Mixture of Experts, and the active fraction shrinks as total size grows: DeepSeek-V3 activates 37B of 671B (5.5%), the open GLM-5.2 activates ~40B of 744B (5.4%), Kimi K2 activates 32B of 1T (3.2%), and the largest open model yet, Kimi K3, activates ~104B of 2.8T (3.7%). The optimal sparsity curve bends down with scale, and deployed models are more aggressive than optimal because serving economics reward it. Active params grow sub-linearly: I model 10B→3B active, 100B→12B, 1T→40B, 10T→200B, 100T→1T.

2. Decode is memory-bandwidth bound. To generate one token you stream every active parameter out of HBM once. The roofline is simply tokens/sec ≈ HBM_bandwidth / (2 × active_param_bytes). On an H100 (3.35 TB/s) with 37B active params in FP8, that’s ~45 tokens/sec, single stream. This is not a FLOPs problem. It’s a “how fast can you read the weights” problem, and it’s why bandwidth, not compute, is the decode bottleneck for essentially every model chip pair.

3. Batching helps, but reasoning caps it. That 45 tok/s is one user at batch one. Batch many users together and you amortize each weight read across all of them, but only down to the latency your users will tolerate, and reasoning users tolerate very little, as a 25,000-token thinking trace served at low interactivity would take half an hour. So you serve at a usable speed, and SemiAnalysis’s InferenceMAX measures exactly what that costs. For DeepSeek-R1 (a reasoning MoE, 37B active) at ~42 tokens/sec/user, an H100 manages just 266 tok/s/GPU and a B200 4,792, about 2,080 per H100-equivalent. Blend a Hopper and Blackwell fleet and you land near 1,300 tok/s/H100e for a 37B-active model; I scale it inversely with active params.

(And 1,300 is still generous: it assumes a Blackwell-heavy fleet. An H100-only fleet serves ~5× worse, at 266 tok/s/H100e, and pushing interactivity higher, to 71 or 100 tok/s/user, collapses throughput further still. Every one of those moves makes the numbers below bigger, not smaller.)

One caveat the other way: I run all of this in FP8. The frontier is sliding to FP4 (DeepSeek quantizes FP8→NVFP4 with under 1% accuracy loss; Together and Fireworks already serve it, and Kimi K3 now ships its weights natively in MXFP4, quantization-aware trained from the SFT stage on), which roughly halves every chip count here.

Put it together and you get the per-chip serving rate for each model size. Now apply it to a realistic slice of the workforce.

A fraction of people, each running a swarm

All humans do not need to use AI agents for the world to be extremely compute constrained. We only need a slice of the workforce running swarms on a cheap, open model, and that is already happening.

Every line crosses the world’s entire chip fleet almost immediately. All ~28 million software engineers, each driving a 50-agent coding swarm, need ~47 million chips, 2.5× every AI chip on Earth, and they cross the fleet at about 20 agents apiece. A quarter of adult Americans (~65 million people) on the same 50-agent swarm is 5.7× the fleet, crossing at roughly 9 agents each. And half the world’s knowledge workers, ~500 million people whose work happens on a screen, reach the entire global fleet at barely one agent apiece; give each of them a 50-agent swarm and you are at ~830 million chips, 44× everything ever built.

None of this assumes a giant model, universal adoption, or anyone managing more than one conversation. It assumes a cheap open model, a fraction of the professional world, and the swarm sizes agentic coding tools already ship.

And notice what this slice leaves out. Half of one profession is a frame of reference, not a forecast. I chose it because it’s easy to picture and easy to argue with. It counts no one using AI for their health, their kids’ education, their finances, their research, or their small business: the things that will reach billions of people who never call themselves knowledge workers. Each of those is its own swarm story. I left them all out, and the number is still 44× every chip on Earth. Add any one of them back and it only moves one way.

The model is a free download. The silicon isn’t.

The reason a fifty-agent swarm is realistic and not a thought experiment is that the model to run it already shipped, and it’s open. GLM-5.2, from Zhipu / Z.ai, is a 744 billion parameter model with ~40 billion active, released in June 2026 under an unrestricted MIT license with a 1-million-token context. It posts frontier-class agentic coding scores: 62 on SWE-bench Pro and an MCP-Atlas tool-use score of 77, within a few points of Claude Opus 4.8 on the long-horizon coding marathons. It speaks the Anthropic and OpenAI APIs, so it drops into Claude Code, Cline, or Cursor with a base URL swap, and the hosted API runs about $2 per million input tokens and $6 per million output, roughly a sixth of the closed leaders, with $18-a-month coding plans. I’ve run it myself: open model, open harness, local serving, frontier coding at essentially zero marginal cost.

And GLM-5.2 is no longer alone. Weeks after it shipped, Moonshot AI open-sourced Kimi K3: 2.8 trillion total parameters, ~104 billion active, native vision, the same 1-million-token context, weights free to download under a permissive commercial license. It posts frontier agentic scores of its own, 42.0 on SWE Marathon against Claude Opus 4.8’s 40.0, 88.3 on Terminal-Bench 2.1, with a hosted API at $3 per million input tokens and $15 per million output. Two labs, weeks apart, each handing the world a frontier-class agent orchestrator for nothing but the cost of the silicon to run it. The open frontier isn’t an event. It’s a cadence.

Here’s the part that matters for compute, and it’s the opposite of what “open and free” sounds like. Open weights don’t remove the silicon. They remove the brake. To actually serve GLM-5.2 you still need the chips: its weights are ~744 GB in FP8, a box of roughly eight datacenter GPUs before it generates a single token, and Kimi K3’s weigh ~1.4 TB even packed in 4-bit. What open weights remove is the meter. There’s no per-token bill capping how many agents you run, no vendor rate limit, no one deciding you’ve had enough tokens for the day. The number of agents you can run stops being a function of your API budget and becomes a function of how many accelerators you can get.

That is the demand engine for this whole piece. A closed, metered model self-limits: you run the agents you’re willing to expense. An open model you host yourself has one limit left, and it’s silicon. Make the best coder a free download and the rational move isn’t to run one agent and bank the savings; it’s to run fifty, because the marginal token is nearly free and not running the swarm is leaving value on the table. Open weights are Jevons’ paradox with the last brake cut.

It also globalizes the demand. A model on Hugging Face runs in any datacenter, any country, any startup’s basement. When the best model is an open download, no single vendor can even meter the world’s demand for it, let alone supply it. The only thing standing between an open frontier model and an unbounded swarm is the chip.

So run every scenario in this piece on GLM-5.2 specifically, with its real 40 billion active params setting the per-chip rate. That’s a deliberately conservative anchor: Kimi K3 activates ~104 billion params per token to GLM’s 40 billion, so a world whose swarms run on the newest open flagship instead needs roughly 2.6× every chip count below. Here is the bill:

single profession on a fifty-agent swarm already needs more chips than every vendor has ever built. The model is free. The hundred million plus chips to run it are not.

To put the swarm in everyday units: half the world’s knowledge workers, 50 agents each, generate on the order of 80,000 trillion tokens a day. The entire AI industry today, every ChatGPT session and every Gemini call, runs about 50 trillion tokens/day. One slice of one profession is already on the order of 1,000× the world’s current token output.

What happens when some people want faster inference?

Everything above assumes standard reasoning serving: ~40 tokens a second per agent, the InferenceMAX operating point. That’s fine for a background worker. It is too slow for the thing people actually pay for.

Watch a developer drive an agentic coding tool and you’ll see the real demand. They want the answer now. Not 40 tokens a second but 100, 200, as fast as the model can think, because a human is sitting there waiting and their time is worth more than the GPU’s. More importantly, they will pay for it. A coding agent that’s 3× faster is worth a lot more than 3× the price, because for that workload latency is the product.

But speed and batching are opposites. To make one request faster you pull it out of the batch and hand it more of the chip. On InferenceMAX, pushing DeepSeek-R1 from ~42 to ~100 tokens/sec/user on an H100 cuts throughput from 266 to 23 tok/s/GPU, more than 10× the silicon per token. I’ll be conservative and price the premium tier at a flat 3×.

Put a slice of the world on that fast tier and the whole curve lifts:

If that knowledge worker swarm ran on the fast tier, the bill goes from ~830 million chips to ~2.5 billion, 131× the world’s entire fleet. Even a modest 20% premium segment adds ~330 million chips on top. And this is the high-margin demand: the customers who pay 2–3× are precisely the ones who make a chip most worth selling. The latency-sensitive tier doesn’t just add load. It adds the load people are most willing to fund. Those who are running fast-tier inference for agentic coding will be running a lot of it and paying virtually whatever it costs.

What about AI training? Pretraining is a rounding error. RL isn’t.

You might expect pretraining these large models to dominate the bill. It doesn’t, and the gap is very illuminating.

Training cost is 6 × active_params × tokens. Run the numbers (FP8, 35% MFU, calibrated to GPT-4’s 2.1e25 FLOP and the 100k-H100 cluster that retrains GPT-4 in four days): training and continuously refreshing a fleet of 20 frontier model lines at 10T params costs ~130k H100e as a standing fleet. At 100T, ~880k.

Against ~830 million chips for serving, training is under 0.03% of the bill. The two demand curves above are visually identical because the training contribution vanishes beneath them. This is the inference economy in one fact: once a model is good, the cost is in running it, forever, for everyone. The market still prices these chips as if training clusters were the demand. The demand is the billions of agents that haven’t been spun up yet.

That covers pretraining. But there’s a much more compute-hungry paradigm of training: RL post-training.

The scale up of reinforcement learning is the steepest curve in AI right now. Reinforcement learning was ~1% of pretraining compute before 2024; then under 10% for OpenAI’s o1, ~20% for DeepSeek-R1, and for xAI’s Grok 4, roughly parity, with RL run at pretraining scale on a 200,000-GPU cluster. Epoch estimates RL compute is growing ~10× every three to five months, against ~4× a year for pretraining. The two are converging now.

And here’s why it belongs in this article and not a training footnote: RL is inference-shaped. Its cost isn’t the gradient step; it’s rollout generation. To run RL you sample many long answers per prompt and grade them (DeepSeek-R1 drew 16 completions per question, up to 32,768 tokens each), and that generation, autoregressive memory-bandwidth-bound decode, is 70–90% of the wall-clock. As SemiAnalysis puts it, inference is “no longer just the end of the pipeline, but an integral part of training.” RL doesn’t dent the “serving dominates” claim. It is serving, pointed inward towards improving the model.

Pretraining plus RL across 20 frontier lines is ~260k chips, a rounding error against the ~830 million for serving. But at today’s scale it’s the whole story. Most of the current fleet isn’t serving the public at all: only ~30% of OpenAI’s 2024 compute went to inference, the rest to training, RL, and experiments, and ~40% of the world’s AI compute is training of one kind or another. That’s exactly why only ~60% of the fleet is free to serve, and why we’re so far from one agent per human. The compute to build the models is still eating the compute that would run them, and the fastest-growing part of that, RL, is itself inference.

You can’t ignore the gap in compute

The realistic scenarios need anywhere from a few times to a few hundred times the world’s AI silicon. How fast can we build it?

At ~16M H100e of net new production per year, closing this gap of ~830 million chips is ~50 years of the entire planet’s AI chip output, devoted to this one slice of the workforce, ignoring replacement of dying hardware. Production is growing ~1.6× a year in units, faster in H100e, so the real timeline is shorter. But the throat is CoWoS and HBM, and those double roughly once a year, not once a quarter. You cannot software your way out of a packaging constraint. You cannot fine-tune your way past an HBM shortage. The gap between “19 million chips” and “what a fraction of the workforce running swarms needs” is not a market sentiment. It’s a decade plus of the hardest manufacturing on Earth running flat out.

This is the whole argument, and I’ve kept it in units of silicon on purpose. I’m not going to model market caps or P/E multiples. The installed base is the floor of the AI economy’s capacity, every credible demand scenario sits one to two orders of magnitude above that floor, and the floor is bottlenecked on two of the most capital-intensive, slowest-to-scale processes in existence.

And then you have to power them

All in (GPU, networking, cooling, grid losses), a modern AI chip pulls on the order of a kilowatt from the wall; a GB200 NVL72 rack is 120 kW for 72 GPUs, and since perf per watt keeps improving I’ll call it ~1 kW per H100 equivalent and be generous. Serving half the world’s knowledge workers a 50-agent swarm each, ~830 million chips, is then about 830 gigawatts of continuous draw.

Every data center on Earth combined draws ~55 GW today (≈485 TWh/yr, ~1.5% of global electricity). This one realistic case is roughly 15 times the entire planet’s current data center load, nearly double all the electricity the United States consumes, for a single slice of one profession. Push the swarm to 500 agents and it’s ~8,300 GW, many times US generating capacity.

And power moves slower than silicon. New generation and grid interconnects take 24 to 72 months; fewer than 5% of existing data centers can even feed a 50 kW rack, never mind 120. CoWoS doubles in a year; a substation does not. The demand curve isn’t sitting above one slow physical wall; it’s sitting above two in series, packaging and power, and it clears neither for a decade. The chips are useless without the watts, and the watts are harder to get than the chips.

Hardware vendors aren’t competing. There is no pie.

Here’s the pervasive story I want to kill. Every quarter someone writes that NVIDIA, Google’s TPU, AWS Trainium, AMD, and Cerebras are locked in a fight for the AI accelerator market: a fixed pie, each new entrant taking a slice from the rest, winners and losers.

This is wrong. There is effectively infinite demand for AI silicon. One vendor cannot supply the entire market.

Putting the numbers on it:

Add up every AI chip from every vendor: ~11M H100 equivalents of NVIDIA, ~4.8M of Google TPU, ~1.2M of AWS Trainium, AMD’s ~1M, and the rest (Maia, MTIA, Huawei). You get about 19 million chips. That total, the entire industry’s combined output, doesn’t even cover all the world’s software engineers running a 50-agent coding swarm, which needs ~47 million chips, 2.5× every chip every vendor has ever made. A quarter of adult Americans on the same swarm needs ~109 million, ~6×; half the world’s knowledge workers, ~830 million chips, 44×.

When demand sits anywhere from a couple times to many hundreds of times above the combined supply of every manufacturer, those manufacturers are not competing for customers. There aren’t enough chips in existence to fight over one. NVIDIA at ~58% share isn’t winning a zero-sum game against Trainium; they are both selling everything they can build into a market that would swallow dozens of times the volume. Cerebras and Groq aren’t stealing NVIDIA’s inference business. They’re additional capacity aimed squarely at the low-latency premium tier from two sections ago, which is additive demand NVIDIA can’t fully serve anyway.

The real competition isn’t vendor versus vendor for customers. It’s all vendors versus physics for CoWoS and HBM, the shared, sold-out chokepoint upstream of all of them. They’re not fighting over the pie. Which is also why portability is a myth: when every vendor is supply limited, each one optimizes its own stack to the metal and sells out regardless. Nobody is losing deals over a missing CUDA shim; they’re losing them over packaging substrate.

How to break this

I held the whole model to one rule: every uncertain assumption breaks toward supply. So the real numbers are likelier to be worse, not better. The knobs, and which way they push:

Throughput. I used ~1,300 tok/s/H100e: InferenceMAX at 42 tok/s/user, blended across a Blackwell-heavy fleet. An older H100-heavy fleet serves ~5× worse (266/H100e), and the faster interactivity coding agents demand cuts it further. Realistic serving pushes the numbers up, not down.

Sparsity. If active fractions don’t keep shrinking (if a 10T model needs 500B active, not 200B), serving costs roughly 2.5× more. My schedule is optimistic for supply here too: Kimi K3 already runs above it, at ~104B active where my curve implies ~80B for a 2.8T model.

Population intensity. Every number above uses the mid rate of 40 tok/s/agent. The floor is 15 (chips ÷ ~2.7); the aggressive case is 100 (chips × 2.5). Even the floor blows past the fleet at modest swarm sizes.

Model size is the real variable. This is the one that helps supply. If a few billion parameter model turned out to be all anyone needed, today’s fleet could nearly cover one agent per human. The entire bull case for “we have enough chips” is “models get smaller and we stop wanting more of them.”

What I don’t model. Fleet depreciation and failures (GPUs last ~3–5 years, so a slice of annual production just replaces dead silicon), node-level memory and networking limits, and downtime. Each of these shrinks the effective fleet, so leaving them out is again supply-favorable.

What I’m not claiming: that a fifty-agent swarm lands in every knowledge worker’s hands next year. Adoption is slow, latency is hard, and most of the workforce isn’t running agents yet. This is a demand curve made of physics, population, and the economics of cheap agents, not a forecast of next year’s bookings.

“But models will get more efficient”

This is the last objection standing, and the one people are most certain of. Models will get smaller. A 10 billion parameter model will eventually match today’s 10 trillion parameter frontier through distillation, better data, and architectures we haven’t found yet. Serving collapses 60×, and the shortage solves itself.

It doesn’t. It inverts. This is Jevons’ paradox, the most durable pattern in the history of resource use: make something cheaper to consume and total consumption goes up, not down. Cheaper steam engines burned more coal, not less. Cheaper compute didn’t empty the datacenters; it built hyperscale. Make an agent 60× cheaper and nobody runs one agent and banks the savings. They run sixty. Then six hundred. Then a thousand, because at that price the only expensive thing left is restraint. We are watching it happen in real time. GLM-5.2 already put a frontier coder at a sixth the price as an open download, and the response wasn’t fewer agents. It was swarms. And the labs are now selling efficiency itself as the headline: Moonshot pitches Kimi K3 as 2.5× the intelligence per unit of compute of its predecessor. That gain won’t be banked either. It will be spent, on more agents.

So watch what a breakthrough actually does. Say a 100B model matches today’s 10T quality, and people respond the obvious way, not with one agent each but with a swarm:

A 100B model is 16× cheaper per agent than the 10T. So nobody who pockets that saving runs one agent and banks it; they grow the swarm. Take the same half-billion knowledge workers and give each a hundred agents on the cheaper model and you need ~500 million chips; push to a thousand, the number cheap agents actually invite, and it’s ~5 billion chips, 263× the entire world fleet, six times the realistic headline we started from. Even the most efficient case, a 10B model at frontier quality with a thousand agents each, is ~1.25 billion chips, 66× the fleet.

The efficiency breakthrough didn’t shrink the problem. It detonated it. And it compounds with everything else: a cheaper model is also a cheaper fast model, so more of that swarm runs on the premium tier instead of the batched one. Every gain in efficiency gets spent on more agents, running faster, for more people, until it slams back into the one wall that doesn’t move: how fast the world can package silicon and stack memory.

This is the deep reason the chips are the floor and not the ceiling. You cannot make models efficient enough to escape it, because efficiency is the thing that creates the demand. The cheaper inference gets, the more of it the world buys.

Does this mean the stocks are cheap?

Regardless of what you believe about a future in which humans are running agents 24/7, the direction the world is taking is undeniable. Models keep getting more useful. Agents multiply rather than consolidate; every coding tool already spawns dozens at once. Token volume is growing severalfold a year; ChatGPT went from 400M to 900M weekly users in twelve months. You don’t need my exact scenario. You need any point on that curve a few times past today, and every one of them sits far above the installed base, behind two walls that take years to move.

That’s the valuation argument, and it’s why I kept the whole piece in chips. When demand is structurally multiples above supply, and supply is gated by fabs and power on multi year clocks, the gap clears exactly one way: the companies that make the packaging, the HBM, the accelerators, and the power have to get much bigger, in absolute terms, for a long time. “Undervalued” here isn’t a P/E call or an entry price. It means the market is implicitly pricing this fleet as if it were near its mature size, when the arithmetic says it’s a small multiple of the floor.

Conclusion: There is no bubble in AI.

The reflexive take on AI compute is that it’s a bubble: too many GPUs, too much capex, a glut waiting to clear. Run the demand side in units of silicon and the opposite falls out. Today’s entire global fleet can’t cover even a fraction of the workforce running modest agent swarms on a cheap open model. That is the most grounded scenario in this piece, and it’s already ~44× every chip on Earth, for one ordinary slice of working life. Every step up (bigger swarms, more people, faster tiers, larger models) multiplies the requirement further past everything that exists. Agents are multiplying from one toward the hundreds. The world has 19 million chips.

The chips aren’t overbuilt. They’re the floor of a new economy we’ve barely started building. The companies that make the packaging, the HBM, and the accelerators aren’t selling into a glut. They’re selling the first 1% of the substrate, against a demand curve set by the size of the workforce and the swarms it will command.

Every one of these companies is already among the most valuable on Earth. Every one of them is still too small for the floor it’s standing on. That’s the part the market hasn’t priced: not that the chips are overbuilt, but that the people who build them have barely begun.

A new economy is forming, one in which the foundations are in silicon.

Connect on LinkedIn: https://www.linkedin.com/in/patrick-toulme-150b041a5/

Follow on X: https://x.com/PatrickToulme

Model: compute_model.py, ~150 lines, every figure and number reproducible. Chip counts in FP8 H100-equivalents; supply figures SemiAnalysis-derived via IFP and Epoch; serving economics calibrated to SemiAnalysis InferenceMAX and LMSYS; training to SemiAnalysis cluster figures and Epoch. Every source is linked inline above. Change any number you doubt and rerun; the gap survives it.

Cover. exist today: 19M. 44x every AI chip on Earth. And that's one slice of the workforce.

Chart. You don't manage the swarm. You talk to one AI that runs it. Chips for realistic populations as each person's AI runs a bigger swarm · GLM-5.2-class open model. Agents in the swarm (per person): 1, 10, 50, 100, 500. Series: All software engineers (28M); 1-in-5 adult Americans (52M); 1-in-4 adult Americans (65M); Half the knowledge workers (~500M); all AI chips today (~19M). @PatrickToulme · patricktoulme.substack.com

Chart. Give half the knowledge workers an AI that runs a team of agents. NEED 832M chips. exist today: 19M. 44x every AI chip on Earth. And that's one slice of the workforce. 50-agent swarm · open model. JUST A BYTE. @PatrickToulme · patricktoulme.substack.com

Table. Every scenario, run on GLM-5.2. GLM-5.2 · 744B total / 40B active · open weights (MIT) · 40 tok/s per agent · vs the 19M-chip world fleet. Scenario | Always-on agents | Chips needed | x world fleet | Power. All software engineers · 50 swarm: 1.4B, 47M, 2.5x, 47 GW. 1/5 adult Americans · 50 swarm: 2.6B, 87M, 4.6x, 87 GW. 1/4 adult Americans · 50 swarm: 3.3B, 109M, 5.7x, 109 GW. Half of knowledge workers · 50 swarm: 25B, 832M, 44x, 832 GW. Half of knowledge workers · 500 swarm: 250B, 8.3B, 438x, 8,316 GW. Swap in Kimi K3, the newest open flagship (2.8T total / 104B active): every count x2.6. serving only · 40B active sets the per-chip rate. JUST A BYTE. @PatrickToulme · patricktoulme.substack.com

Chart. The speed premium. Half the knowledge workers · 50-agent swarm: fast coding trades ~3x the chips per token. Model size (total parameters): 10B, 100B, 1T, 10T, 100T. Series: Standard reasoning batch (40 tok/s); 20% on premium fast tier; All premium · 3x chips; world fleet today (~19M). JUST A BYTE. @PatrickToulme · patricktoulme.substack.com

Chart. Then you have to power them. Half the knowledge workers · 50-agent swarm 832 GW. All US electricity 470 GW. Every data center on Earth 55 GW. ≈ 15x every data center on the planet. And a grid interconnect takes 2–6 years. 50-agent swarm · open model. JUST A BYTE. @PatrickToulme · patricktoulme.substack.com

Chart. They aren't competing. There is no pie. Every AI chip from every vendor, vs. a fraction of the workforce running swarms. NVIDIA 11M. Google TPU 4.8M. AWS Trainium 1.2M. AMD 1M. Others 1M. ~19M All AI silicon (every vendor). 47M All SWE x50 swarm. 109M 1/4 US adults x50. 832M Half the KW x50 swarm. JUST A BYTE. @PatrickToulme · patricktoulme.substack.com

Chart. The gap: chips needed vs. chips that exist. Serving + all training & RL, against the world's fleet. Model size (total parameters): 10B, 100B, 1T, 10T, 100T. Series: Half the knowledge workers · 50 swarm + training/RL; Software engineers · 50 swarm + training/RL; all AI chips today (~19M); usable to serve now (~60%). JUST A BYTE. @PatrickToulme · patricktoulme.substack.com

Chart. A cheaper model just means everyone runs a swarm. If a small model matches today's frontier, the same people just run bigger swarms · half the knowledge workers. Agents per person (concurrent, always-on): 1, 10, 100, 1000. Series: 10B model = frontier quality; 100B model = frontier quality; 1T model = frontier quality; realistic case: half the KW · 50 swarm; world fleet today (~19M). JUST A BYTE. @PatrickToulme · patricktoulme.substack.com