Jito Explained: Bundles, Tips, and How MEV Actually Works on Solana in 2026

Jito is no longer a niche piece of Solana infrastructure. It is the infrastructure. By mid-2026 the Jito-Solana client runs under more than 95% of Solana's active stake, Jito tips account for more than 60% of all priority-fee volume on the network, and the protocol routinely processes billions of dollars in daily activity through liquid staking and MEV extraction combined.

For anyone building on Solana—a searcher, a market maker, a DeFi protocol, an RPC operator, a wallet, or a validator—understanding how Jito works is not optional anymore. Every transaction that needs to land reliably during congestion is competing in some version of Jito's auction. Every block produced on the network is being assembled by infrastructure Jito controls or strongly influences.

The Problem Jito Was Built to Solve

Before Jito, Solana had an MEV economy. It just didn't have a market for MEV. Searchers—the bots competing for arbitrage opportunities and liquidations—knew which validator was producing the next block and competed by spamming the network with transactions, hoping one would land first.

The result was technically expensive. Internal Jito research showed that in a typical 2022 epoch, more than 60% of block compute units were consumed by arbitrage transactions, and more than 98% of those attempts failed. A network as fast as Solana was burning more than half its blockspace on transactions that produced nothing—pure latency war, pure spam, pure waste.

The structural fix wasn't to slow searchers down. It was to give them a different shape of competition. Instead of competing on raw network spam, searchers could compete on price—by paying validators directly to include their transactions in a specific order. The auction replaces the latency war. Block space stops being a tragedy of the commons and becomes a market.

That's what Jito Bundling does. The first version shipped in 2022, and by 2026 it has become the dominant way time-sensitive transactions reach Solana blocks.

How the Jito System Actually Works

Jito is not a single product. It is a stack—partly modified validator software, partly off-chain infrastructure, partly on-chain programs. Five components matter:

The flow: a user (or a searcher) sends a transaction or bundle to the Block Engine. The Block Engine simulates it, scores it against competing bundles, and forwards the highest-paying combination of bundles that fit within the block's compute-unit budget to the validator running Jito-Solana. The validator includes those bundles in its next leader slot. Tips paid by winning bundles flow into the on-chain Tip Payment Program and are eventually distributed by the Tip Distribution Program to validators and their stakers.

The 200ms relayer delay is worth pausing on. It looks like added latency from a user's perspective, but it's the window that makes bundling possible: it gives searchers a chance to see your transaction and either bundle their own next to it (back-running arbitrage, JIT liquidity) or build a competing bundle. The delay is the cost of making the market work.

What a Jito Bundle Actually Is

A Jito bundle is a group of up to 5 Solana transactions executed sequentially and atomically within the same slot. Either every transaction in the bundle succeeds, or none of them do. This is the property that makes bundles useful—and that distinguishes them from sending 5 separate transactions and hoping all 5 land.

The hard constraints are worth knowing:

• Maximum 5 transactions per bundle
• Sequential, atomic execution within a single slot
• Cannot span multiple slots
• Cannot modify consensus-critical accounts
• Must pass cost / QoS checks—if any single transaction exceeds the compute budget, the whole bundle is rejected
• A tip instruction must appear in the last transaction of the bundle
• Minimum tip is 1,000 lamports, paid as a SOL transfer to one of Jito's 8 hardcoded tip accounts

The atomic property is what makes bundles essential for MEV strategies. A cross-DEX arbitrage requires both legs to execute or neither—you cannot end up with the buy leg landed and the sell leg reverted. A liquidation requires the price oracle update and the liquidation call to land together. JIT liquidity requires the LP add and the LP remove to land in the same atomic envelope around the user's swap. None of this works without atomic, sequential execution.

Bundles also unlock use cases that are simply not possible with single transactions: batching operations across multiple transactions to get past Solana's 1.4M compute-unit-per-transaction cap, MEV-protected complex DeFi flows, and protocol-level coordination across multiple programs.

How Tips Work—and Why Priority Fees Aren't the Same Thing

Tips and priority fees are not the same thing, and conflating them is one of the most common technical mistakes I see in production code.

Inside the Block Engine auction, the selection logic is straightforward in principle. The engine ranks bundles by tip and CU efficiency—essentially "tip per compute unit"—and selects the highest-paying combination of bundles that fits within the block's available budget. Parallelism in account locking patterns is exploited where possible, so non-conflicting bundles can be packed together more aggressively.

Two things matter about the tip dynamics in 2026.

First, the auction is continuous and adaptive. Tips that worked last week may not work this week, and tips that worked during quiet hours probably won't work during a token launch. Production teams calibrate dynamically off rolling tip telemetry from recent blocks rather than hardcoding values.

Second, the tip ceiling for competitive opportunities has stabilized somewhere between 50% and 70% of expected profit. That's what competitive searchers actually surrender to win. Pay less, you don't land. Pay more, the strategy is a charity. This has produced its own market—tip-floor monitoring services, dynamic tipping libraries, and tip economics analytics from Solana data providers.

