Ethereum once had a plan to scale through shard chains — dozens of parallel chains coordinated by a beacon chain — before that design was shelved in favor of rollup-centric scaling. Cloudflare’s Will Papper is now arguing the discarded architecture deserves a second look, not for DeFi, but for stablecoin payments between AI agents. His reasoning, laid out on Unchained Premium and reported by Crypto Briefing, is that the property which killed sharding for DeFi — the difficulty of cross-shard composability — simply does not matter for payments.
Why Sharding Failed for DeFi
Ethereum’s original sharding roadmap promised massive throughput by splitting the network into shard chains, each processed in parallel. The problem was that DeFi is composability-heavy: a single transaction might touch a lending market, a DEX pool, and an oracle, all of which need atomic, synchronous access to shared state. If those contracts live on different shards, every composite operation requires asynchronous cross-shard messaging, which is slow, fragile, and breaks the atomicity guarantees DeFi depends on. As Papper put it, shard chains were “way too difficult for DeFi.” The ecosystem concluded that execution should consolidate rather than fragment, and the rollup-centric roadmap followed. That judgment was correct for the applications that dominated at the time.
Why Payments Are a Different Problem
A stablecoin transfer has a fundamentally different state profile. As Papper notes, “a dollar is a dollar” — moving USDC from an AI agent’s wallet to a data provider’s wallet touches exactly two balances and nothing else. There is no dependency graph, no composability requirement, no need for synchronous access to shared smart-contract state. This is precisely the workload sharding was designed for: high volumes of small, independent state transitions that can be processed in parallel without coordination. Machine-to-machine commerce multiplies the transaction count far beyond human payment patterns, since agents pay per API call, per unit of data, per second of compute. Fragmented state is a cost for Uniswap; it is irrelevant for a metered payment.
The AI Agent Angle and Cloudflare’s Position
The context for reviving this argument is the projected growth of agentic commerce — autonomous systems paying each other continuously for data, software, and compute. Crypto Briefing frames Papper’s thesis as scaling stablecoin micropayments for AI agents across roughly 20% of the global web, reflecting Cloudflare’s position as core internet infrastructure. Cloudflare has already moved into this territory through x402, the HTTP-native payment protocol that lets agents pay per request. If agent payments ride HTTP semantics, the underlying settlement layer needs to handle millions of tiny transfers without fee spikes pricing out a $0.01 payment. Current L1 throughput and rollup fee floors are not obviously compatible with that, which is why infrastructure operators are revisiting architectural options Ethereum already explored and rejected.
The Tradeoffs Remain Real
Reviving sharding for payments is not free. First, liquidity fragments: stablecoin balances spread across shards cannot be seamlessly netted against DeFi or exchange venues without bridges, reintroducing the cross-shard problem by another name. Second, a payments-focused shard chain is competing not with other chains but with the agent-driven upgrade of traditional payment rails — card networks and banks are actively building their own agentic commerce layers. Third, Ethereum’s roadmap is committed to rollups; building sharded stablecoin rails would be either a separate payments chain or a protocol-level fork in strategy. The open question is whether throughput gains justify fragmenting the settlement landscape that gives stablecoins their network effect in the first place.