Ethereum researcher ladislaus.eth revealed a walkthrough final week explaining how Ethereum plans to maneuver from re-executing each transaction to verifying zero-knowledge proofs.
The publish frames it as a “quiet however elementary transformation,” and the framing is correct. Not as a result of the work is secret, however as a result of its implications ripple throughout Ethereum’s whole structure in ways in which will not be apparent till the items join.
This is not Ethereum “adding ZK” as a function. Ethereum is prototyping another validation path through which some validators can attest to blocks by verifying compact execution proofs somewhat than re-running each transaction.
If it really works, Ethereum’s layer-1 position shifts from “settlement and information availability for rollups” towards “high-throughput execution whose verification stays low-cost sufficient for dwelling validators.”
What’s really being constructed
EIP-8025, titled “Elective Execution Proofs,” landed in draft kind and specifies the mechanics.
Execution proofs are shared throughout the consensus-layer peer-to-peer community by way of a devoted matter. Validators can function in two new modes: proof-generating or stateless validation.
The proposal explicitly states that it “doesn’t require a hardfork” and stays backward appropriate, whereas nodes can nonetheless re-execute as they do at the moment.
The Ethereum Foundation’s zkEVM group revealed a concrete roadmap for 2026 on Jan. 26, outlining six sub-themes: execution witness and visitor program standardization, zkVM-guest API standardization, consensus layer integration, prover infrastructure, benchmarking and metrics, and safety with formal verification.
The primary L1-zkEVM breakout name is scheduled for Feb. 11 at 15:00 UTC.
The top-to-end pipeline works like this: an execution-layer consumer produces an ExecutionWitness, a self-contained package deal containing all information wanted to validate a block with out holding the complete state.
A standardized visitor program consumes that witness and validates the state transition. A zkVM executes this program, and a prover generates a proof of right execution. The consensus layer consumer then verifies that proof as a substitute of calling the execution layer consumer to re-execute.
The important thing dependency is ePBS (Enshrined Proposer-Builder Separation), focused for the upcoming Glamsterdam hardfork. With out ePBS, the proving window is roughly one to 2 seconds, which is simply too tight for real-time proving. With ePBS offering block pipelining, the window extends to 6 to 9 seconds.
The decentralization trade-off
If non-obligatory proofs and witness codecs mature, extra dwelling validators can take part with out sustaining full execution layer state.
Elevating fuel limits turns into politically and economically simpler as a result of validation value decouples from execution complexity. Verification work now not scales linearly with on-chain exercise.
Nonetheless, proofing carries its personal threat of centralization. An Ethereum Analysis publish from Feb. 2 reports that proving a full Ethereum block at the moment requires roughly 12 GPUs and takes a mean of seven seconds.
The writer flags considerations about centralization and notes that limits stay troublesome to foretell. If proving stays GPU-heavy and concentrates in builder or prover networks, Ethereum might commerce “everybody re-executes” for “few show, many confirm.”
The design goals to handle this by introducing consumer range on the proving layer. EIP-8025’s working assumption is a three-of-five threshold, that means an attester accepts a block’s execution as legitimate as soon as it has verified three of 5 unbiased proofs from completely different execution-layer consumer implementations.
This preserves consumer range on the protocol degree however does not resolve the {hardware} entry downside.
Probably the most sincere framing is that Ethereum is shifting the decentralization battleground. In the present day’s constraint is “are you able to afford to run an execution layer consumer?” Tomorrow’s is perhaps “are you able to entry GPU clusters or prover networks?”
The wager is that proof verification is less complicated to commoditize than state storage and re-execution, however the {hardware} query stays open.
L1 scaling unlock
Ethereum’s roadmap, final up to date Feb. 5, lists “Statelessness” as a serious improve theme: verifying blocks with out storing massive state.
Elective execution proofs and witnesses are the concrete mechanism that makes stateless validation sensible. A stateless node requires solely a consensus consumer and verifies proofs throughout payload processing.
Syncing reduces to downloading proofs for latest blocks for the reason that final finalization checkpoint.
This issues for fuel limits. In the present day, each enhance within the fuel restrict makes working a node more durable. If validators can confirm proofs somewhat than re-executing, the verification value now not scales with the fuel restrict. Execution complexity and validation value decouple.
The benchmarking and repricing workstream within the 2026 roadmap explicitly targets metrics that map fuel consumed to proving cycles and proving time.
If these metrics stabilize, Ethereum positive aspects a lever it hasn’t had earlier than: the flexibility to lift throughput with out proportionally rising the price of working a validator.
What this implies for layer-2 blockchains
A latest publish by Vitalik Buterin argues that layer-2 blockchains should differentiate beyond scaling and explicitly ties the worth of a “native rollup precompile” to the necessity for enshrined zkEVM proofs that Ethereum already must scale layer-1.
The logic is easy: if all validators confirm execution proofs, the identical proofs may also be utilized by an EXECUTE precompile for native rollups. Layer-1 proving infrastructure turns into shared infrastructure.
This shifts the layer-2 worth proposition. If layer-1 can scale to excessive throughput whereas preserving verification prices low, rollups cannot justify themselves on the premise of “Ethereum cannot deal with the load.”
The brand new differentiation axes are specialised digital machines, ultra-low latency, preconfirmations, and composability fashions like rollups that lean on fast-proving designs.
The situation the place layer-2s stay related is one through which roles are cut up between specialization and interoperability.
Layer-1 turns into the high-throughput, low-verification-cost execution and settlement layer. Layer-2s grow to be function labs, latency optimizers, and composability bridges.
Nonetheless, that requires layer-2 groups to articulate new worth propositions and for Ethereum to ship on the proof-verification roadmap.
Three paths ahead
There are three potential eventualities sooner or later.
The primary situation consists of proof-first validation changing into frequent. If non-obligatory proofs and witness codecs mature and consumer implementations stabilize round standardized interfaces, extra dwelling validators can take part with out working the complete execution layer state.
Fuel limits enhance as a result of the validation value now not aligns with execution complexity. This path is dependent upon the ExecutionWitness and visitor program standardization workstream converging on moveable codecs.
Situation two is the place prover centralization turns into the brand new choke level. If proving stays GPU-heavy and concentrated in builder or prover networks, then Ethereum shifts the decentralization battleground from validators’ {hardware} to prover market construction.
The protocol nonetheless capabilities, as one sincere prover anyplace retains the chain stay, however the safety mannequin modifications.
The third situation is layer-1 proof verification changing into a shared infrastructure. If consensus layer integration hardens and ePBS delivers the prolonged proving window, then Layer 2s’ worth proposition tilts towards specialised VMs, ultra-low latency, and new composability fashions somewhat than “scaling Ethereum” alone.
This path requires ePBS to ship on schedule for Glamsterdam.
| Situation | What needs to be true (technical preconditions) | What breaks / fundamental threat | What improves (decentralization, fuel limits, sync time) | L1 position final result (execution throughput vs verification value) | L2 implication (new differentiation axis) | “What to observe” sign |
|---|---|---|---|---|---|---|
| Proof-first validation turns into frequent | Execution Witness + visitor program requirements converge; zkVM/visitor API standardizes; CL proof verification path is secure; proofs propagate reliably on P2P; acceptable multi-proof threshold semantics (eg 3-of-5) | Proof availability / latency turns into a brand new dependency; verification bugs grow to be consensus delicate if/when it’s relied on; mismatch throughout purchasers/provers | Residence validators can attest with out EL state; sync time drops (proofs since finalization checkpoint); gas-limit will increase grow to be simpler as a result of verification value decouples from execution complexity | L1 shifts towards higher-throughput execution with constant-ish verification value for a lot of validators | L2s should justify themselves past “L1 can’t scale”: specialised VMs, app-specific execution, customized price fashions, privateness, and so on. | Spec/test-vector hardening; witness/visitor portability throughout purchasers; secure proof gossip + failure dealing with; benchmark curves (fuel → proving cycles/time) |
| Prover centralization turns into the choke level | Proof technology stays GPU-heavy; proving market consolidates (builders / prover networks); restricted “garage-scale” proving; liveness depends on a small set of subtle provers | “Few show, many confirm” concentrates energy; censorship / MEV dynamics intensify; prover outages create liveness/finality stress; geographic / regulatory focus threat | Validators should confirm cheaply, however decentralized shifts: simpler testifying, more durable proving; some gas-limit headroom, however constrained by prover economics | L1 turns into execution scalable in idea, however virtually bounded by prover capability and market construction | L2s might lean into based mostly / pre- confirmed designs, various proving methods, or latency ensures—probably rising dependence on privileged actors | Proving value tendencies ({hardware} necessities, time per block); prover range metrics; incentives for distributed proving; failure-mode drills (what occurs when proofs are lacking?) |
| L1 proof verification turns into shared infrastructure | CL integration “hardens”; proofs grow to be broadly produced / consumed; ePBS ships and supplies a workable proving window; interfaces enable reuse (eg EXECUTE-style precompile / native rollup hooks) | Cross-domain coupling threat: if L1 proving infra is harassed, rollup verification paths may additionally endure; complexity / assault floor expands | Shared infra reduces duplicated proving effort; improves interoperability; extra predictable verification prices; clearer path to larger L1 throughput with out pricing out validators | L1 evolves right into a proof-verified execution + settlement layer that may additionally confirm rollups natively | L2s pivot to latency (preconfs), specialised execution environments, and composable fashions (eg fast-proving / synchronous-ish designs) somewhat than “scale-only” | ePBS / Glamsterdam progress; end-to-end pipeline demos (witness → proof → CL confirm); benchmarks + potential fuel repricing; rollout of minimal viable proof distribution semantics and monitoring |
The larger image
Consensus-specs integration maturity will sign whether or not “non-obligatory proofs” transfer from principally TODOs to hardened check vectors.
Standardizing the ExecutionWitness and visitor program is the keystone for stateless validation portability throughout purchasers. Benchmarks that map fuel consumed to proving cycles and proving time will decide whether or not fuel repricing for ZK-friendliness is possible.
ePBS and Glamsterdam progress will point out whether or not the six-to-nine-second proving window turns into a actuality. Breakout name outputs will reveal whether or not the working teams converge on interfaces and minimal viable proof distribution semantics.
Ethereum is just not switching to proof-based validation quickly. EIP-8025 explicitly states it “can’t base upgrades on it but,” and the non-obligatory framing is intentional. Consequently, it is a testable pathway somewhat than an imminent activation.
But, the truth that the Ethereum Basis shipped a 2026 implementation roadmap, scheduled a breakout name with challenge homeowners, and drafted an EIP with concrete peer-to-peer gossip mechanics means this work has moved from analysis plausibility to a supply program.
The transformation is quiet as a result of it does not contain dramatic token economics modifications or user-facing options. But it surely’s elementary as a result of it rewrites the connection between execution complexity and validation value.
If Ethereum can decouple the 2, layer-1 will now not be the bottleneck that forces everything interesting onto layer-2.
And if layer-1 proof verification turns into shared infrastructure, the whole layer-2 ecosystem must reply a more durable query: what are you constructing that layer-1 cannot?
