Hook
It’s not chip scarcity that’s throttling the next wave of crypto-native AI agents. It’s the system that turns raw compute into usable tokens. Zheng Weimin, a Chinese Academy of Engineering academician, dropped this bomb during a recent industry talk: the real competition has shifted from FLOPS to the ability to produce tokens – stable, low-cost, high-quality tokens. For crypto, this is a direct challenge to our obsession with TPS and block space. We’ve been measuring the wrong thing.
Context
For years, the crypto narrative has been dominated by hardware – GPU shortages, ASIC wars, and the endless quest for faster chips. Ethereum's transition to proof-of-stake and the rise of L2s were supposed to solve scalability, but the underlying assumption remained: more compute equals more capacity. Zheng flips this on its head. He argues that the bottleneck is not about adding more chips, but about engineering the system that converts chip cycles into tokens efficiently. This token production system – whether for transaction validation, smart contract execution, or AI inference on-chain – requires distributed architectures, aggressive caching, heterogeneous compute, and service-oriented design.
In crypto, we have our own version of this: the execution layer. Whether it's the EVM, SVM, or MoveVM, the system that processes user requests into state transitions is essentially a token factory. But unlike AI, where the token is a unit of information (text), in crypto the token is a unit of value or action. The analogy is powerful: the efficiency of that factory determines not just cost per transaction, but the viability of entire applications – especially those involving AI agents that will conduct thousands of microtransactions per hour.
Chasing alpha through the 2017 hallucination taught me that hype doesn't scale. What scales is the underlying pipeline that turns raw blocks into settled finality. Zheng's speech, though rooted in AI infrastructure, maps perfectly onto the challenges we face with rollups, data availability layers, and the emerging concept of AI wallets making autonomous decisions.
Core
Let's dive into the technical parallels. Zheng describes the optimal token production system as having four pillars: distributed, cached, heterogeneous, and service-oriented. In crypto, these translate directly:
- Distributed: Modern L2s and sharded chains distribute transaction processing across multiple validators or proving systems. But distribution alone isn't enough. The communication overhead (p2p gossip, sequencer coordination) can kill efficiency. The system must minimize cross-shard latency. This mirrors AI's need for low-latency inter-node communication. Based on my audit experience with StarkNet and zkSync, the bottleneck is often the proof aggregation layer, not the execution itself. That's a system problem, not a chip problem.
- Cached: In AI, caching means storing intermediate computations (KV cache, prefix cache) to avoid recomputation. In crypto, we can cache state reads, precompiled contracts, and even partial proofs. Look at how Aerodrome's automated market maker caches spot prices – it's a primitive form. But we need system-level caching for EVM state accesses. Surging front-running and MEV are partially caused by repetitive state lookups. A proper state caching layer could reduce gas costs for common operations by 40-60%. Uniswap taught me liquidity is truth – and truth is expensive in its current form.
- Heterogeneous: Not all transactions are equal. Simple transfers don't need the same execution resources as complex DeFi swaps or zk-proof verifications. A token production system should route tasks to specialized hardware – maybe a lightweight VM for standard txs, and a GPU-backed prover for complex ones. This is analogous to AI's use of CPU+GPU+NPU. In crypto, we see hints of this with Solana's Sealevel parallel execution and Monad's async scheduling. But the industry still defaults to homogeneous execution. The contrarian angle? Most projects over-optimize for the worst-case transaction, wasting resources on simple ones.
- Service-oriented: Token production becomes a service – like AWS for state changes. This implies standardized APIs, billing per token (gas), and fault isolation. The separation of sequencing, execution, and settlement on L2s is a step toward this. But the system must handle fault tolerance transparently. Surviving the Terra algorithmic trap taught me that a black box service with hidden dependencies is a bomb. A service-oriented token production system must expose granular metrics and allow users to choose reliability vs. cost tiers.
Now, let's tie this to specific crypto protocols. Ethereum's post-Dencun blob data is already under pressure. The current blob capacity is roughly 6 blobs per slot, each 128 KB. At 1 tx per blob, that's about 6 tps per slot. With rollups aggregating hundreds of txs per blob, the effective throughput is higher. But as AI agents start generating thousands of transactions per second (each query to an agent requires an on-chain settlement), the blobs will saturate within 18 months, just as Zheng predicted for AI blobs. The cost per blob will double, directly impacting L2 fees. This is the same dynamic: not a scarcity of chips (validators), but a scarcity of system capacity (blob space vs. demand).
Filtering signal from the ICO noise requires recognizing that the next wave of innovation won't come from consensus mechanisms but from execution system design. Consider the test of a simple swap on Uniswap v3 via an L2. The transaction goes through an RPC node -> sequencer -> execution node (witnessed state) -> proof generator -> L1 settlement. Each step is a bottleneck. The current approach is to parallelize by adding more sequencers or using optimistic rollups that don't generate proofs per tx. But this is analogous to adding more AI chips without optimizing the inference pipeline. True system efficiency comes from caching frequently accessed state (e.g., token balances for top 100 tokens), precomputing proofs for common operations (e.g., ERC-20 transfers), and using heterogeneous execution – for instance, running simple txs on a fast, single-threaded VM and reserving parallel engines only for complex interactions.
Contrarian
The contrarian angle: the crypto community is obsessed with TPS as a vanity metric, but the real metric should be "cost per unit of meaningful state change." Most on-chain activity today is spam or MEV extraction. The token production system should disincentivize wasteful operations by making them costly, not by bandwidth limits. Zheng's point about "high-level token production" implies quality over quantity. In practice, this means prioritizing transactions that actually move value or enable new functionality (e.g., agent coordination), while pricing out simple balance checks that could be cached off-chain.
Another unreported angle: the current drive toward vertical integration (e.g., a single team controlling sequencer, execution, settlement) contradicts the service-oriented principle. True system efficiency requires specialization and open interfaces. The smart contract never lies, but the system around it can obscure inefficiency. We need modular token production systems where each component can be optimized independently – just like AI's separation of frontend caching, inference engine, and post-processing.
Finally, the role of AI agents as consumers of token production systems is underappreciated. Agents will require low-latency, deterministic execution with predictable costs. The deterministic property clashes with the probabilistic nature of rollups and sharding. This is a system-level tension that most L2 designs ignore. Fiat illusions break under pressure – and under the pressure of agent-driven demand, L1/L2 architectures will be stress-tested. Only those with robust, efficient token production systems will survive.
Takeaway
The next crypto bull run won't be triggered by a new L1 or a flashy metaverse; it will be triggered by the first team that achieves a true, system-wide 10x reduction in cost per token while maintaining trust minimization. The tools are already here – caching, heterogeneous execution, service-oriented design – but the industry's attention is still on brute force. The question is not when will we have enough chips, but when will we build the software that treats transaction processing as a science, not a lottery. I'm watching the teams moving from "parallel execution" to "heterogeneous execution" – that's where the alpha lies.