Free 30-min Web3 Consultation
Book Now
Smart Contract Security Audits
Learn More
Custom DeFi Protocol Development
Explore
Full-Stack Web3 dApp Development
View Services
Free 30-min Web3 Consultation
Book Now
Smart Contract Security Audits
Learn More
Custom DeFi Protocol Development
Explore
Full-Stack Web3 dApp Development
View Services
Free 30-min Web3 Consultation
Book Now
Smart Contract Security Audits
Learn More
Custom DeFi Protocol Development
Explore
Full-Stack Web3 dApp Development
View Services
Free 30-min Web3 Consultation
Book Now
Smart Contract Security Audits
Learn More
Custom DeFi Protocol Development
Explore
Full-Stack Web3 dApp Development
View Services
the-ethereum-roadmap-merge-surge-verge
Blog

Inside the Ethereum Improvement Proposal Process

A cynical yet optimistic breakdown of the EIP lifecycle, from ideation to mainnet. How a messy, decentralized process of researchers, client teams, and community debate builds the world's most resilient blockchain.

introduction
THE PROCESS

The Contrarian Truth: Ethereum's Strength is Its Messy Politics

Ethereum's chaotic governance is not a bug but a feature that creates superior, battle-tested protocol upgrades.

The EIP process is adversarial by design. Every major change, from EIP-1559 to the Dencun upgrade, faces public scrutiny from core developers, client teams like Nethermind and Geth, and the community. This friction prevents unilateral control and forces consensus through technical debate, not corporate decree.

Messy politics produce robust solutions. The multi-client model, requiring independent implementations from Geth, Erigon, and Besu, is a direct result of this governance. It creates a natural security check against bugs and ensures no single entity dictates the chain's evolution.

Compare this to competitor chains. Solana and Avalanche prioritize speed of execution with more centralized development. Ethereum's slower, contentious path yields upgrades that are more secure and widely adopted because they survive the gauntlet of public criticism.

Evidence: The Merge. The transition to Proof-of-Stake succeeded because years of public EIP debates, multiple testnets, and client diversity (Prysm, Lighthouse) eliminated single points of failure. The chaos was the validation mechanism.

deep-dive
THE PROCESS

The EIP Lifecycle: From Idea to Mainnet Fork

Ethereum's decentralized governance transforms raw ideas into hardened protocol upgrades through a rigorous, multi-stage funnel.

The EIP Repository is the source. All protocol changes start as a GitHub pull request to the Ethereum/EIPs repository, following templates for Core, ERC, or Meta EIPs. This creates a permanent, public record and initial technical specification.

Core Devs are the gatekeepers. An EIP author must champion their proposal through Ethereum Magicians forums and, critically, the All Core Devs (ACD) calls. Without developer consensus for inclusion, an EIP stalls. The ACD calls are the real battleground where trade-offs between clients like Geth, Nethermind, and Besu are debated.

Testnets are the proving ground. Once accepted for a hard fork, EIPs undergo deployment on sequential testnets (Sepolia, Holesky, Goerli). Client teams use this phase to identify consensus bugs and performance regressions before mainnet risk. The Dencun fork's rollout on testnets revealed critical blob propagation issues.

Mainnet activation is a hard fork. A coordinated block height triggers the fork. Post-activation, EIP success is measured by adoption and security. EIP-1559's fee market reform succeeded; EIP-2537's BLS precompiles saw limited use, demonstrating the market's role as final arbiter.

A DECISION FRAMEWORK FOR CORE DEVS

EIP Archetypes: A Taxonomy of Protocol Change

A comparative matrix of Ethereum Improvement Proposal categories, detailing their scope, governance path, and impact on consensus.

Core AttributeCore EIPNetworking EIPERC (Application-Layer)

Consensus Layer Change

Requires Hard Fork

Client Implementation Burden

All (Geth, Erigon, etc.)

All (Geth, Erigon, etc.)

None

Typical Review Timeline

12 months

6-12 months

3-6 months

Primary Champion

Ethereum Core Devs

Client Teams

Application Developers

Example (Post-Merge)

EIP-4844 (Proto-Danksharding)

EIP-2464 (eth/65 Network Upgrade)

EIP-721 (Non-Fungible Token)

Gas Cost Impact

Network-wide repricing

Negligible

Defined by contract logic

counter-argument
THE PROCESS

Steelmanning the Critique: Is This Governance or Anarchy?

A first-principles breakdown of the Ethereum Improvement Proposal (EIP) lifecycle, separating its structured governance from its perceived chaos.

