Ethereum Hegota Upgrade: Native Smart Accounts, Binary State Trees, and the RISC-V Endgame

Ethereum co-founder Vitalik Buterin has laid out an ambitious execution-layer overhaul that could fundamentally reshape how developers and users interact with the blockchain. The plan, centered on the upcoming Hegota upgrade, combines three major shifts: native smart accounts at the protocol level, a binary state tree that slashes proof generation costs, and a long-term migration to a RISC-V based virtual machine. Together, these changes target what Buterin calls the network's biggest bottlenecks — the state tree and EVM — which account for over 80 percent of constraints affecting proof efficiency.

The Hegota Upgrade: What Is It?

Hegota is the next major Ethereum network upgrade, currently targeted for the second half of 2026 according to the Ethereum Foundation's public roadmap, known as the Strawmap. It follows the Fusaka upgrade which recently delivered increased blob capacity for layer-2 rollups. Where Fusaka focused on data availability scaling for L2s, Hegota digs deeper into the execution layer itself — the part of Ethereum that processes transactions and runs smart contracts.

The All Core Developers Execution call in early July 2026 began formal planning for Hegota, setting an August 6 deadline for EIP proposals. Several candidates are already on the table for consideration, and the upgrade is shaping up to be one of the most consequential in Ethereum's history.

Native Smart Accounts: A Decade in the Making

The headline feature of Hegota is EIP-8141, a proposal Buterin describes as an omnibus that wraps up and solves every remaining problem that account abstraction was intended to address — plus more. Account abstraction, the idea that user accounts on Ethereum should be programmable rather than tied to a single private key, has been under active research since 2016.

Currently, Ethereum has two account types: externally owned accounts (EOAs) controlled by private keys, and smart contract accounts. EOAs are rigid — lose your key and you lose everything. Smart contract accounts are flexible but can't initiate transactions on their own. Native account abstraction eliminates this distinction. Every account becomes programmable, unlocking capabilities like:

• Gas payment in any token, not just ETH
• Multi-signature and social recovery built into accounts
• Transaction batching (multiple actions in one transaction)
• Custom validation logic, including new signature schemes like passkeys
• Automated recurring payments and spending limits
• Privacy-preserving account configurations

The upgrade would make wallets programmable by default. A user could set up an account that automatically splits income between savings and spending, requires two-of-three hardware key confirmations for transactions above a threshold, or pays gas fees in USDC instead of ETH — all without deploying a separate smart contract. These features currently exist through ERC-4337 and smart wallet infrastructure, but native support at the protocol level would make them cheaper, more secure, and universally available.

The State Tree Bottleneck and EIP-7864

Beyond smart accounts, Buterin identified the state tree as Ethereum's single biggest proving bottleneck. The current system uses a hexary Keccak Merkle Patricia Tree — a data structure that stores all account balances, contract code, and storage. It works, but it is computationally expensive to generate zero-knowledge proofs against.

EIP-7864 proposes replacing this with a binary tree using a more efficient hash function. The change, championed by developer Guillaume Ballet and in draft since January 2025, would dramatically reduce the cost of generating ZK proofs for Ethereum state. This matters because ZK proofs are increasingly the foundation for cheaper verification, better privacy tooling, and rollup security guarantees that do not depend on trusting a single sequencer.

Lower proof costs unlock practical client-side proving — where your phone or browser can independently verify the chain state without running a full node. It also makes ZK-rollups cheaper to operate, which directly reduces fees for end users.

Beyond the EVM: The RISC-V Roadmap

The most ambitious piece of Buterin's plan is a three-stage migration from the Ethereum Virtual Machine to a RISC-V based execution environment. RISC-V is an open-source instruction set architecture already widely used by ZK provers internally — most ZK-EVMs today are built as ZK RISC-V processors running an EVM implementation on top.

The migration would unfold in three phases:

• Phase 1 — RISC-V for precompiles only. The EVM stays, but computationally heavy precompiled contracts run on RISC-V for efficiency gains.
• Phase 2 — User-deployed RISC-V contracts. Developers can write and deploy contracts directly in languages that compile to RISC-V, bypassing the EVM entirely.
• Phase 3 — EVM retirement. The existing EVM is reimplemented as a smart contract running on RISC-V, preserving full backward compatibility while the network's native execution layer moves forward.

Buterin described this as a longer-term, non-consensus change but expressed high conviction that it would become the obvious thing to do once the state roadmap upgrades are complete. The key insight: since ZK-EVMs already compile EVM code to RISC-V internally, cutting out the middleman yields better performance, simpler tooling, and cheaper proofs.

What This Means for Web3 Developers

For developers building on Ethereum today, these changes are not abstract roadmap items — they represent a material shift in the development landscape over the next 12 to 24 months.

Smart accounts change the dApp UX paradigm. When every user has a programmable account, onboarding flows can skip the seed phrase step entirely. Apps can sponsor gas for users, batch complex multi-step operations into single clicks, and offer social recovery as a native feature. The current workarounds — paymasters, bundlers, entry point contracts under ERC-4337 — become protocol-native and significantly cheaper.

Binary state trees enable trustless light clients. Mobile wallets, browser extensions, and embedded web3 widgets can independently verify chain state without relying on centralized RPC providers. This makes web3 applications more decentralized at the infrastructure level.

The RISC-V migration opens the door to writing smart contracts in languages beyond Solidity and Vyper. Any language with a RISC-V compiler target — Rust, C, Go, even Python — could theoretically be used for on-chain logic, dramatically expanding the developer talent pool.

The Timeline and What to Watch

The Hegota upgrade is currently targeted for H2 2026. The August 6, 2026 deadline for new EIP proposals means the feature set will crystallize over the coming weeks. Key milestones to watch:

• August 2026 — Final EIP proposals submitted for Hegota consideration
• Q3-Q4 2026 — Core developer testing and testnet deployments
• Late 2026 or early 2027 — Hegota mainnet activation
• Post-Hegota — RISC-V phase 1 rollout on a separate timeline

EIP-8141 is currently marked as CFI (Considered for Inclusion) rather than a confirmed headline feature. This reflects the proposal's scope and complexity, not a rejection. The CFI designation means it has entered the serious evaluation stage, and the core developer community is actively working through the implementation details.

The Bottom Line

Vitalik Buterin's Hegota roadmap is the most ambitious rethinking of Ethereum's execution layer since the transition to proof-of-stake. Native smart accounts would remove the last major UX barrier between web2 and web3 applications. Binary state trees would make cryptographic verification practical at consumer scale. And the RISC-V migration, while years away, signals that Ethereum's architecture is being designed for a future where zero-knowledge proofs are the default, not an optimization.

For developers, the message is clear: the abstractions that power better user experiences — gasless transactions, social recovery, passkey authentication — are moving from infrastructure layers into the protocol itself. If you are building a web3 application today, investing in smart account architecture now puts you ahead of the curve when native support lands. If you are ready to build, thirdweb offers developer plans that scale with your project — from smart accounts to gasless transactions, the tools are already here for what the protocol is about to make standard.