Jul 2026
Everyone built a dispute game. We deleted it.
The fanciest machinery in verifiable compute exists to work around a weakness we don't have.
If you've read how Arbitrum or Cartesi or Gensyn's Verde settle a dispute, you've seen the tournament. Someone claims a computation came out one way, someone else says no, and then begins this beautiful, intricate, multi-round game: the two parties bisect the execution — you agree up to step 500,000, you disagree after, so we look at step 750,000, and so on — narrowing by halves until they're staring at one single instruction, and only that one instruction gets re-run to settle it. It's genuinely clever engineering. It's also a monument to a problem we decided not to have.
Here's the thing nobody says out loud: the bisection game is not the point of refereed delegation. The theory — this goes back to Canetti, Riva and Rothblum in 2011 — says something much simpler. Hand a computation to several servers, and as long as one of them is honest, you can get the right answer. That's the whole prize: one honest party, not a majority. The bisection tournament isn't how you win that prize. It's a workaround for a referee that's too weak to just check the work itself.
And their referees are too weak, by design. Arbitrum's referee is an Ethereum contract — it can't re-execute a real program; running the whole thing on-chain would cost a fortune and melt the network. So it can only afford to look at one instruction, which means you need the whole elaborate dance to figure out which instruction. The dispute game is the price you pay for a judge who can't read the case file. It's brilliant precisely because the constraint is brutal.
We don't have that constraint. Our referee is a full node. When there's a dispute about whether a capsule produced a certain output, the node just… runs the capsule. The whole thing. Start to finish. It costs whatever the job costs — which is nothing, because it's just running a program on a computer, the thing computers do. There's no tournament to bisect, no rounds, no narrowing, no "let's meet at step 750,000." There's a claim, a re-run, and an answer. One honest node reaches the same 1-of-N guarantee the tournaments are straining toward, by doing dramatically less.
This is the whole aesthetic, and I want to be honest about the catch, because pretending there isn't one is exactly the move we don't make. Deleting the dispute game only works if the computation is the kind a full node can actually replay: bounded, so it can't run forever; content-addressed, so everyone agrees byte-for-byte on what went in; and deterministic, so the re-run gives the same answer on your machine as mine. Those three constraints are real, and we pay for them — they're why the compute here is a locked-down capsule and not "run any program you want." But look at what the constraints buy: the single most complicated subsystem in every competing design, gone. Not optimized. Not made cheaper. Removed, because the reason for it was never there.
The best engineering isn't the cleverest machine you can build. It's noticing that the machine's whole reason for existing was a limitation you don't share, and then not building it. Everyone else made the dispute game more elegant. We asked why there was a game at all.
A strong enough judge doesn't need a trial. It just re-reads the evidence.