It’s 2025, and we’re still fighting the same war.
I remember watching the 2017 CryptoKitties congestion bring Ethereum to its knees—not because the cats were in demand, but because every single transaction bloated the global state. Seven years later, we’re spinning out L2s, sharding, and data availability layers, but the root enemy hasn’t changed: state growth is a memory problem, not a bandwidth problem. And if you squint hard enough, the solution looks eerily similar to how large language models evolved from GPT-2 to Kimi K3.
Let me be clear: I’m not saying blockchains should become neural networks. I’m saying the architecture evolution that cut AI inference costs by orders of magnitude is the same intellectual battle we need to fight for on-chain state. And the project that cracks it won’t just onboard the next billion users—it will rewrite the protocol physics we’ve been taking as gospel.
Context: The Seven-Year State Bloat
In 2017, Ethereum’s state size was a few gigabytes. Today, it’s pushing two terabytes. Every full node stores the entire history of every account, every contract, every token—forever. We’ve masked the problem with stateless clients, Verkle trees, and ZK rollups but never solved the fundamental economic truth: unbounded state is unsustainable.
The parallel with AI is striking. From GPT-2 (2019) to GPT-4 (2023), transformer models grew parameters from 1.5B to 1.8T—a 1,200x increase—while their context windows (the amount of state they can hold at inference time) only grew from 1K to 128K tokens. The bottleneck was never the storage of model weights; it was the KV cache—the memory required to track every token’s relationship to every other token during generation. Sound familiar? That’s our Merkle Patricia trie.
Kimi K3, released by Moonshot AI in early 2025, didn’t try to beat this memory wall with more GPU brute force. Instead, it deployed a hybrid layered memory architecture that changed the game. And I believe its design principles are a crypto-native roadmap in disguise.
Core: The Three Lessons from K3’s Layered State
Layer 1—The KDA Analogue: Forgettable, Compressed State
K3’s core innovation is the Key-Value Delta Attention (KDA). Instead of storing every token’s full attention vector (as vanilla transformers do), KDA uses a compressed, linear-attention memory cell that updates only when new information changes existing beliefs. It’s like a state that can be overwritten locally without rewriting the entire history.
In blockchain terms, this is state expiry with channel-based trust. Imagine a rollup that doesn’t store every transaction’s effect, but instead maintains a compact “delta trie” that only records changes relative to a periodic checkpoint. The full history lives on L1 as data availability, but the execution layer only caches the active set. This is exactly what the “state network” in Ethereum’s portal network dreams of, but KDA shows us how to make it trainable—meaning the protocol can learn which state fragments to keep and which to forget, based on access patterns.
During my 2022 bear market, when I was fixing legacy bugs in Gnosis Safe, I saw multi-sig wallets maintain redundant state across every signer. A KDA-inspired approach would let signers keep only the “delta” of their own confirmations, reducing node storage by 70%+ for long-lived multi-sigs. We didn’t build a future; we built a mirror of our own inefficiencies.
Layer 2—The MLA Analogue: Precision Retrieval, Not Broadcast
K3 stacks KDA layers for everyday memory, but inserts a single Multi-Head Latent Attention (MLA) layer every three KDA blocks. The MLA acts as a high-bandwidth recall mechanism—when the compressed memory can’t resolve a question, the model goes back to the full context to fetch precise answers.
Blockchain’s equivalent: selective re-execution. Today, verifying a rollup batch requires replaying the entire block to check state roots. But imagine a protocol that only re-executes the transactions that touch state fragments flagged as “uncertain” by a compressed state oracle. That’s exactly what a MLA layer does—it avoids quadratic read costs by limiting full-recall to when it’s actually needed.
This principle is already appearing in optimistic rollup fraud proofs, but we apply it coarsely. K3 suggests we need granular, attention-weighted re-execution—where the protocol’s validators spend more computational resources on state transitions that are “high entropy” (e.g., a stablecoin transfer) vs. repetitive ones (e.g., a daily checkpoint).
Layer 3—Attention Residuals: The Protocol’s Long-Term Memory
K3’s 93-layer transformer is split into blocks, and every block can directly access the intermediate representations of earlier blocks via attention residuals. This prevents information dilution in deep networks. In blockchain, this maps to cross-shard read access without latency penalty. Current sharding designs force each shard to be semantically isolated, with expensive relayer messages for cross-shard communication. K3 shows that providing every shard with a compressed read cache of every other shard’s recent state (like block-level outputs) cuts complexity from O(n²) to O(n).
Mining for truth in the noise of NFT mania, I saw community tokens that held “land” metadata in IPFS, but the protocol had to fetch the entire JSON on every query. A K3-inspired residual cache would let the chain store only the Merkle root of the metadata’s deep features (e.g., rarity score, creator signature) while preserving full authenticity.
Contrarian: The Church of Full History Is Wrong
Every blockchain purist will object that “compression loses data” and “forgetting state violates immutability.” That’s a strawman. Immutability is about consensus on truth, not storing every truth forever.
Layer-2 hype has taught us that we can order transactions outside the main chain and only post roots. But we’ve been cowards—we still force every L2 to keep its own complete state tree for fraud proofs. A KDA-like approach would let L2s keep compressed, learnable state that can be reconstructed on demand from L1 data availability. The community would agree on the compression algorithm (like how we agree on the EVM) and trust that any malicious compression leads to an invalid state root.
The contrarian truth: Blockchains don’t need to be stateless; they need to be amnesiac. Selective forgetting, guided by economic signals (which state is accessed? staked? traded?), is the only way to scale to global adoption. Liquidity isn’t just capital; it’s bandwidth for state reads. If we can’t reduce the cost of reading state, the world won’t come on-chain.
Open source is not a license; it’s a state of mind. We need to open-source not just code, but our assumptions about which state is sacred. The K3 paper taught me that the most sacred part of a model is its ability to recall—not its ability to store. The same is true for chains.
Takeaway: The Next Chain Will Be a Memory Network
The winner of the next bull run won’t be the chain with the highest TPS or the lowest fees. It will be the chain that can hold a trillion on-chain identities—each with a programmable lifetime—while letting a million nodes verify the whole thing on a Raspberry Pi. That chain’s architecture will look like Kimi K3’s: layered, hybrid, and ruthlessly economic about memory.
I left the NFT podcast life in 2021 because the mania was a distraction. But the underlying problem—how to preserve cultural context without bloating the universe—is the same problem every protocol faces. We don’t need more data. We need better memory managers.
So, to the builders reading this: stop optimizing for throughput. Start optimizing for forgetfulness. Your protocol’s soul isn’t its state—it’s the rules by which state is allowed to die.