Batch Auctions & Coincidence of Wants

In lesson 3 we auctioned one intent at a time: a single trader’s “I want at least X out for my Y in,” handed to competing solvers who raced to fill it. That already moved value back to the user. But it still settled each order on its own timeline, one transaction at a time — and “one transaction at a time” is exactly the soil that ordering MEV grows in.

Batch auctions change one variable and that variable changes everything: instead of settling orders in sequence, you collect a bunch of them over a short window and settle them all at once, at the same moment, at the same price. That single move kills a whole class of MEV outright and quietly unlocks something even better — letting traders who want opposite things just trade with each other. This is the design behind CoW Protocol (CoW = Coincidence of Wants), and it’s what this lesson is about.

Hold onto that intuition — it’s the load-bearing wall of the whole design. Now let’s build it up properly.

Batch auctions: settle together, not in sequence

A batch auction collects orders over a short window (think a few seconds to a couple of minutes), freezes that set, and then clears the entire set simultaneously in a single settlement that a solver constructs. Nobody’s order executes a moment before anybody else’s — they all execute together, as one atomic event.

Contrast that with continuous (or serial) settlement, which is how a vanilla DEX swap works: each order is its own transaction, lands in its own block position, and is therefore exposed to whatever ordering games the block builder and searchers want to play around it. Earlier in the block means a better price means a target on your back.

The analogy: imagine a school currency-exchange day. In the serial version, every kid sprints to the teacher’s desk one at a time, and the sharp kids at the front of the line get the good rate while the stragglers at the back get fleeced — your position in line decides your fate. In the batch version, everybody writes their order on a slip, drops it in a box, and at the bell the teacher matches the whole box at once at a single fair rate. There is no front of the line. There is no back of the line. There is just the box.

That’s the structural difference. Everything good below flows from “there is just the box.”

The uniform clearing price

Within a batch, all trades of the same token pair settle at one price — the uniform clearing price — identical for every participant. Alice and Bob and the anonymous whale all swapping ETH for USDC in the same batch get the same number of USDC per ETH. Not “approximately the same.” The same.

Here’s why that detonates ordering MEV. The entire MEV course so far has been about extracting value from sequence — sandwiching, back-running, being first. But profit from sequence only exists if your position in the sequence changes someone’s price. In a batch, it doesn’t. If everyone clears at, say, 2,000 USDC/ETH no matter whether their slip was the first or the last pulled from the box, then there is literally no price to front-run into. The sandwich has no bread.

A quick worked intuition: suppose six traders in one batch all want to move ETH and USDC, and the batch clears at 2,000 USDC/ETH. The trader who sells 1 ETH gets 2,000 USDC. The trader who sells 50 ETH gets 100,000 USDC — the same 2,000 per unit. A searcher who somehow inserts a trade “ahead” of them gains nothing, because that 2,000 was fixed by the batch as a whole, not by who went first.

Coincidence of wants (CoWs)

Now the headline act, the thing the protocol is literally named after. A coincidence of wants is the happy situation where two traders in the same batch want opposite things: Alice wants to sell ETH for USDC, Bob wants to buy ETH with USDC. The classic economics-textbook double coincidence — and on a normal DEX it’s tragically wasted, because Alice and Bob each go swap against the pool separately, as strangers.

In a batch auction, the solver can spot that overlap and match them directly, peer-to-peer, at the uniform clearing price — Alice’s ETH goes straight to Bob, Bob’s USDC goes straight to Alice, and the AMM is never touched for the matched portion. No AMM swap means: no LP fee paid to the pool, no slippage from moving along the bonding curve, no price impact, and — crucially — nothing for a sandwicher or arbitrageur to skim, because there’s no public pool trade to skim from. Only the net residual imbalance (the part that doesn’t cancel) gets routed to on-chain liquidity.

The analogy: two neighbours, one holding euros and wanting dollars, the other holding dollars and wanting euros. They can each trudge to the airport currency kiosk and pay its spread twice — or they can just swap with each other across the fence at the honest mid-market rate and keep the kiosk’s cut in their own pockets. CoWs are the across-the-fence swap, done at protocol scale.

Let’s walk the numbers in the diagram. Alice sells 10 ETH for USDC; Bob buys 8 ETH with USDC; the batch clears at 2,000 USDC/ETH. Take the round-trip cost of routing through the pool — LP fee plus slippage plus MEV leaked — to be about 0.6% of the notional you push through it.

• AMM-only path: each order routes separately. Alice’s 10 ETH is 20,000 USDC of notional, costing about 0.6% ≈ $120; Bob’s 8 ETH is 16,000 USDC, costing ≈ $96. Total leaked ≈ $216.
• Batched path: 8 of Alice’s 10 ETH coincide with Bob’s 8 ETH and match peer-to-peer for free — no fee, no slippage, no MEV. Only the 2 ETH residual (4,000 USDC of notional) actually hits the AMM, costing ≈ $24.
• Saved by batching: $216 − $24 ≈ $192 — roughly 89% of the leakage, gone, simply because two people who wanted opposite things were allowed to trade with each other.

Solvers compete on the whole batch

Same solvers as lesson 3 — the professional fill-finders — but now their job is bigger. In CoW Protocol, each solver submits a complete settlement for the entire batch: which orders coincide and get matched peer-to-peer, what the uniform clearing price is, and how the residual is routed across on-chain liquidity. They’re not pricing one intent anymore; they’re proposing a single consistent plan for the whole box.

The protocol then picks the settlement that maximises total user surplus — the solution that gives traders, in aggregate, the most value above their limit prices — and that solver wins the right to execute it on-chain. So solver competition now operates at the batch level, and two forces push value toward users at once: the uniform price (no in-batch ordering edge to sell) and surplus maximisation (solvers literally compete to make users better off, because that’s the winning condition). The race that used to enrich searchers now enriches the people whose orders are being filled.

Costs and limits

Time to be honest, because no design is pure upside and pretending otherwise is how you get fooled.

• Batch latency. You wait for the window to close before anything settles. For a long-term swap that’s nothing; for someone who wants instant execution to the millisecond, the few-seconds wait is a real (if usually tiny) cost. You’re trading immediacy for protection.
• CoWs need offsetting demand in the same batch. A coincidence of wants requires someone wanting the opposite of you right now, in this batch. Often there isn’t enough — most flow still nets out to AMM routing. The dramatic 89%-style savings apply to the matched portion only; the residual pays normal costs.
• Solver quality and centralisation. The whole thing leans on a competitive, honest set of solvers finding the best settlement. If that solver set is thin, slow, or captured, surplus maximisation gets weaker — a real concern we’ll dig into in lesson 6.
• You still trust the infrastructure. Orders, the batch construction, the solver auction — all of it runs on operators and off-chain machinery you’re trusting to behave. Batch auctions shrink the MEV attack surface dramatically, but they don’t make trust disappear.

Recap

Where this leaves us

Batch auctions and intents are a genuine leap: they relocate MEV off the individual trader and onto a residual slice, hand the ordering edge nobody, and turn solver competition into a force that fills your order better. But notice the load-bearing word that kept reappearing in the limits section — trust. The batch, the solvers, the off-chain machinery: you’re trusting all of it to be honest and competitive.

In lesson 5 we confront that head-on with MEV-Share and SUAVE: programmable privacy that lets you reveal just enough of your order to get a good fill without handing attackers the whole thing, and the decentralised-sequencing endgame that tries to remove the trusted operator from the picture entirely. We’ve made the line fair; next we ask whether we even need a line.