Programmable Blocks: How Ethereum Builders Rewire Execution

Ethereum may be entering a new phase of execution design by the introduction of a concept called Programmable Blocks.

On March 25, 2026, Eureka Labs, a relatively quiet Ethereum startup based in Tel Aviv, introduced a concept called Programmable Blocks. At first glance, it sounds like an infrastructure upgrade. In practice, it could be much bigger than that. If the model works, it would push Ethereum blocks beyond their traditional role as simple containers for transactions and turn them into programmable execution environments.

That is a meaningful shift inside the world of Proposer-Builder Separation (PBS), where the line between block production and application logic has historically remained quite clear.

Before getting into the core idea, the market context matters. Eureka Labs has raised $6.7 million in seed funding through a SAFE with token warrants. The round was led by Spark Capital and Collider Ventures, with support from additional funds and angel investors. Founded in December 2024, the company has already climbed to become the fourth-largest Ethereum block builder, with around 1.5% market share.

Still, the funding is not the real headline. The real headline is this: Eureka wants to make Ethereum blocks do more than just hold transactions.

What Block Builders Actually Do in Ethereum PBS

Since The Merge and the rise of MEV-Boost, Ethereum block production has become more specialized.

In the current flow can be divided into 2 steps:

• Proposers - usually validators - are responsible for proposing blocks to the network.
• Builders assemble those blocks by pulling transactions from the mempool, ordering them for maximum value, extracting MEV, and then submitting finished blocks to proposers.

Today, the top three builders control nearly 96% of the market. That concentration already makes the builder layer one of the most influential parts of Ethereum’s execution pipeline.

However, under the current model, builders mostly optimize transaction packaging and ordering. The deeper logic still lives inside smart contracts. Eureka Labs is challenging that design assumption.

Why Ethereum Still Struggles With Complex On-Chain Execution

This is the pain point at the center of the story.

Ethereum is programmable, but the EVM is still a constrained environment. Developers building sophisticated DeFi systems often run into the same problems: high gas costs, fragile execution paths, ordering uncertainty, and limited access to real-time external data.

Consequently, some classes of applications are either too expensive, too rigid, or too unreliable to execute purely on-chain.

Programmable Blocks aim to change that by introducing block-level guarantees enforced directly by the builder during block construction. Instead of treating the block as a passive endpoint, the builder becomes an active coordination layer that can support more expressive execution logic.

As Eureka Labs Co-Founder and CEO Nir Magenheim put it:

“This allows developers to rely on guarantees at the block level, not just within smart contracts. For example, you can build applications that need large amounts of capital for a few seconds, depend on precise ordering, or require complex computations that are usually impossible to put on-chain.”

That framing matters. If smart contracts expanded what blockchains could do in 2015, Programmable Blocks could expand what block production itself can do next.

Four Ways Programmable Blocks Could Expand Ethereum

Eureka’s design opens a new execution surface between the mempool and final block inclusion. In other words, it gives developers access to a more flexible layer than the EVM alone.

1. Intra-Block Credit

This is one of the most attention-grabbing features.

With intra-block credit, a user could access a large amount of capital for roughly 12 seconds without posting collateral, execute a strategy, complete the required logic, and repay the borrowed funds before the block is finalized.

Specifically, this could support large arbitrage trades, complex liquidation flows, and highly capital-efficient DeFi strategies without forcing capital to remain locked for longer periods.

2. State-Aware Pre-Computation

Builders can compute against the exact pending state of the block they are assembling, then inject the result directly into the final transaction flow.

That sounds technical, but the implication is simple: less gas waste and fewer execution surprises.

Furthermore, for advanced DeFi use cases, this kind of state-aware computation could make strategies more efficient and more dependable, especially when execution precision matters.

3. Execution-Time Access to External Data

During block construction, builders can fetch off-chain data in real time, including price feeds, APIs, and event-driven inputs, and incorporate those values into transactions before the block lands on-chain.

In contrast to traditional oracle-heavy designs, this creates a faster path for data-aware execution. As a result, applications could react to fresher market information without depending entirely on slower, more rigid on-chain data delivery systems.

