"Are L2s eroding L1's value?" "Is Ethereum losing its global composability?" During the peak hype years of L2s, such anxieties nearly saturated the entire Ethereum community.
Back then, in Ethereum's scaling framework, L1 was the stable but expensive settlement layer, while L2s acted as cheap and efficient execution layers. While this indeed granted Ethereum more block space, it also gradually eroded the cohesive experience of "one chain."
Consequently, these questions have driven Ethereum to re-examine the relationship between L1 and L2s over the past two years.
On one hand, Ethereum L1 has been persistently increasing the Gas Limit, advancing statelessness and zkEVM verification, no longer content with being merely a low-throughput settlement base. On the other hand, community discussions have intensified. Early this year, Vitalik frankly stated that with Ethereum mainnet's own scaling capacity improving, some premises of the roadmap formulated five years ago, which viewed L2s as the primary scaling solution, have already changed (Extended reading: "Understanding Vitalik's L2 Reflection: Farewell to Fragmentation, Course Correction Towards Native Rollups in the New Phase").
More recently, Ethereum researcher Barnabé Monnot further emphasized the need to re-evaluate the long-term relationship between L1 and L2s, including how L2s should create value in the future, why finality needs to be drastically shortened, and whether L1 might also become, in a sense, a "rollup of itself" as proof systems gradually enter the mainnet verification process.
While these viewpoints do not yet constitute a finalized protocol roadmap, they offer a valuable observational lens.
Ultimately, the challenge Ethereum faces today is no longer just how to continue increasing block space, but rather, after transactions, assets, and user states are dispersed across more and more execution environments, how exactly should L1, L2s, execution layers, and settlement layers be re-divided.
I. Ethereum Has Not 'Abandoned' L2s, But Must Find a New Positioning
To be realistic, when the Ethereum scaling roadmap centered on Rollups first took shape, the most important task for L2s was relatively singular: to provide more, cheaper transaction space for Ethereum.
Under the technical conditions of that time, this division of labor was quite reasonable.
Because all Ethereum validators needed to re-execute L1 transactions, mainnet throughput could not be aggressively increased in the short term. Rollups, however, could batch execute transactions off-chain, submitting only compressed data or state commitments back to the mainnet, retaining certain Ethereum security attributes while significantly reducing unit transaction costs.
Thus, scaling gradually formed two parallel tracks: L1 maintaining restraint, prioritizing decentralization and security; L2s accommodating new transactions, continuously reducing costs through Blobs, data compression, and proof technology.
Now, the premises of this division have changed.
In 2026, the Ethereum Foundation reorganized protocol work, merging the previously relatively independent "Scaling L1" and "Scaling Blobs" into a unified Scale roadmap. Increasing the Gas Limit, expanding data availability, optimizing execution clients, advancing statelessness, and developing zkEVM attester clients were all placed within the same scaling framework.
In other words, Ethereum no longer sees L1 and L2 scaling as two separate tasks. Instead, it has begun to reallocate execution, consensus, and data capacity from the perspective of the entire system.
This change does not mean Ethereum is preparing to abandon L2s or suck all activity back to the mainnet. On the contrary, it signifies that L2s can no longer easily justify their long-term value solely based on "faster transactions, lower Gas."
After all, if L1 itself can increase execution capacity by several orders of magnitude while maintaining security and decentralization, then ordinary EVM execution and low-cost block space will no longer be unique capabilities of L2s. What L2s will need to provide will shift more towards differentiated needs that L1 cannot uniformly satisfy, such as application-specific optimizations, privacy features, and more flexible governance and economic models.
The Ethereum Foundation's latest characterization this year of the L1-L2 relationship also explicitly emphasizes this. In the past, the primary goal of L2s was scaling Ethereum; differentiation and customization were secondary values. Now, it is providing differentiated functions while continuing to contribute additional scaling capacity.
Correspondingly, L1 needs to become a sufficiently powerful, permissionless, and highly resilient global hub, carrying settlement, shared state, liquidity, and DeFi.
This effectively pushes L2s from a unified technical category towards a more complex continuous spectrum:
- At one end of the spectrum are Rollups that inherit Ethereum's security attributes as much as possible. They aim to reduce multi-sig security councils, open permissionless proof mechanisms, and ensure users can still exit via L1 even if the operator ceases operations.
- The middle ground consists of execution environments that inherit part of Ethereum's attributes based on business needs. They may have stronger administrative authority, independent sequencers, or specific compliance designs, in exchange for performance, privacy, and operational flexibility.
- The other end may be chains that merely adopt EVM, use Ethereum assets, or access some cross-chain facilities, but remain relatively independent in terms of security and settlement.
This is also why Ethereum is not abandoning L2s but redefining the division of labor. Ultimately, in the past 3-5 years, L2s primarily represented a scaling technology. In the future, they are more likely to represent a set of execution environments that establish different security, settlement, and liquidity relationships with Ethereum.
II. Interoperability Is More Than Cross-Chain; It's About How States Trust Each Other
However, as Ethereum expands into a system composed of numerous L2s, another perennial issue gradually surfaces: the increasing number of L2s inevitably fragments liquidity, account states, and application experience.
This has been vividly reflected in actual usage over the past few years. For example, users may hold assets on one chain, use applications on another, and need to go to a third chain to complete transactions. As a result, the same stable coin has different versions in different networks, and the same account must deal with different Gas Tokens, cross-chain bridges, and asset gateways.
Therefore, interoperability is becoming an increasingly important part of Ethereum's roadmap.
The Ethereum protocol team has focused the 2026 Improve UX roadmap on two directions: native account abstraction and interoperability. They believe the key to solving L2 fragmentation lies in making Ethereum "feel like one chain again," a vision dependent on the maturation of the intent architecture.
- Among them, the Open Intents Framework allows users to merely declare the outcome they desire, such as "convert a certain asset on Chain A into USDC on Chain B." Solvers in the background then handle path calculation, advanced payments, execution, and fund rebalancing (Extended reading: "When 'Intents' Become Standard: How OIF Ends Cross-Chain Fragmentation, Returning Web3 to User Intuition?").
- Further ahead, the Ethereum Interoperability Layer (EIL) attempts to build a trustless transport layer, aiming to make cross-L2 transactions feel indistinguishable from single-chain transactions (Extended reading: "Ethereum Interop Roadmap: How to Unlock the 'Last Mile' of Mass Adoption").
On the account side, EIP-7702 in the Pectra upgrade already allows traditional EOAs to temporarily execute smart contract code, supporting transaction batching, gas sponsorship, and recovery mechanisms. Subsequent native account abstraction schemes, represented by EIP-8141, aim to further embed smart account logic into the protocol, gradually making smart contract wallets the default account form and reducing reliance on additional bundlers, relayers, and intermediary services.
The L1 fast confirmation rule aims to provide a stronger security confirmation signal within ten to tens of seconds before full finality, which would shorten application wait times in most normal scenarios. This will directly benefit all cross-chain applications that rely on L1 finality, which is significant for cross-chain bridges, stablecoin settlement, and RWA asset trading.
Because the real bottleneck for many cross-chain interactions is not whether a message can be sent, but when the target chain can be sufficiently confident that the state on the source chain will not be reversed.
A point often overlooked is that a transaction being included in a block does not mean it has achieved finality. From a user's perspective, a transaction may show as successful within seconds, but for bridges, exchanges, lending protocols, and cross-chain solvers, they still need to judge the likelihood of that transaction encountering a block reorganization and whether they can release assets or execute the next operation on another chain based on it.
This is also why many seemingly "instant" cross-chain services today do not actually wait for the source chain to complete final settlement. Instead, solvers or liquidity providers advance funds. This mechanism optimizes user experience but does not make the underlying waiting time disappear.
Therefore, Ethereum's long-term goal is to gradually shorten finality itself from minutes to seconds. However, this is not a single upgrade already scheduled for launch, but rather a set of research tasks that need to be promoted in phases. These include decoupling finality votes from fork choice, optimizing validator sets, vote aggregation and network propagation, and gradually changing the consensus protocol.
In summary, good interoperability is not about giving dozens of chains the same cross-chain button, but rather enabling different execution environments to trust each other's states faster and at lower cost.
III. When L1 Also Becomes a Rollup, Does the Layering Boundary Still Exist?
If the change in L2 positioning and the shortening of finality are still adjustments within the existing layered architecture, then another judgment mentioned by Barnabé touches the very definition of L1 and L2: as proof systems enter the Ethereum mainnet, L1 may ultimately also become, in a sense, a "rollup of itself."
This statement sounds somewhat counterintuitive.
After all, a rollup is typically understood as a scaling network built on top of L1. It executes transactions externally, with L1 verifying the state results. Ethereum itself is the underlying consensus and settlement network; how could it become its own L2?
Understanding this viewpoint requires first separating "Rollup" from the hierarchical relationship. In today's Ethereum, after a node receives a block, it needs to re-execute all transactions within it, independently calculate state changes, and judge whether the block adheres to protocol rules.
This mode ensures nodes can verify independently, but it also means the network's overall execution capacity must be constrained by the hardware conditions of ordinary nodes. The greater the computational load in a block, the more hardware and time validators need to complete execution.
In the future, with the maturation of real-time proofs and L1 zkEVM, transactions can still be computed by high-performance execution nodes, but ordinary validators may not need to personally re-execute every transaction. For example, execution nodes could generate validity proofs after completing computations; other validators would only need to verify these much smaller, lower-cost proofs to confirm whether the state transition is correct.
From the perspective of the relationship between execution and verification, this indeed shares similarities with Rollups: a subset of participants are responsible for high-performance execution; execution results are compressed into cryptographic proofs; a broader set of consensus participants no longer repeat all computations but verify the proofs and confirm the final state.
Therefore, Barnabé's description of "L1 becoming its own Rollup" is better understood as a summary of this verification model, not that the Ethereum mainnet would be placed on another underlying chain or "downgraded" to its own L2.
His point is that when proofs gradually replace the repeated execution by all nodes, Rollup may no longer be just a hierarchical name located above L1, but become a more universal execution and verification architecture.
This further blurs the traditional boundary between L1 and L2.
On one hand, L1 can leverage zkEVM proofs to expand its own execution capacity. On the other hand, Native Rollups aim to enable L2s to more directly invoke the verification capabilities within the Ethereum protocol, with L1 verifying L2 state transitions in a more native, unified manner.
Today, different Rollups typically need to build their own proof systems, verification contracts, upgrade mechanisms, and security councils. Once a proof system has an error, the protocol needs an emergency upgrade, or the operator fails, users often still rely on additional governance and trust structures. The long-term direction of Native Rollups is to turn part of the Rollup verification logic into a native capability of Ethereum, allowing L2s to reduce self-built security structures, more fully inherit L1's state transition rules, and potentially shed security councils.
Taking one step further, when multiple L2s can rely on faster L1 confirmations, unified proof mechanisms, and synchronously composable access to each other's states, their relationship with the mainnet may no longer be connected by bridges as they are today.
They would be more like multiple execution domains under the same Ethereum consensus. Some are responsible for general financial activities, some cater to gaming, social, or payments, some provide privacy or special compliance capabilities. They possess different execution logics and product forms but share a common verifiable state, security foundation, and asset settlement system.
Of course, this remains a long-term direction.
But regardless of the eventual form these technologies take, they have already transformed the L1-L2 boundary from a clear architectural line into a spectrum of varying degrees of security inheritance.
In Conclusion
Worldly affairs are ever-changing; what is united must divide, and what is divided must reunite.
Ethereum once relied on shared state to gain global composability; later, it split execution out through Rollups to gain more capacity. Now, its task is to reconnect the fragmented assets, accounts, and applications without undoing the scaling achievements.
For ordinary users, the ideal Ethereum should never be a network map composed of dozens of chains, different Gas tokens, and cross-chain bridges. In reality, where transactions are executed, where liquidity comes from, and who ultimately settles can all gradually be handled by wallets, applications, and the underlying protocol. However, the trust assumptions, security boundaries, and exit paths involved must not be hidden along with the operational experience.
Therefore, the endgame for L2s might be neither replacing L1 nor being eliminated by a continuously scaling L1. Instead, they are likely to become a set of execution environments with different functions and performance, yet able to share security, liquidity, and state relationships.
In the past, Ethereum gained more capacity by splitting execution apart.
Next phase, let's see if, after being split apart, it can still be reassembled into one Ethereum.