The EIP process is a formalized anarchy. It provides a structured forum for conflict, not a top-down command chain. Anyone can propose changes, but adoption requires rough consensus from core developers, client teams like Nethermind and Geth, and the broader ecosystem.

Governance power is diffused, not absent. Final authority rests with client teams who must implement changes. This creates a veto power dynamic where a single team's refusal can stall an EIP, as seen with past EIP-3074 debates.

The real bottleneck is social consensus. Technical merit is necessary but insufficient. Proposals must navigate All Core Devs calls, gather feedback from major protocols like Uniswap and Lido, and survive community scrutiny on forums like Ethereum Magicians.

Evidence: The multi-year journey of EIP-4844 (Proto-Danksharding) demonstrates the system's rigor. It evolved through countless iterations, testnets like Holesky, and client implementations before its 2024 mainnet activation, proving the process filters for network-critical upgrades.

case-study
INSIDE THE EIP PROCESS

Case Studies in EIP Darwinism: Success and Failure

The Ethereum Improvement Proposal process is a brutal proving ground where technical merit, economic incentives, and network politics collide.

01

EIP-1559: The Fee Market Revolution

The Problem: First-price auction fee model was inefficient, causing user overpayment and extreme volatility. The Solution: Introduced a base fee that is burned and a priority tip, creating predictable gas costs and a deflationary ETH supply.

  • Key Benefit: Reduced fee volatility by ~70% for users.
  • Key Benefit: Burned over 4.5 million ETH (~$15B+), fundamentally altering ETH's monetary policy.
~70%
Fee Volatility
4.5M+ ETH
Burned
02

EIP-4844 (Proto-Danksharding): The L2 Lifeline

The Problem: Rollup data availability on mainnet was the primary cost bottleneck, limiting L2 scalability. The Solution: Introduced blob-carrying transactions, a new transaction type with cheap, ephemeral data storage for rollups.

  • Key Benefit: Reduced L2 transaction costs by 10-100x post-implementation.
  • Key Benefit: Paved the way for full Danksharding, establishing a clear scaling roadmap.
10-100x
Cheaper L2 Txs
~128 KB
Blob Capacity
03

EIP-3074: The Smart Account Catalyst

The Problem: Externally Owned Accounts (EOAs) are primitive, lacking features like batch transactions and sponsored gas, hindering UX. The Solution: Allows EOAs to delegate control to a smart contract invoker, enabling social recovery and complex operations.

  • Key Benefit: Unlocks batch transactions and gas sponsorship for any wallet.
  • Key Benefit: Bridges the gap to ERC-4337 Account Abstraction without requiring a new wallet.
1 Tx
Batch Operations
0 Gas
For User (Sponsored)
04

The ERC-20 Standard: The Unstoppable Meme

The Problem: No common interface for fungible tokens, leading to fragmentation and integration hell for exchanges and wallets. The Solution: ERC-20 defined six mandatory functions (transfer, balanceOf, etc.) creating a universal token blueprint.

  • Key Benefit: Enabled the 2017 ICO boom and the entire DeFi ecosystem.
  • Key Benefit: Over 500,000 contracts deployed, creating the foundational layer of Ethereum's economy.
500K+
Contracts
$10B+
Initial TVL Driver
05

EIP-867: The Standardized Rewards Proposal (Failed)

The Problem: Developers lacked a formal, transparent process for requesting funding for completed work, leading to ad-hoc grants. The Solution: Proposed a standardized template for reward EIPs to compensate contributors post-implementation.

  • Failure Reason: Rejected over fears of entitlement culture and setting a dangerous precedent for core protocol funding.
  • Legacy: Highlighted the tension between open-source ethos and sustainable developer compensation, later addressed by entities like the Ethereum Foundation and Protocol Guild.
0
Adopted
High
Governance Friction
06

The DAO Hard Fork: Survival Over Immutability

The Problem: The DAO hack drained 3.6 million ETH, threatening Ethereum's viability and user trust. The Solution: A contentious hard fork (EIP-779) to recover funds, creating Ethereum (ETH) and Ethereum Classic (ETC).

  • Key Benefit: Saved the nascent ecosystem and ~$50M in user funds at the time.
  • Key Benefit: Established the 'Code is Law' vs. 'Social Consensus' debate as Ethereum's core philosophical tension.
3.6M ETH
At Risk
2 Chains
Result
future-outlook
THE PROCESS

The Verge and Beyond: EIPs Shaping the Next Era

