Gavin Baker, one of the most quoted technology investors of this cycle, dropped a sentence that should have triggered a coordinated reassessment across two industries at once. 500,000 agentic AI users today. 100 million tomorrow. Not enough compute for either. That is not a forecast. It is a threat assessment. The market’s first reflex is to file it under “AI narrative.” That is a misread. This is a compute supply-chain event, and the most liquid venue for trading that event is not a cloud provider’s dashboard. It is a blockchain.
The original report that carried Baker’s comment was not a research piece. It was an opinion-transcription. It offered no verified dataset, no deployment timeline, no hardware inventory. But in a bull market, narratives move capital before the data catches up. The signal is still useful: a serious institutional investor believes the agentic demand curve has already crossed the physical supply curve. That has consequences for every market that trades compute, energy, or infrastructure tokens.
Let me be precise about what agentic AI actually is. It is not a chatbot with a plugin. It is an autonomous loop. A coding agent opens a repository, reads files, writes a test, runs it, observes an error, edits the code, and runs the test again. A browser agent clicks through a checkout flow, checks for a confirmation screen, and corrects itself. Each step can be a full model invocation, and the context window accumulates every previous step like a growing hash chain. The compute footprint is not additive. It is multiplicative.
I have spent years auditing GPU-backed token projects. The first question I ask is not “how fast is your network growing?” It is “where is the counterparty on the other side of this compute claim?” An audited ledger answers that question. A dashboard does not.
The first analytical error is to confuse users with requests. An ordinary ChatGPT conversation is usually a single inference event. User sends a prompt. Model emits a reply. One call, perhaps a few thousand tokens. An agentic workflow is a sequence of inference events. The agent plans, calls a tool, receives a tool result, recontextualizes, and plans again. A single user task can require dozens or hundreds of model invocations. Some agents maintain a running context of 100,000 tokens or more. If one agentic user consumes 10 to 100 times the compute of one chatbot user, the implied demand curve from 500,000 agentic users to 100,000,000 agentic users is not 200x. It is somewhere between 2,000x and 20,000x. That is not linear scaling. That is a structural discontinuity.
Let me make that concrete. A coding agent working through a complex refactor might read 50 files, produce 30 candidate patches, run the test suite three times, and summarise the results. That is hundreds of inference events, many of them processing context windows far larger than a typical chat message. The token consumption is not 2x or 5x a chatbot. It is often 50x or 100x. By the time the agent has finished, the supporting infrastructure has handled a sustained load that resembles a small batch inference job, not a real-time query.
Even the low end of that range is beyond the current supply schedule. The world’s GPU pipeline is not a faucet. TSMC’s advanced packaging capacity, HBM supply, data center power, and network interconnects all have multi-year lead times. A new fabrication facility takes years to qualify. A grid interconnection study can take longer. When an agentic user calls a tool 50 times, the function returns a result that must be re-processed by the model. This creates a bandwidth loop that stresses memory interconnects as much as FLOPS. The chips are not the only bottleneck. The memory and the interconnect are the bottleneck.
This is where crypto enters. Not because blockchains mint GPUs. They do not. Not because decentralized infrastructure networks can suddenly outbuild Amazon or Microsoft. They cannot, at least not at frontier scale. The blockchain’s contribution is accounting. A distributed ledger can record what compute exists, who is using it, at what price, and for how long. That is not a trivial feature. It is the prerequisite for a liquid forward market in compute.
Think of it as a compute registry rather than a compute cloud. The most successful crypto-compute projects will not be the ones that try to decentralize model training. They will be the ones that create verifiable metadata for GPU assets that are already owned by thousands of entities. Operators can tokenize their GPUs and commit to uptime. Buyers can lock in capacity with on-chain collateral. Lenders can finance hardware purchases with utilization-based repayment. Power lies in the code, not the community. The code defines the terms of service, slashing conditions, and price discovery. The community simply supplies the narrative.
But there is a wide gap between the narrative and the ledger. Based on my audit experience, I have examined GPU-backed protocols with dashboards that claimed 10,000 active GPUs. The on-chain utilization data showed a handful of recurring buyers. The advertised capacity was real in the sense that the hardware existed somewhere. It was not real in the sense of being available to the market. This mismatch is not a bug. It is the business model of many projects: attract token holders with phantom density, then sell tokens before utilization can catch up. The ledger remembers what the market forgets. The on-chain record will eventually expose the difference between announced capacity and executed contracts.
Part of my experience traces back to the 2021 Bored Ape liquidity audit. I followed irregular secondary-market trading patterns to bot clusters that inflated apparent volume by roughly 30%. The method was simple: identify counterparty clusters, check wallet reuse, and compare transaction cadence to organic behavior. Apply the same method to a GPU-backed token today. Check whether the network’s “active GPU” count is echoed in on-chain settlement volume. Check whether the buyers’ addresses reuse the same treasury wallet. Check whether the reported average utilization matches the hardware’s actual memory and bandwidth profile. In practice, many projects fail these checks. That is alpha.
There is another structural twist. When agents coordinate with other agents, the compute requirement grows quadratically. If each agent’s action depends on the output of another agent, the number of inference events scales with the number of interactions. A network of one million agents, each performing 100 actions, creates 100 million inference events, and each event triggers another round of context aggregation. The aggregate demand curve is not a straight line. It is exponential up to a saturation point. That saturation point does not yet exist in public cloud capacity.
The solution does not lie in simply buying more GPUs. It lies in making compute a financial instrument. An agent cannot hold a credit card. It can hold a wallet. It can sign messages. It can pay per inference. It can participate in a staking contract to guarantee availability. That is a native growth vector for crypto infrastructure. The first protocol that builds a credible forward market for compute will be more valuable than a chain that merely says “AI” in its token name.
Imagine a scenario in 2026. An AI startup needs 5,000 H100-equivalent hours per month. It does not want to negotiate with three hyperscalers and wait for a procurement review. It wants to buy a compute future: a tokenized contract that guarantees the use of a specific GPU cluster for a specific period, with automatic compensation if the provider fails to deliver. A smart contract can enforce that better than a lawyer can. It can key a payment stream to verified utilization proofs. It can issue a penalty if the model response time exceeds a threshold. This is not a future idea. It is what the crypto-AI sector should have been building since 2021.
The market’s reaction to Baker’s comment will likely be a rally in AI-themed tokens, GPU marketplaces, and any token that mentions “agentic” in its documentation. That rally does not have to be rational. Crypto often prices narrative before fundamentals. But the reason to track this space is not to chase the initial pump. It is to identify the protocols that can actually service an enterprise agentic deployment. Those protocols will have short waiting lists, active proof-of-utilization contracts, and a governance structure that makes slashing enforceable. The rest will be noise.
Now here is the contrarian part. The most seductive tail of Baker’s comment is orbital compute. The idea that data centers belong in space offers an escape from terrestrial grid constraints. But the physics is unforgiving. In a vacuum, the only way to reject heat is radiation. You cannot rely on air or water cooling. Every watt of compute in orbit requires a corresponding radiative surface. Add launch costs, ground-station bandwidth, latency constraints, and the impossibility of hands-on maintenance. Orbital compute is a long-duration research agenda, not a near-term capacity plan. It functions as storytelling. It makes the compute shortage sound heroic rather than structural.
The more believable near-term fix is software. Model compression, speculative decoding, shared KV caches, and agent routing can reduce compute demand by 10x without adding a single GPU. But none of these fixes have a logo that is easy to buy as a token. So capital will flow to orbital fantasies instead. That is the inefficiency. A project with a real scheduler and a real proof-of-utilization ledger will quietly outperform a project with a satellite mockup and a founders’ white paper.
There is a deeper blind spot in the compute scarcity frame. The scarcest resource may not be GPUs. It may be trust. Agentic AI remains unreliable. A coding agent that writes a single bad pull request can cost a company more time than it saves. A browser agent that buys the wrong product becomes a support headache. Enterprise procurement will demand service-level objectives, insurance, and auditability. That demand for auditability is exactly what a blockchain ledger provides, but it also means adoption will be slower than the headline suggests. The 100 million user assumption is an aggressive political claim, not a measured forecast. Agents fail. They fail in public. A user who spends 20 minutes correcting an agent’s shopping list will not return the next day.
The same pattern appeared during DeFi Summer. Governance tokens rallied before governance mattered. Yield farming dominated before any durable liquidity model existed. Today, compute tokens will rally before agents matter. The second-order trade is to wait for the inevitable utilization data and buy the survivors. A protocol that cannot prove its last 10,000 GPU-hours on-chain is just a pump with a white paper. Trust no one. Verify everything.
The next cycle’s winner is not the protocol with the loudest AI branding. It is the protocol with the most explicit proof that a GPU was used, by whom, and for what price. Agents will need to purchase compute the way banks purchase collateral: with attestation, audit trail, and enforceable consequences. The blockchain’s job is to make that circulation legible. Orbit can wait. The ledger cannot.
Ask one question before buying any compute-backed token: can you prove the last 10,000 GPU-hours on-chain? If the answer is no, the 100 million users are not your problem. The 500,000 users are already one audit away from a write-down. Power lies in the code, not the community. And the ledger remembers what the market forgets.