By the end of 2024, Jito tips had grown from roughly 10% of Solana priority-fee volume in April 2023 to more than 60%—and the share has stayed above that line through 2025 and into 2026. The protocols generating the most tip activity are exactly the ones you'd expect: Raydium v4 dominates by volume, with Jupiter v6, Pumpfun, Meteora, and Photon making up most of the rest. Almost every high-volume contract in DeFi is now bidding into Jito's auction by default.

ShredStream: Earlier Shreds, Real Edge

ShredStream is the part of Jito's stack that has nothing to do with bundle submission and everything to do with data ingestion.

On Solana, blocks are constructed in pieces. Each piece is called a "shred"—a fragment of a block containing some transactions and metadata. Validators produce shreds and propagate them across the network using a protocol called Turbine, which works like a fanout tree: each validator forwards shreds it receives to a small set of peers, who do the same, until eventually the whole network has the full block.

Turbine is efficient at scale. It is not, however, fast. A node receiving shreds over Turbine sits a few hops away from the producing validator, and those hops add latency. ShredStream short-circuits this: it streams shreds directly from Jito-connected validators to ShredStream subscribers without waiting for the Turbine fanout to reach them.

The practical effect is hundreds of milliseconds of saved latency on incoming block data. For HFT and competitive MEV, this is the difference between detecting an opportunity inside the slot and detecting it in the next one. For RPC operators, it's the difference between serving fresh state and serving slightly stale state.

ShredStream is not consensus-relevant—it doesn't change how Solana reaches agreement, only how quickly downstream systems see what consensus produced. In 2026 it has become standard for any infrastructure provider serving latency-sensitive customers, often wired in by default through the Yellowstone Geyser plugin.

The Lifecycle of a Winning Bundle

Putting the pieces together, here is what a competitive bundle's path looks like end-to-end:

1. Signal detection. A searcher's bot, subscribed to Yellowstone Geyser and/or ShredStream, sees an account write—a swap that creates an arbitrage opportunity, a price update that puts a position underwater, a new pool creation. Target latency: <50 ms.
2. Path search. The bot evaluates the opportunity against expected fees, slippage, and likely tip cost. Target latency: <20 ms.
3. Bundle construction. Both legs of the trade (or the liquidation call plus oracle update, etc.) are packed into a single bundle. The tip instruction goes in the last transaction. Address Lookup Tables compress account references. Target latency: <10 ms.
4. Simulation. simulateBundle runs against current chain state. If the bundle reverts in simulation, it's dropped—a failed simulation is free, but a failed bundle on-chain with a paid tip is not. Target latency: <20 ms.
5. Submission. The bundle is forwarded to multiple Block Engine regional endpoints in parallel (NY, Frankfurt, Tokyo, Amsterdam) so it lands no matter where the slot leader is. Tip is calibrated dynamically against rolling block telemetry. Target latency: <30 ms.
6. Auction and inclusion. The Block Engine simulates the bundle against competing bundles, ranks the field by tip-per-CU, selects the highest-paying combination that fits the block budget, and forwards the winners to the Jito-Solana validator currently producing the slot.
7. Settlement. The bundle lands and captures the opportunity, or it reverts on-chain due to state changes between detection and execution. On revert, only the compute fee is lost—not the principal—but the tip is still paid.

A well-tuned searcher pipeline can complete steps 1 through 5 in under 50 milliseconds end-to-end. That is the difference between competing and watching.

BAM: The Block-Building Architecture That Just Changed Solana

Through 2024 the Jito model worked, but it had a known limitation: the Block Engine was effectively a centralized auctioneer. Searchers trusted it not to leak their bundles, validators trusted it not to play favorites, and there was no cryptographic guarantee that the auction was actually fair.

The Block Assembly Marketplace (BAM) is Jito's answer. Announced in July 2025 and rolled out on Solana mainnet on September 25, 2025, BAM is the most significant architectural change to Solana's block production since Jito itself.

The mechanics:

• Builders in TEEs. BAM introduces a network of off-chain "BAM nodes"—block builders—that run inside Trusted Execution Environments (TEEs). The TEE provides hardware-enforced privacy: transactions submitted to a BAM node are encrypted and remain invisible even to the node operator until execution.
• Proposer-Builder Separation on Solana. This effectively brings PBS—the dominant Ethereum architecture—to Solana, with builders (BAM nodes) decoupled from validators (proposers).
• Verifiable ordering. BAM nodes produce on-chain attestations of how they ordered transactions, making the sequencing process publicly auditable. Combined with the TEE privacy, this is the "private, transparent, verifiable" framing Jito uses for it.
• Application-Controlled Execution (ACE). A plugin framework allows protocols to deploy custom logic at the block-building layer—native slippage protection that runs at sequencing time, programmable order types, protocol-level guards against toxic MEV like sandwich attacks.

