Not faster swaps — concurrency is per transaction, so a split order gets none of it. What it bought is a market maker who can requote fifty price levels without any of them queuing, and the result is measurable: a CLOB is now Monad's biggest venue and quotes tighter than a top-tier CEX at retail size. With a census of all 54 trading venues on the chain.
We took a snapshot of Monad on July 28, 2026, around block 91,054,000. Three things were true at once, and the gap between them is the whole story.
First: the chain is nearly empty. Twenty consecutive blocks carried an average of 10.6 million gas against a 150 million block gas limit — about 7% utilisation — and roughly 12 transactions per block. The base fee sat on its 100 MON-gwei floor the entire time. Whatever is limiting Monad today, it is not capacity.
A single block's gas capacity drawn as a bar: 150 million gas, of which an average of 10.59 million was used across twenty consecutive blocks — 7.1 percent. The base fee sat on its 100 MON-gwei floor throughout.
Second: despite that, on-chain venues on Monad now quote tighter than the best fee tiers major centralised exchanges offer anyone. Not on a testnet. On live books, at fillable size.
Third: the slowest part of a swap is no longer the chain. Our own routing engine quotes 15 protocols across 1,102 pools, and its median response was 1.41 seconds — essentially none of which is Monad. It is our own network round trips to the venues. On a 300ms chain, the router is the bottleneck.
Monad executes the transactions in a block concurrently, tracking what each one reads and writes, then merges the results in the original block order. If a transaction turns out to have read data that an earlier transaction changed, it re-executes with the corrected state. The final result is identical to running everything one-by-one, which is why the EVM's programming model survives untouched.
The reason this matters for exchanges is narrower and more interesting than "everything gets faster". The most valuable thing an exchange does constantly is let a market maker update quotes. A maker cancelling and replacing across fifty price levels is writing to fifty unrelated places in storage — none of those writes touch each other, so none of them wait in line. Monad's own research on order books leans on exactly this: makers can push thousands of cancel-and-replace transactions in parallel precisely because updates at different price ticks don't conflict.
An animated central limit order book for MON/USDC. Six ask levels sit above a spread band labelled 3.41 basis points and six bid levels below it. Depth bars flicker on a 300-millisecond cadence as the market maker cancels and replaces quotes every block, and a taker order periodically sweeps down through the three best asks, emptying them before the maker refills.
That is the mechanical reason a central limit order book is the highest-volume venue on Monad and a research curiosity almost everywhere else. It is also why oracle-priced proprietary AMMs work here — a keeper pushing fresh prices into many pools every block is, again, many writes that don't contend. And it is why MonadDb exists at all: a database rebuilt from scratch so that parallel execution never stalls waiting on a disk read.
Two side-by-side lanes, each showing a market maker updating ten price levels. On a serial chain the ten updates light up one after another, forming a queue. On Monad all ten light up together, because each price level lives in its own storage slot and none of the writes conflict.
So parallel execution matters enormously. It just matters on the maker's side of the trade, not the taker's — and that distinction is the one that gets lost.
Note: The precision that gets missed: parallel execution does not make your swap faster. Concurrency happens between whole transactions, never inside one. Splitting a single order across four venues in one transaction gets zero parallel speedup — those four calls run one after another, exactly as they would on Ethereum. What makes your swap feel fast is the 300ms block, not the parallelism.
Two more consequences follow. Multi-hop routes can never be parallelised, because the second hop's input is the first hop's output. And a single extremely popular pool is actually a serial hot spot even on a parallel chain: two swaps in the same pool conflict, so one of them re-executes. The dividend goes to breadth — many markets moving independently — not to depth in any one of them, which is another way of saying this layer rewards order books and punishes monoliths.
Three transactions execute at the same time. Transaction 2 reads a pool that transaction 1 writes, so when results are merged in block order its inputs are stale and it is rejected and run a second time against committed state. Transactions 1 and 3 touch different pools and commit on the first attempt. A label notes that no transaction is ever executed more than twice.
“Parallel EVM” now describes at least four incompatible designs, and the differences are not cosmetic — they decide what a trading application is allowed to do inside a single transaction. That turns out to matter more to a router than raw throughput does.
Monad belongs to the second family. Four things separate it from the rest of that family — and, tellingly, only the first of them lives in the execution engine at all.
A comparison table of parallel execution designs. Solana and Sui require transactions to declare state upfront and never speculate. Aptos, Polygon, BNB Chain and Sei run optimistically and may re-execute a transaction several times. All of them execute inside the consensus critical path. Monad declares nothing, bounds re-execution at two runs per transaction, and is the only design that runs execution outside the consensus path.
All four designs share one weakness, and it is worth knowing because it shapes which venues win. A single very popular pool degrades every one of them: declare-upfront chains serialise everybody who named it, optimistic chains burn re-execution on it, hint-based chains put it back in a queue on purpose. No scheduler can fix a shared counter that everyone writes to. Which is the same conclusion from the other direction — on any parallel chain, the venues that come out ahead are the ones whose state is naturally spread out. An order book with independent price levels is exactly that shape. A single monolithic pool is exactly not.
Parallel execution only pays out if the rest of the chain can keep up with it. Three other pieces of the stack are what make that dividend collectable, and each removes a specific, decades-old constraint on how an exchange can work.
Two timelines drawn to scale. On Ethereum, execution must happen inside the consensus slot, so it occupies roughly 100 milliseconds of a 12-second slot — a sliver about one percent of the bar. On Monad, consensus and execution run as two separate lanes: consensus agrees on block ordering while execution of the previous block runs alongside it, filling the entire block interval.
There is a fourth item, and it is the least popular design decision in the stack: Monad charges you for the gas limit you set, not the gas you actually use, with no refunds. That exists because leaders build blocks before executing them — if you were charged for usage, you could reserve enormous block space and pay almost nothing for it. For a router this is a hard constraint: every basis point you save a user by splitting a trade cleverly, you can hand straight back by padding the gas limit.
The five layers of Monad's stack with what each one buys a trading venue. MonadBFT gives a 300 millisecond requote cycle. RaptorCast makes the block time real globally. Deferred execution gives roughly 120 times the execution budget, making an order book affordable. Parallel execution lets fifty price-level updates run without contending. MonadDb and MIP-8 price a book walk per 4-kilobyte page rather than per storage slot.
The honest test of whether any of this is real is to put on-chain quotes next to centralised-exchange taker quotes for the same trade size, at the same moment. Here is that comparison for MON/USDC, measured at block 91,054,481, quoted as total spread in basis points (lower is better):
A bar chart of total spread in basis points for a one-thousand-dollar MON/USDC trade, lower is better. Hanji's on-chain order book is 3.41, LFJ POE 7.53, Metric 10.36, Uniswap V4 14.97, and Bybit's Supreme VIP tier — the best fee tier that exchange offers — is 21.22. Every on-chain venue shown is tighter than the centralised reference.
On ETH/USDC the same pattern holds against Binance's VIP9 tier: Hanji quoted 2.11 bps at $100 and $1,000 where Binance was at 4.55, and stayed ahead at $10,000. Binance only pulls back in front at $100,000, where its 4.77 bps beats everything on-chain. Depth, not speed, is the gap that remains.
The third number in each row is the one worth staring at. Uniswap V4 is competitive at $100 and catastrophic at $100,000 — 512.96 bps, a fifty-fold degradation. That is not a criticism of V4; it is the mechanical signature of a passive curve competing against venues that requote every 300 milliseconds. It is also the entire economic case for routing: the venue that is best at $1,000 is very often not the venue that is best at $100,000, and on this chain the gap between them spans two orders of magnitude.
A line chart of spread in basis points against trade size, on a logarithmic scale. Hanji, LFJ POE and Metric stay in single or low double digits from one hundred to one hundred thousand dollars. Bybit's VIP tier rises from 17.7 to 76 basis points. Uniswap V4 starts competitive at 10.5 and degrades to 513 basis points at one hundred thousand dollars, a fifty-fold blow-out that no other venue shows.
There are 54 DEX volume adapters on Monad. Thirty-four have recorded a dollar of volume; twenty never have. Total DEX volume was $1.23 billion over 30 days, and the top three venues account for 63.9% of it. Sorted by market structure rather than by brand, the chain looks like this.
A ranked bar chart of thirty-day volume on Monad by market-structure family. Programmable singletons lead with 380 million dollars, central limit order books follow at 355 million, concentrated liquidity 224 million, oracle and proprietary AMMs 119 million, discretised bins 59 million, yield-token AMMs 58 million, stable invariants 30 million, bonding curves 3.5 million and constant-product pools under one million. Order books and prop AMMs — the two families Monad's architecture made viable — together account for 38.6 percent.
Adjacent to spot, the perpetuals venues compete for the same market-maker capital: Perpl ($6.5M TVL) is, by fees collected, the single highest-revenue protocol on the whole chain, followed by LeverUp, Monday Trade Perps, OBSDN, Pingu, Bean and Narwhal.
And on the demand side, aggregators routed $207.3M over 30 days — 16.8% of all DEX volume. KyberSwap leads with $115.45M, then 0x at $61.03M, then a long tail: Kuru's own aggregator, Dirol, fly.trade, Monorail, Enso, De1, LI.FI and a dozen wallet-embedded routers. NullTerminal has no DefiLlama adapter, so our volume isn't in that number.
First, the volume leaderboard is not the venue list. Atlantis and nad.fun's V2 DEX both have real, routable liquidity and no volume adapter on DefiLlama. Any router built by reading a leaderboard misses both — and for graduated V2 memecoins, nad.fun's DEX is the primary market.
Second, gas is not a market force here. Total fees paid to the Monad chain over 30 days came to $206,001, against $1.23 billion of DEX volume — roughly 1.7 basis points of notional, spread across every transaction on the network. Optimising a route to save gas rather than to improve output is, on this chain, simply an error.
We quote 15 protocols across 1,102 pools on every request, and building that taught us a few things that aren't in anyone's documentation.
Monad is usually explained as a parallel EVM, and that explanation is right about the headline and wrong about the mechanism. Parallel execution did change what an exchange can be here — by buying breadth, not speed. Its payoff is that a market maker requoting fifty price levels writes to fifty places that don't contend, so a live order book stops being a queue. What it never did, and was never going to do, is make any individual swap faster.
The rest of the stack is what makes that payoff collectable. Deferred execution bought roughly 120 times the execution budget, which is what makes running a real order book affordable in the first place. MonadDb exists so parallel execution never stalls on a disk, and page-aware storage priced state the way SSDs actually read it, which is what makes walking that book cheap. MonadBFT and RaptorCast delivered 300ms blocks and 600ms finality globally, which is what makes requoting every block worth doing. And charging gas on the limit is the tax that pays for all of it. Remove any one of them and the market above doesn't happen.
Note: The result is measurable and it isn't marketing: an order book is now the highest-volume venue on Monad, a family of exchanges that barely exists anywhere else is already a tenth of the chain's volume, and at retail size an on-chain book quotes tighter than the best fee tier a major CEX will give anybody. All of it happening while the chain sits at 7% utilisation.
See also: Monad Now Runs at 300ms — and Your Swaps Feel It · The 400ms Era — the full on-chain data report · Kuru — Monad's highest-volume order book
Not directly — and that is the most common misunderstanding about Monad. Concurrency happens between whole transactions, never inside one, so splitting a single order across several venues gets no parallel speedup at all. What parallel execution does is let many independent things happen at once, and the most valuable of those is market makers requoting: a maker updating fifty price levels writes to fifty places that don't contend. That is why order books are viable on Monad, and better quotes from those venues is how it reaches you. The part that makes your swap itself feel fast is the 300ms block time and 600ms finality.
Solana and Sui require every transaction to declare upfront which accounts it will touch, so the scheduler can group the ones that don't overlap. Nothing is wasted, but nothing can adapt — a router has to name every venue it might use before it knows which one wins. Monad declares nothing: it runs everything at once, checks afterwards, and re-runs what was wrong. Aptos and Polygon do the same in principle, but with two differences that matter. Monad's documentation caps a transaction at two executions — one optimistic, at most one on commit — where Block-STM can retry several times. And Monad runs execution outside the consensus critical path entirely, so the same algorithm gets a whole block to work in rather than a sliver of one. That second difference, not the scheduler, is where the order-of-magnitude comes from.
At retail size, often yes. Measured live at block 91,054,481, Hanji's MON/USDC order book was 3.41 bps wide where Bybit's Supreme VIP tier — the best fee tier they offer — was 17.70 bps. On ETH/USDC, Hanji beat Binance VIP9. At $100,000 the centralised exchanges pull back ahead, because they still have more depth. The gap that remains is depth, not speed.
Nine families by market structure: central limit order books (Kuru, Hanji, Clober), programmable singletons (Uniswap V4, Balancer V3), concentrated-liquidity AMMs (Uniswap V3 and its forks, Capricorn, Atlantis), oracle-anchored proprietary AMMs (Metric, Mento, LFJ POE, Lunarbase), discretised-bin AMMs (LFJ Liquidity Book), stable-asset invariants (Curve, Balancer stable), constant-product x·y=k pools (Uniswap V2 and forks, nad.fun's V2 DEX), bonding-curve launchpads (nad.fun, Printr), and yield-token AMMs (Pendle). Fifty-four venues have volume adapters on the chain; the top three are 64% of the volume.
An order book only works if market makers can cancel and replace quotes constantly and cheaply. On Ethereum a maker requoting twenty price levels every block would spend more on gas than on inventory risk. Monad removes each blocker: deferred execution gives the block roughly 120 times more execution budget, updates at different price ticks don't conflict so they process in parallel, page-aware storage makes reading adjacent price levels cheap, and 300ms blocks make a requote worth sending at all.
Because leaders build blocks and validators vote on them before anything is executed. If the protocol charged for gas actually used, a transaction could set an enormous gas limit, consume almost none of it, and occupy a large share of the block for free — a denial-of-service vector. Charging the limit closes that. The practical consequence is that padding a gas limit costs the user real money, so routers on Monad have to budget gas tightly.
Sources: Parallel Execution — Monad Developer Documentation, Asynchronous (Deferred) Execution — Monad Developer Documentation, MonadBFT — Monad Developer Documentation, RaptorCast — Monad Developer Documentation, MonadDb — Monad Developer Documentation, Gas Pricing — Monad Developer Documentation, MIP-8: page-aware storage for the EVM — Monad Blog, Ideas for Next Generation CLOB DEXes — Monad Blog, Prop AMMs on Monad — mechanism-sound execution-time routing, mpamm.wtf — live proprietary-AMM spread dashboard for Monad, DefiLlama — Monad chain overview, Block-STM: Scaling Blockchain Execution by Turning Ordering Curse to a Performance Blessing (arXiv), Block-STM: How We Execute Over 160k Transactions Per Second — Aptos Labs, Road to High Performance: Parallel EVM for BNB Chain — BNB Chain Blog, How Monad Works — Monad Blog
Last reviewed 2026-07-28. More Monad research.
Monad DeFi board · Markets · Swap on NullTerminal
NullTerminal finds the best swap price on Monad by aggregating 13 DEXs — Uniswap V3/V4, PancakeSwap, Kuru, Hanji, Capricorn, LFJ, Atlantis, Balancer, Metric and nad.fun — with split routing in a single transaction and sub-400ms quotes. Free public swap API for builders. AI agents: machine-readable skill manifest at /skill.md.
NullTerminal requires JavaScript for live quotes and trading.