The Ethereum Improvement Proposal process is a formalized, multi-stage governance mechanism that filters thousands of ideas into the few that upgrade the protocol.

EIPs are a filtering mechanism that separates viable protocol upgrades from community noise. The process begins with an idea draft, moves to a formal specification, and requires rigorous peer review before finalization. This ensures only proposals with clear technical merit and broad consensus advance.

Core Devs hold implementation power, but the community drives consensus. While teams like the Ethereum Foundation's R&D or client teams (Geth, Nethermind) build the code, acceptance depends on rough consensus from developers, miners (pre-Merge), and stakers. This creates a balance between central coordination and decentralized approval.

The 'Meta-EIP' process itself evolves. EIP-1, the original process document, is regularly updated. Recent changes formalize the role of Ethereum Magicians forums for early discussion and introduced the Ethereum Cat Herders to shepherd proposals, reducing core developer overhead.

Evidence: Of over 10,000 EIPs submitted to the GitHub repository, fewer than 200 have reached 'Final' status. This sub-2% acceptance rate demonstrates the process's extreme selectivity, prioritizing stability over rapid, untested change.

takeaways
THE EIP PIPELINE

TL;DR for Protocol Architects

The EIP process is the constitutional amendment process for Ethereum, dictating how core protocol changes are debated, standardized, and deployed.

01

The Problem: Bikeshedding Kills Momentum

Endless debate on trivial details stalls critical upgrades. The process must separate high-level consensus from implementation minutiae to avoid the fate of EIP-86 or early account abstraction proposals.

  • Key Benefit: Clear separation of concerns (Core vs. ERC)
  • Key Benefit: Final comment period enforces decision deadlines
2+ Years
Stall Risk
80/20
Effort Split
02

The Solution: Alligator's EIP-1 is Your Playbook

EIP-1 is the meta-EIP that defines the entire process. Ignoring it is the single biggest mistake a proposer makes. It outlines the stages from Draft to Final, required peer reviews, and the critical role of Ethereum Magicians and client teams.

  • Key Benefit: Defines formal acceptance criteria (Last Call)
  • Key Benefit: Mandates multiple client implementations for Core EIPs
5 Stages
Formal Process
100%
Required Reading
03

The Reality: Client Teams Are The Real Gatekeepers

An EIP is just a paper standard. Real adoption requires Geth, Nethermind, Besu, Erigon to implement it. Their resource constraints and architectural opinions (e.g., on EIP-4444 history expiry) are the ultimate bottleneck. Propose with their stack in mind.

  • Key Benefit: Early client feedback prevents dead-on-arrival proposals
  • Key Benefit: Aligns with network's practical upgrade capacity
4/5
Client Consensus Needed
~6 Months
Dev Lead Time
04

The Leverage: ERCs Are Your Fast-Track to Production

For application-layer standards (like ERC-20, ERC-4337, ERC-7579), the bar is community adoption, not client consensus. A well-specified ERC with OpenZeppelin implementations and major protocol backing (e.g., Uniswap, Aave) can achieve de facto standard status rapidly.

  • Key Benefit: Bypasses core protocol upgrade cycles
  • Key Benefit: Live testing on mainnet drives refinement
Weeks, Not Years
Time to Market
$1B+ TVL
Adoption Signal
05

The Trap: Ignoring The Hard Fork Coordinator

Tim Beiko (and previously James Hancock) manages the All Core Devs calls and hard fork timelines. Failing to engage here means your EIP misses the train for the next fork (Prague/Electra). This is political navigation, not just technical merit.

  • Key Benefit: Secures slot in scheduled network upgrade
  • Key Benefit: Synchronizes testing across all testnets
~Quarterly
ACD Cadence
1 Fork
Annual Major
06

The Meta-Game: Social Consensus > Code

The final test is a successful mainnet hard fork. This requires miner/validator signaling, exchange readiness, and infrastructure provider updates. A technically perfect EIP that fractures the community (see EIP-1559 debate) risks chain split. Measure sentiment on Eth R&D Discord and Twitter.

  • Key Benefit: Prevents contentious forks and ecosystem fragmentation
  • Key Benefit: Ensures smooth, non-breaking activation
>66%
Staker Support Needed
Zero
Tolerance for Splits
ENQUIRY

Get In Touch
today.

Our experts will offer a free quote and a 30min call to discuss your project.

NDA Protected
24h Response
Directly to Engineering Team
10+
Protocols Shipped
$20M+
TVL Overall
NDA Protected direct pipeline
How Ethereum EIPs Work: The Protocol's Hidden Engine | ChainScore Blog