Ethereum Eyes Bitcoin’s Utreexo as Scaling Strategy Evolves

Vitalik Buterin is exploring how ideas developed around Bitcoin’s UTXO architecture could help Ethereum process substantially more activity without forcing nodes to store ever-growing amounts of state.
Summary:
- Vitalik Buterin says Ethereum can borrow ideas pioneered by Bitcoin and Utreexo.
- Native UTXOs could sharply reduce permanent state created by simple payments.
- Recursive STARKs could aggregate transaction proofs before they reach block proposers.
- A cheaper payment layer on Ethereum could also reshape the role of major L2 networks.
His August 16 comments in X followed research linking native Ethereum UTXOs with recursive STARK aggregation, an approach that could make simple payments considerably cheaper to verify while keeping ETH’s account-based model for applications that actually need it.
Bitcoiners deserve a lot of credit for pioneering many of these ideas (see Utreexo).
But yes, this is what the current proposed Ethereum scaling strategy looks like in action.
We want Ethereum to have the best of UTXO-style state, dynamic state, and everything in between,…
— vitalik.eth (@VitalikButerin) August 16, 2026
Ethereum could stop treating every transaction the same way
The strongest argument for native UTXOs is not that Bitcoin’s accounting model is inherently better. It is that Ethereum currently asks relatively simple transfers to use infrastructure designed to support far more complicated applications.
Ethereum researcher Toni Wahrstätter has proposed native UTXOs for transactions that do not require persistent smart-contract state. An output would exist until it is spent, rather than creating an account or storage entry that nodes may need to maintain indefinitely.
Wahrstätter estimates that a new account or token-holder entry can require roughly 100 to 150 bytes of permanent state. At one billion entries, that translates into around 100 to 150 GB. Under the proposed UTXO structure, the remaining persistent footprint for comparable activity could fall to roughly 300 MB, a reduction of about 99.8%.
That would address a specific scaling problem that higher throughput alone cannot solve. Processing more transactions is less useful if every additional user permanently increases the storage burden placed on nodes.
Ethereum would still retain its account model for decentralized exchanges, lending protocols and other applications whose state changes continuously. Simple payments could use a lighter structure.
Buterin described the broader objective as combining the advantages of “UTXO-style state, dynamic state, and everything in between.”
Recursive STARKs attack the verification problem from another direction
Reducing permanent state solves only part of the problem. Ethereum also has to distribute and verify increasing volumes of transactions without allowing bandwidth and computation requirements to rise proportionally.
That is where recursive STARK aggregation enters the proposal.
Buterin has previously discussed a STARK-based mempool in which proofs are progressively combined while transactions move through Ethereum’s peer-to-peer network. Instead of requiring every participant to process a large collection of expensive proofs separately, nodes could work with increasingly compressed proofs covering larger groups of valid transactions.
The process could work roughly like this:
- Users create UTXO-style transactions.
- Transactions and their validity information propagate across Ethereum.
- Network participants aggregate proofs covering multiple transactions.
- Those proofs are recursively combined into larger validity proofs.
- A block proposer receives a compact proof representing the aggregated activity.
- The resulting commitment is included when the transactions settle on Ethereum.
One researcher suggested that a proposer could ultimately include a roughly 128 kB root representing a much larger collection of UTXO activity. Buterin responded positively to the concept and specifically credited Bitcoin developers, pointing to Utreexo as relevant prior work.
The UTXO and STARK proposals therefore address different constraints. UTXOs reduce the amount of state that must persist, while recursive proofs reduce how much verification work has to be repeated across the network.
Utreexo offers Ethereum a useful model, not a blueprint
Bitcoin’s Utreexo uses cryptographic accumulators to reduce how much UTXO information participants need to hold locally. Rather than storing the entire set, participants can use compact commitments and proofs to establish that particular outputs exist.
Ethereum cannot directly reproduce the model. Its state includes smart contracts, token balances and application-specific storage that Bitcoin does not have.
READ MORE: Cboe Tests SEC Limits With New 3x Bitcoin and Ethereum ETFs
The useful principle is narrower: full verification does not necessarily require every participant to permanently store every piece of active information.
That distinction matters for Ethereum’s decentralization strategy. Raising block capacity can increase throughput, but eventually pushes hardware and bandwidth requirements higher. Cryptographic compression instead attempts to increase capacity while limiting what individual nodes must retain and verify.
The trade-off is that the computational work does not disappear.
Proof generation may become the harder decentralization test
If ordinary nodes receive compact proofs, someone still has to generate them.
At sufficiently high transaction volumes, recursive STARK production could demand specialized hardware or substantial computing resources. Ethereum could therefore make verification easier while concentrating proof generation among a smaller group of infrastructure providers.
Buterin’s distributed aggregation concept is intended to limit that risk. Different nodes could prove subsets of valid activity before other participants recursively combine those proofs, rather than assigning the entire workload to the final block builder.
Data availability creates a separate constraint. A compact validity proof can establish that transactions are correct, but it does not automatically eliminate requirements to make underlying transaction data accessible.
The meaningful benchmark is therefore not simply transactions per second. Researchers need to compare state savings with proof-generation costs, bandwidth requirements, hardware demands and data availability.
Native payment scaling could change what Ethereum L2s compete on
A successful native UTXO layer would also raise a less obvious question for Ethereum’s rollup ecosystem.
Networks such as Arbitrum, Optimism and Base currently benefit partly from the fact that executing activity directly on Ethereum is comparatively expensive. Rollups move execution away from the base layer, batch transactions and ultimately settle compressed information back to Ethereum.
If Ethereum itself develops a lightweight path for simple payments, one portion of that value proposition could narrow.
That does not make rollups redundant. L2s support smart-contract applications, specialized execution environments, faster confirmation experiences and ecosystems that a basic UTXO payment layer would not reproduce. Rollups can also continue scaling complex activity that cannot fit comfortably into a stateless or semi-stateless payment model.
The distinction could instead become sharper: Ethereum handles simple transfers more efficiently at the protocol level, while L2s compete increasingly on application execution rather than merely offering cheaper transactions.
For Base, Arbitrum and Optimism, that would shift competitive pressure toward liquidity, applications, interoperability and execution design. Cheap transfers alone would become less differentiated if Ethereum can provide them without imposing substantial additional state on validators.
What Ethereum needs to prove before that shift matters
The immediate question is whether the proposed architecture works economically outside research discussions.
Wahrstätter’s estimated 99.8% reduction in persistent state provides a measurable target for suitable payment workloads.
Researchers still need to determine how many UTXO transactions can be aggregated efficiently, how quickly recursive proofs can be produced and whether ordinary hardware can participate meaningfully in that process.
The next meaningful milestone would be an implementation benchmarking native UTXOs and recursive aggregation under realistic network conditions. Those results would also give L2 developers something concrete to evaluate: whether Ethereum is merely reducing base-layer state growth or beginning to reclaim a category of low-complexity transactions that rollups currently process.
The information presented in this article is intended for informational purposes only and should not be interpreted as financial, investment, or trading advice. Coinspress.com does not promote or advocate for any particular investment strategy, asset, or cryptocurrency project. Cryptocurrency markets are highly volatile and unpredictable – always perform your own research and seek guidance from a qualified financial professional before making any investment decisions.