4. Deterministic Transaction Placement

Ordering is everything in Ethereum, especially in DeFi.

Programmable Blocks allow builders to guarantee the precise order of a set of transactions within the same block. That creates a stronger execution environment for workflows that depend on exact sequencing.

More importantly, it could help reduce harmful MEV patterns such as front-running and sandwich attacks, both of which thrive on ordering uncertainty.

The Bull Case: A New Execution Layer for Ethereum

The broader vision is clear. Eureka is not just improving block construction. It is positioning the builder layer as a new form of execution infrastructure.

That could have major implications for:

• DeFi, where execution precision and capital efficiency are critical
• RWA protocols, which often depend on timely data and more structured guarantees
• complex on-chain applications that struggle under pure EVM constraints
• future infrastructure designs that sit between today’s smart contracts and tomorrow’s more modular execution stack

In that sense, Programmable Blocks fit into a wider industry trend: pushing blockchain design toward more specialized and expressive infrastructure. While Ethereum is not becoming a modular blockchain in the strict sense here, it is clearly deepening the separation of roles inside its execution architecture.

But Here’s the Catch: More Power Means More Trust Assumptions

This is where the idea gets more controversial.

Ethereum has always leaned toward trust minimization. Smart contracts are powerful precisely because their rules are transparent and verifiable by anyone. Programmable Blocks introduce a different model. They create new guarantees, but those guarantees depend more heavily on the builder behaving as promised.

That changes the trust surface.

Intra-Block Credit Is Powerful, But Not Entirely New

The idea of borrowing capital without collateral inside a short atomic window already exists through flash loans.

So what is different here?

Flash loans operate inside a single transaction and fully revert if repayment fails. Intra-block credit extends across the entire block-building window. Therefore, it may offer more flexibility and composability, but it feels more like a builder-native extension than a completely new primitive.

External Data Access Raises Verification Questions

Execution-time access to off-chain data is appealing. However, it also introduces a critical problem: how do users verify that the builder fetched and used the right data honestly?

Without strong validation mechanisms, this feature could become a new source of opacity, manipulation, or hidden centralization.

Centralization Risk Could Increase

This concern is impossible to ignore.

If programmable features become economically valuable, the most sophisticated builders may gain even more influence. That could deepen existing concentration in the PBS market, where a handful of players already dominate.

Consequently, one of the biggest open questions is how this model would fit with Ethereum’s longer-term roadmap, particularly around Enshrined PBS.

Programmable Blocks Don’t Eliminate Trust. They Move It.

That may be the cleanest way to understand the entire proposal.

Programmable Blocks do not make Ethereum more trustless by default. Instead, they shift part of the trust model away from smart contracts and into the builder layer.

That does not automatically make the design bad. But it does mean Ethereum would need stronger systems for verification, accountability, and transparency if this approach is going to scale safely.

If Eureka Gets This Right, the Upside Is Huge

If the trust and transparency issues can be solved, Programmable Blocks could unlock a meaningful step forward for Ethereum.

They could enable:

• more gas-efficient DeFi execution
• stronger atomic guarantees for complex transaction flows
• new on-chain applications that are currently too expensive or too brittle to deploy
• better infrastructure rails for advanced crypto products, including RWA and next-gen financial logic

In short, this is not just a builder optimization story. It could be an execution stack story, one that pushes innovation deeper into Ethereum’s core infrastructure.

Final Take

Programmable Blocks package a surprisingly simple idea inside a very ambitious vision: turn an Ethereum block into a 12-second programmable machine.

If Eureka Labs can prove the model and the ecosystem can solve the trust layer around it, this could become one of the more important infrastructure experiments in Ethereum’s PBS era.

And for the broader Web3 market, that is the real signal. Ethereum is still evolving where it matters most: deep in the infrastructure layer, where the next generation of DeFi, RWA, and high-performance on-chain applications will be built.

Author: Khong Vu Minh Duc Compiled by Dieu Anh