Agentic AI’s Compute Shortage Is a Narrative, Not a Number

The most expensive sentence in technology right now is seven words. “500,000 users today, 100 million tomorrow.” It is attributed to Gavin Baker, or at least to a headline wearing his name. It is not a forecast. It is a load-bearing narrative. A load-bearing narrative is a sentence that supports an entire investment thesis, a token design, a road map, and in some cases an orbital launch contract, without ever being checked. The chain looks like this: agentic AI will create users in the hundreds of millions. Each agent will need absurd amounts of inference compute. Therefore compute will be the scarcest asset in the world. Therefore we need radical infrastructure, perhaps compute in orbit. Every link in that chain is emotionally satisfying. Every link deserves to be audited. I have spent the last few years doing exactly that. I audited bZx v3 in 2020 and found an integer overflow in the flash-loan repayment logic before it was exploited. I reverse-engineered optimistic rollup fraud proofs in 2022 and published gas-efficiency comparisons between EVM and Cairo execution. I benchmarked zkSync Era’s STARK circuits against Polygon CDK in 2024. I led a post-mortem of three cross-chain bridge exploits in 2025. None of that experience tells me whether agentic AI will have 100 million users. But it tells me how a narrative slips past a code review. The source material here is a news flash. It is short. It is thin. It is the kind of content that gets republished because the headline is quotable, not because the analysis is sound. The only concrete event in the story is that someone made a claim. The rest is extrapolation: more users, more compute, not enough supply, then a pivot to “non-traditional solutions” such as orbital data centers. There is no data table, no timeline, no GPU count, no unit economics. There is just a signal, compressed into a sentence. That is why I want to review the sentence the way I would review a smart contract: premise, constraints, execution, fallback. The Premise Is Not Wrong Here is the uncomfortable truth. The quote is saying something that is, at a high level, technically plausible. Agentic workloads are structurally different from conversational AI, and the difference is not incremental. It is a multiplier. Conversational AI is a request-response model. You type a prompt. The model returns a completion. The interaction ends. The compute cost is exhausted in a single forward pass, or maybe two if you count an initial retrieval stage. An agent, by contrast, is a loop. It receives a goal. It plans. It calls tools. It reads tool outputs. It replans. It calls more tools. It verifies. It sometimes calls sub-agents. Each step in that loop can trigger one or more LLM inference calls. Each tool output arrives as raw text that must be re-tokenized and re-fed into the context window. Each planning step can consume as many tokens as an entire ChatGPT conversation. This is not a product defect. It is the architecture. A coding agent like Claude Computer Use or ChatGPT Operator can exhaust a context window on a single task in a way that would be embarrassing for a chatbot. I saw the same dynamic in my ZK benchmarking work. When you increase the number of constraints in a circuit, proving time does not increase linearly. It increases with the complexity of the constraint system. With agents, every tool call adds a new constraint to the “world model” the agent is trying to maintain. The compute curve is not a line. It is a staircase. So the statement “we do not have enough compute for 500,000 agentic AI users” is not insane on its face. If each user is a research analyst agent running a dozen expensive models per task, the token throughput could be orders of magnitude higher than the entire conversational ChatGPT user base. You could plausibly build a $100 million data center and have a few thousand agents saturate it. But then the narrative gets sloppy. The Number Is a Story, Not a Measurement “500,000 users today, 100 million tomorrow.” Let us treat as a variable. What is a user? Is it a person who has used an agentic product once? Is it a monthly active installation? Is it an API key? Is it a session that completed at least one task? In the absence of a definition, is not a measurement. It is a vibe. The same applies to . The original quote, as transmitted through the news flash, does not specify whether “not enough compute” means training compute, inference compute, peak throughput, sustained daily workload, or the limited availability of a specific GPU SKU. In my experience analyzing infrastructure, these distinctions matter more than any headline. A 100 million-user agentic product could be built on a platform where the average task consumes 2 million tokens. Or it could be built on a platform where the average task consumes 200 billion tokens. The difference is four orders of magnitude. “Not enough compute” is not a technical claim. It is a call to action. There is a second problem with the 200x growth number. You cannot have 500,000 users today already exhausting the compute supply, and then multiply by 200, without explaining why the supply is not elastic. GPUs have lead times measured in quarters. Data centers have lead times measured in years. But the cloud is not a fixed pot. If an agentic product generates enough revenue per user, it can simply buy more compute. The real constraint is not absolute compute. It is unit economics: compute cost against the value generated by an agent. If a user is worth $100 and consumes $200 in inference, then no compute supply is enough. If a user is worth $1,000 and consumes $20, then the shortage is a construction of the pricing model. Baker’s quote bypasses all of this. It collapses supply and demand into a single narrative clause: not enough compute for either. That clause is designed to be emotionally true. It is not designed to be analytically true. Let me put some numbers on the table, because numbers are the only thing that make a compute argument honest. Suppose a conversational ChatGPT power user sends 20 prompts per day, with an average of 1,000 input tokens and 1,000 output tokens per exchange. That is 40,000 tokens per day. Now suppose an agentic AI user works on one complex task: a code migration, a financial report, a market analysis. The agent might make 10 planning calls. Each planning call reads the entire current context, which could be 50,000 tokens. It might call 20 tools, and each tool response is irrelevant until it is re-embedded into context. That means 30 or more long inference calls per day, each with a 50,000-token context window. The total is 1.5 million tokens per agent per day. That is 37.5x the heavy conversational user. At a conservative $3 per million output tokens, one agent task might carry $4.50 in direct inference cost before any API overhead, tool fees, or failed attempts. And failed attempts are the hidden tax: an agent often retries a step two or three times before success. Now multiply that by 500,000 users. That is 750 billion tokens per day just from the “today” number. For 100 million users, if the same pattern holds, the daily figure becomes 150 trillion tokens. You are no longer talking about a datacenter shortage. You are talking about a planetary energy problem. But this is the point: the 500,000-to-100,000,000 ratio is built on an assumption about the workload. If workloads become more efficient, if models get distilled, if agents cache their context, if most tasks are simple, then the ratio collapses. If workloads become more ambitious, then the ratio is worse. A single number with no workload definition is not an analysis. It is a rhetorical amplifier. The Orbital Fallback Is a Tell The most revealing part of the source article is not the quote about users and compute. It is the implication that the compute shortage is so severe that we need non-traditional solutions, with orbital compute at the top of the list. Let me be direct. Orbital compute is not a solution to the agentic AI compute shortage. It is a symptom of narrative inflation. When a technology story has reached the point where it requires a satellite constellation to be plausible, you are no longer reading engineering. You are reading marketing. I am not saying orbital data centers are impossible. You can theoretically launch GPUs into low Earth orbit, power them with solar panels, and cool them with radiative surfaces. The physics is not forbidden. But the economics and latency are brutal. Start with launch cost. Even with reusable rockets, the cost per kilogram to low Earth orbit has fallen, but it is still high enough to make a GPU in orbit a luxury item. A single H100 GPU weighs about 1.2 kilograms without its full server system. Add the chassis, power supply, radiation shielding, and network equipment, and you are paying launch prices for a machine that will be obsolete in two years. The cost of launching a data center would exceed the cost of the data center itself by an order of magnitude. The same capital could buy more ground-based GPUs, better cooling systems, or more fiber connections. Then there is thermal management. In a data center on Earth, heat is removed by air or liquid flow. In orbit, the only way to reject heat is radiation. That means large radiator panels, careful orientation, and a power budget that must include not just the GPU but the thermal control system. The cooling problem does not disappear in a vacuum. It becomes harder. You cannot put a cooling tower in orbit. You cannot install a liquid cooling loop and swap out a faulty pump. You are dependent on radiative surface area, and radiative surface area is expensive. Then there is latency. The speed of light in a vacuum is fast, but it is not infinite. A low Earth orbit satellite is about 500 to 2,000 kilometers above the ground. Round-trip latency to a ground station is roughly 10 milliseconds in ideal conditions, on par with a mediocre internet connection. But that does not include downlink scheduling, packet loss, or the fact that a LEO satellite passes over a given ground station for only a few minutes per orbit. The satellite would need dense inter-satellite links and a huge number of ground stations, each with high-bandwidth radio spectrum. At the end of that chain, an agent that needs to respond in 200 milliseconds would be at the mercy of a network that was never designed for interactive inference. And then there is maintenance. A dead GPU in a terrestrial data center is a warranty claim. A dead GPU in orbit is space debris. No one is replacing a failed NVLink or a broken fan in orbit. Radiation, thermal cycling, and the inability to swap modules make orbital infrastructure fundamentally less reliable than a data center in Utah. High-performance electronics in space need radiation-hardened components, and radiation-hardened components are not the state-of-the-art GPUs you would use for inference. The more powerful the chip, the more sensitive it is to bit flips. That is not a small design detail. For an AI agent, a single corrupted bit in the wrong place can cause a nonsense output. Error-correcting memory helps on Earth. In space, the error rate is higher, and the cost of handling errors is higher. The orbital compute story is a perfect Keynesian beauty contest. It is not about technical feasibility. It is about telling a story that is one step ahead of the listener’s imagination. In a bull market, imagination is the most overvalued asset class. The Blind Spot No One Is Auditing Here is the contrarian angle. The compute shortage narrative, as told through the Gavin Baker quote, is missing the actual bottleneck of the agentic future. It is not compute. It is verification. An AI agent does not just need to think. It needs to act in a world where the results of its actions must be checked. If an agent moves money, who verifies the transfer? If an agent signs a message, who verifies the key? If an agent consumes compute and produces output, who measures the output and decides that it is worth the input? In the current web, this work is done by platforms and trust. A chat interface says, “Here is the answer,” and you trust the logo. But in an agentic world, agents will be independent economic actors. They will buy services from other agents. They will pay for compute, data, storage, and inference, and they will need to settle those payments without a human watching every transaction. Trust is a legacy variable. In the human economy, trust is handled by legal contracts, banks, reputation, and a healthy amount of hope. In a machine economy, that approach fails. An agent has no legal identity. It cannot be sued. It cannot be shamed. It can only be constrained by the economics of the network it operates on. That is exactly the problem blockchains were built to solve. Not the compute problem. The accounting problem. I learned this lesson the hard way in 2025, after leading a post-mortem analysis of three cross-chain bridge exploits. The total loss was around $400 million. The smart contracts themselves were not always the weakest link. The signature verification requirements were. The bridges relied on off-chain committees, centralized multisigs, and social consensus to update parameters. When one of those trust anchors was compromised, the contracts were helpless. Code does not lie, but it can be misled. The same principle applies to AI agents. You can give an agent a wallet and a set of permissions. But if the agent’s inference results are not verifiable, and if there is no mechanism to prove that a computation happened correctly, then the agent’s decisions are just unauthenticated trust. The 100 million-user future will fail not because of FLOPS, but because of unresolved disputes. When agent A pays agent B for a computation, and agent B returns garbage, who decides? The only sustainable answer is a verifiable computation market, where results are accompanied by proofs and where economic settlement is built into the protocol. This is where zero-knowledge circuits enter. ZK-circuits are compressing the future. They compress a long computation into a short proof, and that proof can be checked for a fraction of the cost of re-running the computation. For agents, this is not an optimization. It is a survival requirement. If an agent is going to spend real money on inference, it needs to be able to prove that the inference was performed correctly, or at least that it was performed by the claimed model. Otherwise, the entire agent economy runs on honor, and honor is not a settlement layer. The industry tends to frame this as an AI scaling problem. I see it as a cryptographic accounting problem. The Layer 2 world already made this exact mistake. We spent years building dozens of rollups, each with its own sequencer, its own bridge, its own trust assumptions, and the result was not a single scalable ecosystem. It was liquidity sliced into fragments. The same fragmentation will happen in the agent economy if we build 10,000 independent agent frameworks, each with its own native wallet and no common ledger. The agents will not be able to pay each other. They will not be able to prove anything to each other. They will be the equivalent of siloed rollups without a shared bridge. And when that happens, people will blame the compute supply, because it is easier than admitting the coordination layer was missing. Machine-Readable Economics Is the Real Infrastructure I have been working on a framework for machine-readable economics for the past year. The core question is simple: how do you price a micro-transaction that is executed by an AI agent in a few milliseconds? A human does not want to approve every tiny payment. The agent must have a spending budget, a pricing oracle, and a way to detect whether it is being overcharged. That requires a tokenomic model where the cost of a unit of computation is transparent and verifiable. It is not enough to say “the price is set by the market.” The price must be sampled by an agent, committed to a ledger, and settled atomically. This is not a GPUs-in-space problem. It is a protocol design problem. The compute is somewhere. The question is whether the agent can prove it got the compute it paid for. This is why I believe the Layer 2s that will win the agentic AI era are not the ones with the largest grants or the loudest marketing. They are the ones that can process high-frequency, low-value transactions with low latency and fraud resistance. They are the ones that can support on-chain verification of off-chain computation. They are the ones that can provide a trust anchor for an agent’s identity, reputation, and payment history. None of that appears in the orbital compute pitch. The pitch is about more hardware. The gap is about more governance, more proof, more finality. The industry is spending ninety percent of its mental energy on the first half of the problem, the production of compute, while the second half, the verification and settlement of compute, is funded as if it were a side quest. Think about the agentic future from the perspective of a Layer 2 sequencer. A single agent task might require one million tokens, one hundred tool calls, and a payment of a few cents to a data provider. If the agent is going to do that without human intervention, the sequencer must be able to process thousands of settlement transactions per second, each with a tiny value, each requiring a proof. That is the opposite of the current trend in crypto, which is to maximize transaction value and minimize transaction count. Agentic AI will invert that. It will produce billions of micro-transactions that all need to be settled before the agent can move on to the next step. Settlement latency becomes the ultimate bottleneck. And here is the irony. If the industry keeps believing the Baker quote, it will build rockets and GPU parks, while the actual shortage is in the settlement layer. We already have enough compute to run a meaningful agentic economy. What we do not have is a way to let agents pay for compute and prove that they received it, in a trust-minimized manner. Trust is a legacy variable, and the agentic AI era has no room for it. The Centralization Risk Hiding Inside the Shortage Narrative There is another layer to this story that the original news flash completely misses. A compute shortage is not only an engineering constraint. It is an allocation problem. If compute is scarce, who decides which agents get to use it? The narrative implies that the market will decide, but in practice the market is a small group of cloud providers, AI labs, and GPU brokers. A 100 million-user agentic economy cannot settle on an opaque queue controlled by a handful of platforms. This is where the crypto native instinct should kick in. Every shortage claim is a claim about price and access. A Bitcoin block is full, but there is a market price for block space. Gas fees adjust. Compute markets do not have a transparent pricing mechanism yet, which is why the shortage feels absolute. If agents cannot discover the price of compute in real time, they cannot make rational decisions. They will either overpay, or they will not act at all. The solution is a transparent market for machine-readable compute, where bids, asks, and proof of execution are recorded on a settlement ledger. The source article presents orbital compute as a way to escape terrestrial constraints. But the more interesting escape is from centralized allocation. A decentralized compute marketplace could pool GPU supply from many sources, price it by an oracle, and execute payments automatically. That would not require rockets. It would require better protocol design. It would also require a different definition of scarcity: the most important scarce resource is not the chip, but the trust that a chip actually produced the claimed output. I have seen this pattern before. In the 2022 bull market, everyone believed the problem was throughput. The market responded with dozens of Layer 2s. Each one claimed throughput. But the result was fragmented liquidity, worse user experience, and a series of bridge exploits. The problem was not speed. The problem was coordination and security. The agentic AI narrative is heading straight into the same trap. It is obsessing over an input metric, raw compute, while ignoring the output metric, verifiable action. A More Honest Forecast Let me give a different forecast. Not about user counts, but about constraints. In the next twelve months, you will see more agentic AI announcements than you can count. Most of them will be wrappers around existing models, with a wallet integration bolted on. A smaller group will develop actual agent protocols. The market will quickly realize that the user count is not the key metric. The key metric will be the ratio of verified computational work to unverified claims. Call it the proof ratio. The higher the proof ratio, the more durable the economy. The companies that win will be the ones that build a ledger agents actually want to use. That ledger must have three properties. First, it must be cheap enough for micro-transactions. Second, it must be fast enough for real-time agent interaction. Third, it must support cryptographic proofs of computation, so that agents can audit each other without a human. These are not new properties. They are the properties blockchain researchers have been chasing for years. The difference is that AI agents are about to become the most demanding users of this infrastructure. When an agent needs to buy a piece of inference output, it does not want a lawyer. It wants a proof. When it needs to settle a dispute, it does not want a courtroom. It wants a smart contract. When it needs to choose between two compute providers, it does not want a whitepaper. It wants a benchmark that is stored on-chain. This is not a world of orbital data centers. This is a world of cryptographic accounting. Code does not lie, but it can be misled. It can be misled by narratives, by unquantified user counts, and by heroic stories about space-based GPUs. The code that will matter in the agentic AI era is not the code that squeezes another fifteen percent proving-time improvement into a ZK circuit, although that is valuable. The code that matters is the code that connects machine intelligence to machine payment and makes every action auditable. ZK-circuits are compressing the future. But they are not compressing the compute itself. They are compressing the trust required to transact in a world of machines. That is the real infrastructure story. And it is happening on Earth, in ledgers, not in orbit. So the next time you hear “500,000 users today, 100 million tomorrow, and not enough compute for either,” I suggest you ask a different question. What counts as a user? What counts as compute? And when those 100 million agents wake up, who will vouch for them? The future does not need more GPUs in space. It needs fewer unverified transactions on Earth. The first layer to make agents accountable will be the one that captures the next hundred million users. They will not go to orbit. They will go to the chain.