Jito co-founder Lucas Bruder estimated BAM could add $15M in annual revenue on top of the $4.7M earned in Q3 2025. In September 2025 JTO holders voted unanimously to direct 100% of protocol fees from both the Block Engine and BAM to the Jito DAO treasury—a structural realignment that put real value flow behind the architectural change.

BAM is still expanding. Initial BAM nodes were operated by Jito Labs; the published roadmap targets 50–100 globally distributed third-party operators, FPGA-accelerated builders for sub-slot latency, and full open-sourcing of the BAM node software. Validator onboarding through 2026 targets 30%+ of total stake, with full coverage as the longer-term goal.

The strategic point: BAM is not replacing bundles or the Block Engine. It is adding a new programmable, privacy-preserving layer on top of them. Protocols can opt in to BAM-mediated execution for the strategies that need it (large institutional flows, regulated trading, latency-critical DeFi), while standard bundle submission continues to work for everything else.

The Economics in 2026

The numbers underneath all this have become institutionally significant.

The dual structure—operating both the dominant validator client and the dominant liquid staking token—is what makes Jito's position so structural. JitoSOL holders receive MEV-boosted yields that outperform native staking. The DAO controls the protocol's economic levers. The Block Engine determines whose bundles win. ShredStream gates how quickly downstream systems see chain state. Each of these is independently valuable; together they form a stack that competing infrastructure has to compete against in multiple dimensions at once.

Competition and What's Next

The dominance is real, but the field isn't empty. Through late 2025 and into 2026 a handful of alternative submission paths have grown into credible options.

• Astralane—an alternative Solana block relay, increasingly used as a parallel submission path alongside Jito by serious searchers.
• QuickNode Lil-JIT—QuickNode's marketplace add-on for bundle submission, useful where Jito is congested or you want a second routing option.
• Raiku—a new entrant focused on rebuilding block-building infrastructure from scratch; raised $13.5M across pre-seed and seed rounds in September 2025, with Pantera Capital leading the latest financing.

The serious operational pattern in 2026 is not "use Jito" or "use Astralane." It is to treat transaction submission as a routing problem and fan out across Jito plus Astralane plus Lil-JIT in parallel, with raw RPC submission as a degraded fallback. Where the slot leader is, who their preferred relay is, which regional Block Engine endpoint is least congested—these change throughout the day. Production searcher infrastructure routes accordingly.

On the protocol side, the integration with Alpenglow—Solana's upcoming sub-150ms finality upgrade—is the longer-term story. Faster finality compresses the slot window further. Tighter slots make latency mismatches more lethal. Every infrastructure decision Jito and its alternatives are making right now is positioned for a world where the unit of opportunity may be 150ms instead of 400ms.

Best Practices for Searchers and Trading Operations in 2026

If you're operating on this stack, the pattern that consistently works has converged considerably. The checklist:

• Co-located, dedicated bare-metal RPC. Public RPC fails during congestion—exactly when you need it most. Co-location with validators in US East, EU, and APAC is table-stakes for competitive infrastructure.
• Yellowstone Geyser gRPC with ShredStream enabled. Read state at `processed` commitment, filtered server-side. Polling and websocket subscriptions are obsolete patterns for time-critical work.
• Multi-relay submission. Jito, Astralane, Lil-JIT in parallel. Raw RPC as fallback only.
• Dynamic tipping. Calibrate tips against rolling block telemetry. Hardcoded values from quiet hours will not land in competitive conditions.
• Always simulate before submission. simulateBundle is free. A failed bundle with a paid tip is not.
• On-chain profit assertion. Encode a revert path if realized profit falls below threshold. State drifts between detection and execution; the chain is the only honest source.
• Use jitodontfront for protection. Adding a jitodontfront-prefixed account in your bundle's first transaction prevents the Block Engine from accepting bundles that try to front-run yours.

Region-aware routing. Send to all major Block Engine regions—NY, Frankfurt, Tokyo, Amsterdam—in parallel.

What Actually Matters

Jito is not a feature on Solana. It is, by mid-2026, an operating layer that almost every meaningful interaction on the chain passes through. The Block Engine sorts who lands during congestion. ShredStream determines who sees state first. JitoSOL routes a meaningful share of all SOL staking activity. BAM is rebuilding the block-building stack to be privacy-preserving and programmable. JIP-24 has aligned all of this economic value behind a single governance layer.

If you are building or operating on Solana, the practical implication is that "use Jito" is no longer a meaningful instruction. The actual decisions are four:

1. How you submit—Jito plus alternatives, multi-relay, multi-region.
2. How you tip—dynamic, telemetry-driven, calibrated against live block conditions.
3. How you ingest data—Geyser plus ShredStream, processed commitment, server-side filtered.
4. How you run the underlying infrastructure—dedicated bare-metal, co-located, with monitoring on slot lag and landing rate.

The strategies are public. The latency profile of the stack underneath them is not. That's where the actual edge lives in 2026.

Talk to RPC Fast about the layer underneath