Monad
#—
Monad testnet, recorded
The Ephemeral Rollup on Monad.
Run the same Solidity, at the same address, without a bridge. One signature, then every call is one round trip to the node and the user pays no gas. Diffs commit back to Monad.
Interlude session simulated
12,483actions
Monad block loading. Session 12483 actions, simulated.
10 ms blocks · ~3 ms per order · ~40 ms round trip · 0 gas after one grant · Measured 2026-09-30 →
Why it exists
A raw chain breaks the room. A server breaks the pot. Interlude keeps both true.
Raw chain
Fair, one block at a time.
305 ms
send to receipt, median
- Gas
- every write
- Who can change the result
- nobody
- Where the state lives
- Monad
- Liquidity
- on Monad
Room ✕ Pot ✓
A server
Fast, but you trust the host.
~40 ms
round trip
- Gas
- free, not a chain
- Who can change the result
- the host, quietly
- Where the state lives
- their database
- Liquidity
- off-chain
Room ✓ Pot ✕
Interlude
Fast and verifiable.
~40 ms
round trip, + node time
- Gas
- 0 after one signature
- Who can change the result
- the validator, in public, slashable
- Where the state lives
- Monad, same address
- Liquidity
- on Monad
Room ✓ Pot ✓
Room = the speed a live app needs. Pot = state nobody can quietly change.
Measured 2026-09-30, medians. Monad: a transaction’s send to receipt, 305 ms through Ankr (370 through the public RPC), at the Proposed stage; blocks are about 304 ms apart. A server and Interlude: the warm round trip, 38-42 ms. On Interlude a Tap order or a Kandle tap adds about 3 ms on the node, and the receipt is the node’s: Monad has the change at the next commit. How it was measured.
How it works
→ → → .
Four functions. The contract stays on Monad. Only marked slots move to the engine, and only while the session is open. What MagicBlock proved on Solana, native to the EVM on Monad.
01 / 04, Monad, Delegate
The owner hands a slice of storage to an allowed validator. Those slots lock. On-chain writes revert. The engine is the only writer.
delegateAll()02 / 04, Engine, Execute
The user signs one session grant, a time-limited permit for a throwaway key. After that the same bytecode answers, no popup, no user gas.
session.send(fn, args)03 / 04, Engine → Monad, Commit
The engine signs the slots that moved, the old and new values, and the transaction list. The Hub checks order and roots. It does not re-run the EVM.
hub.commit(batch, diffs, sig)04 / 04, Monad, Undelegate
Commits stop. The slots stay locked through the challenge window, the period when a lie can still be proven, with the stake reserved. Then the lock lifts: same address, post-session state.
undelegate(partition)Why trust it
The engine can try. The tape proves it, the bond pays.
You trust Interlude to run the engine. The allow-list is ours. You do not trust us to keep the state because we said so.
Committed, the public tape
Replayed, same pin, same bytes
An hour silent, anyone can close
Reserved stake
0
left in the bond after a lie
Mismatch, slashed, anyone can close
No commit for 1 h + 5 min
What is not there yet
- 01The Hub cannot re-execute. A challenge ends in a vote of the session's bench, not an on-chain EVM step. Every seat is Interlude's: on new sessions, two judge bots and a cold key, two votes of three.
- 02No automatic challenger on prod sessions: anyone can replay and challenge. No ZK. No forced inclusion of a user write onto Monad.
- 03Encrypted sessions: the engine sees live slots today.
Who it's for
Apps that need a reply faster than a block, and a pot that stays the contract.
01
High-frequency trading
An order that crosses fills inside the transaction that placed it, so the fill comes back in one round trip, with no wallet popup. Placing, cancelling or filling measured about 3 ms next to the node; the network round trip adds about 40. The book is still the contract, so after each commit every Monad protocol reads the same balances.
- ~3 ms per order
- no popup
- same liquidity
02
Real-time games
Every move is a contract call, answered in one round trip: about 40 ms, plus the move's own time on the node. Both players read the same contract, so nobody edits the score on a server. The round settles on Monad, at the same address.
- every move a contract call
- no host
- settles each round
03
Agent swarms
Each agent gets a scoped session key: which functions it can call, and until when. Thousands of actions run inside the session; only the outcome commits to Monad.
- scoped keys
- many actions
- one outcome
04
Real-money PvP
Both stakes lock in the contract before the match starts. Play runs in the session, and the pot never moves to a server. If the engine lies, anyone can replay the batch and the bond is slashed.
- pot in the contract
- replayable
- slashable
05
Live social & payments
Messages and reactions land in one round trip, with no gas per action. Balances commit back to the same address on Monad, where any wallet or protocol can read them.
- one round trip
- no gas per action
- same address
Build on it
Keep Foundry. Keep the ABI. Keep the address.
Annotate the storage that needs to be fast. gen writes the surface. ship deploys on Monad and opens a session.
~/mygame $
LIVE
Visit kandle.live
A multiplayer tap-trading app. Two players, one book. Hits land now, the pot stays the contract.
RAN ON HUB V1Pong needs fast controls. Sending every move straight to Monad was too much delay. The game was not playable. Interlude is how the logic stays in the contract, the state commits to Monad, and players do not wait for a block.
EXPLORINGBefore, the match lived on a game server, as it does in every browser shooter. It played fine. But positions, hits and kills were whatever our server said, and the only thing Monad ever saw was a score our own backend wrote. Putting the match itself on-chain was never an option: nobody signs a popup mid-fight, and nobody pays gas to die.
Teams exploring
Prototyping on Interlude now.
If the state lives in a process we run, users do not own it. Interlude is how that state stays the contract, on Monad.
Benja, Founder 
A dungeon tick cannot wait for a block, and it cannot live only on our server either. Interlude is how the fight stays the contract.
Ketama, Founder 
A trading arena has to feel live. Interlude is how that loop stays the contract.
Paul Warren, CEO Building something real-time on Monad?
Start building
Where it's going
Now is permissioned and slashable. Next is not us.
No dates. Each block is a capability, in the order it has to land.
The hard questions.
08
The state is the contract. Every batch posts a tape on Monad. Anyone can replay it. A lie can slash the bond. A server has none of the three.
No bridge. Same bytecode, same address. Other Monad contracts read the last committed slots. Liquidity does not move to a new chain. This is a session in front of Monad, not a new settlement layer.
10 ms blocks. About 3 ms next to the node for a Tap order (place, cancel or fill) or a Kandle tap. About 40 ms of network round trip, which is most of the total: timed end to end, a Tap order took about 42 ms and a Kandle tap about 40. Farther from the node, the network adds more. A session's first transaction takes longer, because the node reads that account from Monad. Measured on 2026-09-30; every figure, its sample size, percentiles and method are on the docs' Performance page.
The Hub accepts a well-formed commit without re-executing. A watcher you run can disagree. You post a challenge bond. Bisection, then the session's bench votes: on new sessions, two judge bots and a cold key, two votes of three, every seat Interlude's in v1. Fraud slashes the reserved stake. Optimistic and manual. Not ZK.
Users stop getting receipts. After an hour without a commit, plus a five-minute grace, anyone can close the session. The owner can undelegate sooner. There is no forced inclusion of a pending click onto Monad.
After a commit, yes: the committed slots were written. Between commits they see the last commit, not the live overlay. Writes to a locked slice revert on Monad until the session closes.
We do. v1 is permissioned. ship opens machines we operate. Permissionless operators are next, not live.
Inherit the session base, annotate the hot storage, run gen, guard writers while delegated, use the actor helper instead of msg.sender. Then ship. No new VM.
Play Kandle. Read the docs. Or open the repo.
Testnet is live. One signature, then every action is gasless.