The MEV supply chain: PBS, MEV-Boost, and who actually captures the value

A profitable on-chain opportunity — a liquidation, a cross-venue arbitrage, a sandwich — is no longer captured by one bot doing everything from mempool-watching to block inclusion. It is captured by a division of labor. One party finds the opportunity, a second assembles it into a block, a third ferries that block to a fourth who signs it, and money changes hands at every hop. MEV has industrialized. It has a supply chain, and like every supply chain, the interesting question is not how much value flows through it but where the margin ends up.

The short answer, which this article spends its length earning: the value has migrated downstream, away from the searcher who does the clever part and toward the builders and validators who control block space. That migration is not an accident or an abuse — it is the predictable output of turning transaction ordering into a competitive auction. If you read MEV anatomy: sandwiches, frontrunning, and the dark forest of the mempool, you already know what MEV is and met the words "bundle" and "PBS" in passing. This piece is the org chart behind them: who the players are, what each one actually sells, and why a newcomer trying to enter at the top of the chain today is entering the most commoditized part of it.

The assembly line: searcher, builder, relay, proposer

Before proposer-builder separation, the entity that ordered transactions (a proof-of-work miner) also produced the block, and a searcher who wanted a specific ordering had exactly one crude lever: the public gas price. That world — priority gas auctions screaming at each other in the mempool — is the one the sandwich article opens with. The modern stack unbundles that single actor into four specialized roles:

• Searcher. Finds the opportunity and expresses it as a bundle — an ordered list of transactions to be executed atomically. A backrun on an oracle update, an atomic arb across two pools, a sandwich around a victim swap. The searcher's edge is strategy and simulation: knowing the opportunity exists and pricing it correctly. This is the role the atomic arbitrage and flash loans article lives inside — the searcher whose bundles feed everything downstream.
• Builder. Collects bundles from many searchers plus ordinary public transactions, and solves a combinatorial packing problem: assemble the single most valuable block, respecting each bundle's atomicity and ordering constraints, with no two bundles conflicting on state. The builder's edge is order flow and optimization — the more (and more exclusive) the flow it sees, the more valuable the block it can produce.
• Relay. A trusted intermediary that receives full blocks from builders, validates them (they pay what they claim, they're not invalid), and exposes only the block header plus a value bid to the proposer. The relay exists to solve a trust problem in both directions: the proposer commits to a block before seeing its contents (so it can't steal the MEV), and the builder reveals its block only to a proposer that has committed to it (so it can't be plagiarized).
• Proposer (a validator, chosen by the protocol for this slot). Receives header+bid pairs, picks the highest, signs it, and collects the payment. The proposer's "edge" is simply having been selected to propose — a right the protocol allocates by stake, not by skill.

Read as a market, each layer sells something to the next. Searchers sell ordered bundles to builders. Builders sell complete blocks to proposers (via relays). Proposers sell the block space itself — the one thing that is genuinely scarce — to the highest bidder. Value accrues to whoever controls the scarcest input, and the scarcest input is not cleverness. It is the slot.

Proposer-builder separation and the MEV-Boost pipeline

On Ethereum this assembly line runs off-protocol through MEV-Boost, middleware released by Flashbots around the September 2022 Merge and now run by the large majority of validators. Widely-cited dashboards put roughly ~90% of Ethereum blocks as built through external builders via MEV-Boost rather than locally by the validator — treat the exact figure as an approximate, moving number, but the qualitative fact is settled: most blocks are outsourced. The validator who wins a slot mostly does not build its own block; it buys one.

The mechanism is a sealed-bid, first-price block auction, run once per 12-second slot:

1. Searchers submit bundles privately to one or more builders.
2. Each builder assembles its best block and streams bids — (block header, value) — to relays. Bids update continuously as better bundles arrive, right up to the slot deadline.
3. The relay holds the full blocks, exposes only headers and values to the proposer's MEV-Boost sidecar.
4. The proposer signs the header with the highest value. Only then does the relay release the full block body for propagation.

What the builder does in step 2 is not bookkeeping — it is a hard optimization problem, and it is the second reason (alongside exclusive flow) that building concentrates. The builder must select and order a subset of thousands of bundles and transactions to maximize block value, subject to the gas limit, each bundle's internal ordering and atomicity constraints, and the requirement that no two included items conflict on the state they read and write (two bundles that both sandwich the same swap cannot coexist). This is a constrained combinatorial search with no clean closed form, re-solved continuously as new bundles stream in during the ~12-second window and re-bid to the relay each time a better block is found. Doing it well demands fast simulation, careful conflict detection, and low latency to relays — a fixed-cost infrastructure game that rewards scale and punishes newcomers, entirely apart from who has the best order flow.

Three properties of a bundle make this work, and they are worth stating precisely because everything downstream depends on them:

• Ordered. The transactions in a bundle execute in the exact sequence given. A sandwich's frontrun must land before the victim; a liquidation must land after the oracle update. Order is the product.
• All-or-nothing (atomic). Either every transaction in the bundle is included, in order, or none is. A searcher never lands a half-executed strategy — the frontrun without the backrun, the arb's buy leg without its sell leg. This is what lets searchers bid aggressively: a losing bundle simply doesn't execute and costs (almost) nothing.
• Sealed-bid. Bundles and bids are private to the builder and relay, not gossiped on the public mempool. The auction is a closed envelope, not the open shouting match of the PGA era.

Two structural facts fall out of this design and drive the rest of the article. First, the relay captures almost nothing: relays typically take no cut, running as neutral infrastructure — a public good funded strategically (by Flashbots, by staking pools, by builder-adjacent teams) rather than a profit center. The thin, unpaid middle of the chain is a deliberate feature; a relay that started skimming would be routed around. Second, the proposer captures the auction's clearing price — the winning block's bid, which flows to the validator and, through staking pools and liquid-staking tokens, ultimately to stakers as part of yield. MEV that once stayed with a lone searcher now shows up, diffusely, in the staking rate of the whole network. That is the migration downstream, made concrete. The proposer contributed no cleverness; it contributed scarcity.

There is one more subtlety worth naming, because it undoes the tidy picture of a fair sealed auction: timing games. Since the relay releases the block body only after the proposer commits, and since bids keep improving until the slot deadline, both builders and proposers have an incentive to wait as long as they safely can — builders to squeeze in one more bundle, proposers to let the highest bid mature — before signing. Sophisticated proposers deliberately delay their attestation to capture marginally more MEV, at some risk to timely block propagation. The "auction" is not a clean instant; it is a race against a soft deadline, and the players who can push closest to it without missing the slot extract a little more.

The neutrality of the relay is also a trust assumption, not a cryptographic guarantee — and that assumption has failed in the wild. In April 2023, two operators exploited an implementation bug in the Flashbots MEV-Boost relay: they baited sandwich bots into a block, and when they were the proposer for that slot, they induced the relay to release the full block body prematurely (via a malformed, invalid-signature block), then reordered the contents to drain roughly ~$25M from the very sandwichers they had lured. The bundle's "all-or-nothing, ordering-guaranteed" promise held only as long as the relay software behaved; a bug turned the sealed envelope inside out. (U.S. prosecutors later indicted the two for fraud.) The lesson isn't that PBS is broken — it is that the relay is the load-bearing trust joint in the whole chain, which is precisely why removing it is the next design goal.

(Where does it go next? The trusted-relay dependency is the weak joint, and enshrined PBS — folding proposer-builder separation into the protocol itself — is the standing proposal to remove it, which the sandwich article covers as a forward-looking item. For our purposes the point is narrower: even enshrined, PBS keeps the auction, and the auction is what redistributes the margin.)

Searcher economics: the auction eats your margin

Here is the uncomfortable arithmetic for anyone who wants to enter at the searcher layer. Suppose you spot a public opportunity — a liquidation everyone can compute, a CEX-DEX arbitrage everyone can see — worth gross value $V$ after execution costs. To land it, you must pay the proposer a bid $b$, delivered either as a priority fee or as a direct transfer inside the bundle (a "coinbase payment"). Your profit if you win is

$\pi = V - b - g$

where $g$ is gas. The catch: $N$ other searchers have run the same simulation and arrived at the same $V$. You are not pricing an asset only you understand; you are bidding in an auction for a prize everyone has measured.

The commodity limit. If the opportunity is truly public and every searcher values it identically, this is Bertrand competition on the bid. In equilibrium the bid is driven up to the value: $b \to V - g$, and the searcher's profit collapses to essentially zero. The entire gross value flows through you to the proposer. You did the work; the validator got paid.

The private-information case. Real searchers have noisy estimates of $V$ and slightly different costs, so the auction is first-price with private values rather than pure Bertrand. Take the tractable benchmark of $N$ searchers whose valuations are i.i.d. uniform on $[0, V]$. The symmetric equilibrium bid shades below one's own valuation:

$b(v) = \frac{N-1}{N}\, v$

You bid a fraction $(N-1)/N$ of what you think it's worth — and that fraction climbs toward 1 as $N$ grows, so the more crowded the opportunity, the less room to shade. Working through the order statistics, the winner keeps in expectation

$\mathbb{E}[\pi_{\text{win}}] = \frac{V}{N+1},$

while the proposer collects $\frac{N-1}{N+1}V$. And since any given searcher wins only about $1/N$ of the time, a searcher's unconditional expected profit per opportunity is

$\mathbb{E}[\pi] \approx \frac{V}{N(N+1)},$

which decays like $1/N^2$. Two rivals become five become twenty, and your expected take per opportunity falls off a cliff.

def searcher_edge(value_estimate, n_rivals, gas):
    """First-price common-value-ish auction with n_rivals competitors.
    Shade toward value as competition rises; margin ~ V/(n+1) when you win,
    and ~ V/(n*(n+1)) unconditionally, since you win ~1/n of the time."""
    n = n_rivals + 1                       # total bidders including you
    bid = value_estimate * (n - 1) / n - gas
    margin_if_win  = value_estimate / (n + 1)
    margin_expected = value_estimate / (n * (n + 1))
    return bid, margin_if_win, margin_expected

Numerically, a $1,000 opportunity split among five searchers leaves the winner ~$167 and hands the proposer ~$833; among twenty searchers the winner keeps ~$48 and the proposer takes ~$952. The winner's curse sharpens this further: in a common-value setting, winning is evidence you overestimated $V$ — you won precisely because your estimate was the most optimistic — so rational searchers must shade additionally to avoid systematically overpaying, thinning the margin again.

The strategic conclusion writes itself. On any opportunity the whole field can see, the block-space auction transfers the surplus to the proposer. The searcher's only defense is to not be bidding against $N$ rivals with the same information — to have flow, or an opportunity, that others cannot see. Which is exactly why the frontier of MEV has moved from cleverer strategies to exclusive order flow.

Order-flow auctions and the private-flow oligopoly

If public opportunities are competed to zero, the scarce resource is private order flow: transactions that reach you before they reach everyone else. This reframes the whole business. The value in a user's swap isn't only the swap — it's the right to backrun it, sandwich around it, or route it optimally before anyone else knows it exists. Whoever captures that right first captures the MEV attached to it.

Order-flow auctions (OFAs) turn that right into an explicit market. MEV-Share, Flashbots' OFA, is the user-facing, benign version: a user sends a transaction privately, the system reveals only partial hints about it to searchers, searchers bid to backrun it, and a large share of the resulting profit is refunded to the user. From the user's seat this is protection (covered from the trader's side in the sandwich article). But look at the same flow from the builder's seat and a different, less comfortable picture appears.

The chain of incentives runs like this:

1. A builder that receives exclusive order flow — retail swaps routed to it alone, an OFA whose winning bundles it sees first, a wallet or RPC that sends only to it — can build strictly more valuable blocks than a builder without that flow.
2. More valuable blocks win the MEV-Boost auction more often.
3. Winning more often lets the builder pay searchers and integrators more for their flow, and reinvest in latency and optimization.
4. Which attracts still more exclusive flow. Return to step 1.

This is a textbook winner-take-most feedback loop, and it is visible in the data: Ethereum block building is far more concentrated than block proposing. A handful of builders produce the large majority of MEV-Boost blocks — treat specific names and shares as fast-moving, but the shape (a top-heavy oligopoly of two or three dominant builders plus a long tail) has held for years. The searcher layer stays competitive; the builder layer does not, because the builder layer is where exclusive flow accumulates.

The centralization pressure is the real cost, and it is a genuine tension in the design. OFAs are good for the individual user — they hand back value the dark forest used to steal. But by making order flow a tradable, exclusive asset, they hand the builders who accumulate it a structural moat, and a maximally concentrated builder market is exactly what proposer-builder separation was supposed to avoid: a few parties deciding what goes into most Ethereum blocks. "Give the value back to users" and "keep block-building decentralized" are, at the margin, in conflict. Nobody has fully resolved it; enshrined PBS and enforced inclusion lists are attempts to bound the damage rather than eliminate the incentive.

For a would-be searcher, the lesson is blunt: the game is no longer only "find opportunities others miss," it is "secure flow others can't see." That is a business-development and integration problem — deals with wallets, RPCs, protocols — at least as much as an engineering one, and it favors incumbents.

The Solana contrast: Jito, tips, and continuous auctions

Ethereum's supply chain is shaped by one architectural choice: a public mempool where pending transactions are visible to all. Solana made different choices, and the MEV supply chain there looks different as a result — a useful contrast for seeing which parts of the Ethereum story are fundamental and which are contingent.

No canonical public mempool. Solana does not gossip pending transactions into a shared pool. Under Gulf Stream, clients forward transactions directly to the expected leader — the validator scheduled to produce upcoming blocks (the leader schedule is known in advance for the whole epoch, and each leader owns four consecutive ~400 ms slots). There is no global bulletin board of pending intent for searchers to watch. That removes the classic "watch the mempool, frontrun what you see" attack surface at the base layer — but it does not remove MEV; it relocates the contest to whoever is feeding the current leader.

Jito as the off-protocol auction. That "whoever" is, in practice, Jito. The Jito-Solana validator client — run by validators representing a large majority of stake — adds a bundle market on top of the base protocol, mirroring MEV-Boost's role but integrated into the validator client rather than sitting behind relays. Searchers submit Jito bundles (ordered, atomic, all-or-nothing, just like Ethereum bundles) plus a tip to the Jito Block Engine, which runs an off-chain auction and forwards the winning bundles to the leader. Tips land in tip accounts and are distributed to the validator and its stakers — the same "MEV becomes staking yield" endpoint as Ethereum, reached by a different road.

Priority fees vs tips — two different levers. Solana has two distinct ways to pay for ordering, and conflating them is the common mistake:

• Priority fees are protocol-native: a per-compute-unit price (micro-lamports per CU) attached to a transaction, raising its scheduling priority inside the leader's banking stage. They are in-protocol, apply to every transaction, and are partly burned.
• Jito tips are out-of-protocol: a payment to the Block Engine's auction for bundle inclusion and ordering, entirely separate from the CU price. This is the direct analog of the Ethereum coinbase payment / block-auction bid.

Continuous vs slot auction. Ethereum runs one sealed-bid auction per 12-second slot — a single, discrete block-space market with a hard deadline. Jito's Block Engine instead runs frequent, short auction windows (sub-second ticks), parallelized across bundles that touch disjoint accounts, matching Solana's ~400 ms block cadence and continuous execution. The economic texture differs: Ethereum's is a clean per-block first-price auction where a searcher bids for a slot; Solana's is a rapid stream of smaller auctions where contention is per-account and latency to the Block Engine matters even more.

One episode makes the design trade-off vivid. Jito did run a public mempool for a time — and in March 2024 disabled it, because that mempool had become the primary venue for sandwich attacks on Solana users. Removing the public pending-transaction feed removed the sandwich surface at a stroke. It also pushed order flow further into private channels (direct-to-Block-Engine, private RPCs), which is the same centralizing dynamic as Ethereum's OFAs wearing different clothes: kill the public mempool to protect users, and you strengthen whoever controls the private pipes.

Where a newcomer can (and cannot) compete

Map the supply chain onto a realistic entry strategy and the picture is sobering but not hopeless.

Where you almost certainly cannot compete:

• Building. The builder layer is a latency-and-flow oligopoly with years of optimization and exclusive order-flow relationships baked in. Entering as a general-purpose builder against the incumbents is a capital-intensive loss.
• Public, deterministic opportunities. Public liquidations, textbook two-pool arbs, anything a hundred bots can simulate to the same number — Section 3's arithmetic says the surplus is auctioned to the proposer. You will win $1/N$ of the time for $V/(N+1)$, minus real fixed costs, against people with better latency. That is not a business; it is tuition.
• Proposing for MEV. Capturing the proposer's slice means being a validator, which means stake. That is a yield play on capital, not an edge.

Where a newcomer realistically can:

• Long-tail and new-chain opportunities. Emerging L2s and appchains with immature builder markets, thin competition, and mispriced parameters resemble Ethereum circa 2021. The edge is being early to an inefficient venue, not being fastest on a saturated one.
• Hard-to-simulate opportunities. Multi-hop routes, exotic collateral whose exit liquidity is genuinely difficult to price, cross-domain plays spanning chains. Here the edge is modeling, not latency — exactly the searcher skill the auction does not commoditize, because rivals who model it wrong don't bid it up correctly.
• Securing your own flow. The durable moat, per Section 4, is order flow others can't see: a wallet, a frontend, a protocol integration, a Telegram-bot userbase whose transactions route to you first. This is a distribution problem more than an engineering one — and distribution is where incumbents are, paradoxically, sometimes beatable by someone who owns a niche audience.
• Stress events. When gas spikes and RPCs fail, the marginal, under-provisioned operators drop offline and opportunities that are normally auctioned to zero briefly pay again. Robust infrastructure earns its keep precisely when everyone else's breaks — the race pays best when it is hardest to run.

The honest framing: the top of the supply chain (searching public opportunities) is the most commoditized part, and the middle (building) is a moated oligopoly. A newcomer's realistic edge is at the edges — inefficient venues, hard modeling, and owned flow — not in the center where the incumbents and the auction have already extracted the margin.

What to take away

1. MEV is a supply chain, not a bot. Searcher → builder → relay → proposer, and each layer sells something to the next: bundles, blocks, trust, and finally the scarce thing itself — block space.
2. The margin migrated downstream. The searcher does the clever part but the block-space auction transfers surplus to whoever controls the slot. The relay captures ~nothing (a neutral public good); the proposer/validator captures the clearing price, which resurfaces as staking yield.
3. PBS/MEV-Boost is a sealed-bid, first-price block auction, run once per slot, over ordered, all-or-nothing bundles — and it builds the ~90%-ish majority of Ethereum blocks.
4. On any public opportunity, the searcher's margin is competed to ~zero. Expected profit decays like $1/N^2$ in the number of rival searchers; the winner's curse thins it further. The only defense is information others don't have.
5. Exclusive order flow is the new moat, and order-flow auctions — great for the individual user — concentrate the builder market, putting "give value back to users" in tension with "keep block-building decentralized."
6. Solana/Jito shows which parts are contingent. No public mempool (Gulf Stream), an in-client Block Engine instead of relays, priority fees and tips, and continuous sub-second auctions instead of one per slot — a different architecture reaching the same endpoint (MEV as validator/staker yield) and the same centralizing pull toward private flow.
7. A newcomer competes at the edges, not the center: inefficient new venues, hard-to-simulate opportunities, owned flow, and stress events — never public opportunities against the field, and never head-on as a builder.

The searcher whose bundles feed this whole machine is the subject of atomic arbitrage and flash loans; the trader on the receiving end of it is the subject of the sandwich and mempool primer. This article was the middle of the chain — the part that decides who keeps the money.

References

• Flashbots documentation: MEV-Boost architecture, relays, MEV-Share, and builder/searcher docs (docs.flashbots.net).
• MEV-Boost: block-building outsourcing statistics and relay/builder dashboards (e.g. mevboost.pics, Rated, relayscan.io) — treat specific shares as time-varying.
• Daian et al. (2019), Flash Boys 2.0: Frontrunning, Transaction Reordering, and Consensus Instability in Decentralized Exchanges. arXiv:1904.05234 (the PGA world PBS replaced).
• Ethereum proposer-builder separation and enshrined PBS (ePBS) design notes and EIP-7732 materials.
• The April 2023 MEV-Boost relay exploit and subsequent U.S. indictment (Flashbots post-mortem on the relay vulnerability; DOJ press release, 2024) — the relay-trust failure discussed above.
• Jito documentation: Jito-Solana client, Block Engine, bundles, tips, and the March 2024 mempool deprecation (docs.jito.wtf, jito.network blog).
• Solana Gulf Stream, leader schedule, and priority-fee (compute-unit pricing) documentation.
• Auction-theory background on first-price bidding, bid shading, and the winner's curse (Vickrey 1961; Milgrom & Weber 1982).