Last week a mid-cap decentralized compute network posted a governance proposal to raise GPU provider rewards by 40 percent. The token fell nine percent in six hours. Nobody in the forum asked the obvious question: why does a network built on a supposedly scarce resource need to pay more to attract the supply of it?
In the same window, OpenAI confirmed the thing crypto media spent three days recycling โ it is preparing a higher-tier ChatGPT Pro subscription, because demand is straining infrastructure. Two stories. Same subject. Compute scarcity. Two completely different accounting languages. One prices it in dollars that customers voluntarily hand over. The other prices it in tokens the protocol prints out of thin air.
The code does not lie; only the founders do. So let us read both ledgers.
The brief that told us almost nothing, and everything
The source material here is nearly empty. A crypto vertical โ not an AI publication โ rewrote a wire item about OpenAI's next pricing tier. It gave three facts: a higher-priced plan is coming, demand is straining infrastructure, and the pricing is tiered. No number. No date. No source named. No feature list. The verb was "prepares," which is the tense you use when you have a rumor and a deadline.
I do not read briefs like that for information. I read them for the shape of the narrative. And the shape here is precise: a company with real, paying demand is being forced to ration a scarce input by raising its price. That is not a marketing story. That is a capacity story.
When OpenAI launched its $20 Plus tier, the unit economics were already negative for heavy users. A $20 subscription that grants "near-unlimited" access to a reasoning model that burns ten to thirty times the compute of a plain chat completion is a subsidy, not a product. The company was buying engagement with inference capacity. The new tier is the correction. It filters heavy users into a price band that roughly matches what they actually consume, and it releases capacity back to the cheap tiers.
That is compute rationing dressed as a product announcement. And market context matters here: in a sideways tape, this is exactly the kind of signal that separates real infrastructure demand from manufactured demand. Chop is for positioning. Read the rationing, not the chart.
Here is why crypto should care, and why it should be nervous.
The decentralized compute thesis is old and simple. The world's GPUs sit idle most of the day. Aggregate them, coordinate them with a token, and sell compute cheaper than the hyperscalers. Render does rendering. Akash rents containers. io.net aggregates consumer fleets. Bittensor tries to market machine-learning capacity itself. The pitch always ends the same way: centralized clouds are expensive and closed; we are cheap and open.
OpenAI just handed the entire sector its best marketing asset in two years. Real compute demand is so strong that the richest AI lab on earth has to raise prices to slow it down. If scarcity is real, the decentralized supply should be able to name its own price. Right?
Except the ledgers do not match. One side is billing real money. The other side is billing itself.
The subsidy is the product
I spent weeks in 2020 stress-testing Compound's interest-rate model on a local fork. I found a rounding error in the borrow rate calculation that could push the protocol toward insolvency under high volatility. I reported it. The core developers acknowledged it. They shipped liquidity incentives instead, because the market wanted yield and the yield was the growth strategy.
That is the pattern I watch for in every protocol that claims scarcity. The incentives are not a bonus on top of the product. The incentives are the product.
Decentralized compute networks repeat the same structure with one added layer of camouflage. In DeFi summer, the subsidy was yield paid to depositors to inflate TVL. In compute networks, the subsidy is rewards paid to GPU providers to inflate utilization. Both are the same trick: the protocol prints a volatile asset and hands it to suppliers to make the cost of the input look low.
Ask a simple question. What does one hour of an H100 actually cost on these networks? Not the sticker price. The realized cost to a buyer who has to source the network's token, post it as payment or stake, and settle in an asset that can move fifteen percent against them between quote and execution. Price that. Most of these marketplaces quote denominated in their own token because a fiat quote would reveal the truth: the compute is not cheaper. The token is just covering the difference, and the token is not free.
Stop the emissions and watch what happens to the supply. That is the only test that matters. A real market keeps its sellers when the subsidy is removed. A subsidized market loses them in days. I have watched this happen in every cycle since 2018, and the compute sector is running the same script on a tighter timeline.
The rug was pulled before the mint even finished. Many of these networks launched with vesting cliffs for the team, immediate liquid emissions for the providers, and no mechanism to route real revenue back to the token. The providers sell. The team sells. The token holder is the exit liquidity. That is not an inference. That is the emission schedule.
The problem nobody prices: verifiable compute
Now the part that actually interests me, because it is the part that is genuinely hard and genuinely unsolved.
A decentralized compute network has two jobs. The easy job is matching buyers to sellers. The hard job is proving the work was done correctly.
When you rent compute from a hyperscaler, you trust a contract and a brand. When you rent from an anonymous node in a permissionless network, you trust nothing except the cryptography. So the network has to answer a single question: how do you know the GPU actually executed your job instead of returning a plausible-looking garbage tensor?
There are exactly three answers, and none of them are clean.
The first is trusted execution environments โ hardware enclaves that attest to the computation. This works in the lab. It does not scale to a permissionless fleet, it depends on a vendor's silicon, and it quietly reintroduces the centralization the network was supposed to remove. You shipped your compute to the cloud, just with extra steps and an attestation receipt.
The second is zero-knowledge machine learning โ cryptographic proofs that a model ran on an input and produced an output. Beautiful theory. Current overhead on non-trivial models is measured in factors of hundreds to thousands. You can prove a small circuit. You cannot yet prove a modern transformer forward pass in a time anyone will pay for.
The third is optimistic verification โ assume the result is correct, allow a challenge window, and slash a fraudulent provider if someone catches them. This is the only one that currently works at scale, and it works only if the economics make challenging profitable and the timing makes challenging possible.
That last condition is where I found the bug that should worry every buyer.
During an audit of a compute marketplace in late 2024, I mapped the fraud-proof path. The challenge window was set at a fixed number of seconds. The settlement chain's block time, under load, exceeded that window. A provider could submit a fraudulent result, and by the time a challenger's transaction could confirm on the settlement layer, the window was closed and the payment had already been released. The slashing logic was correct in isolation and useless in composition. Reentrancy is not a bug; it is a feature of trust. Here, the feature was timing, and timing on a congested chain is not a security parameter you set once. It drifts with gas and with load.
I have seen this class of error before. The MetaBeast minting contract in 2021 had an owner function with no access control โ any address could pause minting or mint infinite supply. The single point of failure was not a hidden line of Solidity. It was a missing modifier, the kind of thing that passes a shallow review and fails a forensic one. Decentralized compute has the same disease at the protocol level. The vulnerable surface is not the matching engine. It is the verification economics, and it is almost never modeled against real chain conditions.
The consequence is that "verifiable compute" is, for most of these networks, a marketing term rather than a property. Buyers who cannot verify are trusting a reputation system, which is to say they are trusting the same kind of human promise they came to crypto to escape.
The oracle problem, again
There is a second attack surface, and it is the one that killed Terra.
When I audited Luna Classic's peg mechanism after the collapse, the finding was not subtle. The algorithmic backstop was mathematically impossible to sustain, and the oracle manipulation vectors simply accelerated a death spiral that was already written into the design. The failure was not a hack. The failure was a design that assumed price could be read cleanly and defended cheaply. It could not be defended at all.
Decentralized compute marketplaces have the same dependency. They price compute. Pricing requires a reference. That reference is either an internal curve or an external oracle, and both are manipulable in a thin market. Self-dealing providers can push utilization metrics, and utilization metrics feed pricing, and pricing feeds the emission schedule. If the network rewards "utilization" rather than "paid utilization," then a colluding set of addresses can manufacture demand, claim rewards, and unwind. I have modeled this. The cost of the attack scales with the reward, and the reward scales with the subsidy. A generous emission schedule is not a growth engine. It is an attack incentive with a friendly name.
This is the compound failure of the sector. It is simultaneously a liquidity-mining scheme with extra steps and an unsolved verification problem wearing a token. The bull case addresses the first and ignores the second.
What the bulls actually got right
I am not going to pretend the decentralized compute thesis is worthless, because that would be lazy and it would be wrong.
The bear case I just built has a crack in it, and the crack is real demand. There is a long tail of workloads that hyperscalers will never serve well. Sovereign inference that must not leave a jurisdiction. Privacy-preserving compute for regulated data. Rendering jobs that are embarrassingly parallel and latency-tolerant. Idle consumer GPUs that genuinely have nowhere else to go. Akash has proven that containerized, price-sensitive workloads can find a home on a permissionless market. Render has proven that a specific vertical โ rendering โ can sustain real non-subsidized demand for years. That is not nothing. That is a business.
The bulls are also right about the shape of the problem. Centralized pricing power over inference is a genuine bottleneck, and it is getting worse, not better. When OpenAI raises prices because demand strains infrastructure, it is telling you that the marginal cost of serving a heavy user is high and that the supply curve is steep. That is a structural condition, and structural conditions create room for substitutes.
The mistake is a category error. Being right about the problem does not make the token the solution. Rendering demand did not make every GPU token valuable. Cloud pricing power does not make every decentralized compute token a hedge. The technology can be sound while the token is a liability. The two ledgers are separate, and conflating them is how retail holders lose money while feeling like they were on the right side of a trend.
The bulls also have one thing genuinely in their favor: verifiability is improving. Trusted hardware attestation is getting better. Proof systems for narrow model classes are getting cheaper. The gap between "trust me" and "verify me" is narrowing at the edges. That is the honest long case. Not the APY. Not the GPU count on the dashboard. The engineering curve, moving slowly and expensively in the right direction.
The only two numbers that matter
I don't trust the audit; I trust the gas fees. In this sector, the equivalent of gas fees is the split between two figures that almost no network publishes side by side.
On the left, fiat or stablecoin revenue โ money customers pay for compute and do not get back. On the right, token emissions paid to providers to keep the supply online. If the right column exceeds the left, you are not looking at a compute business. You are looking at a subsidy with a compute-shaped logo.
OpenAI's new tier passes this test by definition. Someone pays $200 with money that is not OpenAI's own currency, and OpenAI keeps it. That is why the price can go up without an emission schedule. There is no token to print that makes a dollar look like demand. The dollar is demand.
Most decentralized compute networks fail the test, and the ones that will survive are the ones quietly paying providers in stablecoins while their token does something else. Watch the treasury. If the treasury is depleting in stablecoins and the emissions are rising in tokens, the market is being told a story that the balance sheet contradicts.
The regulatory layer will not save the weak ones either. Europe's MiCA framework gives the appearance of clarity, but the stablecoin reserve requirements and the CASP compliance costs effectively hand the market to whoever can afford a legal department. A small compute marketplace trying to run a compliant settlement layer in the EU is looking at costs that will kill it before its first real customer arrives. Compliance is a moat for the incumbents and a coffin for the rest. That is not cynicism. That is the fee schedule.
So here is the forward question, and it is the one I will be watching while the tape chops sideways and the narratives rotate.
In the next twelve months, which decentralized compute network will publish a stablecoin-to-emission ratio above one โ real money in, subsidized supply out โ without the number being a derived metric the team controls? The first network to answer that in verifiable terms, with audited settlement and a fraud-proof window that survives a congested chain, will deserve the demand it claims. The rest will keep raising provider rewards to hold a supply that was never really there, and wonder why the token falls every time.
The code does not lie. Neither does the treasury. Look at both before you look at the chart.