How Intent-Based DEXs Work (and What You Trust)
How Intent-Based DEXs Work (and What You Hand Off to a Solver)
The first time I swapped tokens, I felt like I was filing a tax form in a language I half understood. Pick the pool. Set the slippage. Pray nothing front-runs me.
So when I read that how intent-based DEXs work is closer to ordering food than filing paperwork, I wanted to believe it. You sign what you want, not how to get it. A network of solvers competes to fill it. That’s the pitch.
But “someone else handles it” is exactly the kind of sentence that makes me slow down. This post walks both sides: the real case for handing your trade to a solver network, the real case against it, and where I actually land after thinking it through.
What an intent-based DEX actually is
Here’s the 40-second version, the one I wish someone had given me.
An intent-based DEX lets you sign a desired outcome — “swap 1,000 USDC for the most ETH possible” — instead of a specific transaction path. Off-chain agents called solvers compete in an auction to fill that intent. The winner is the one that gives you the best price, and they’re bound to honor the price they quoted.
Compare that to the older model. On a classic automated market maker (AMM) like a basic Uniswap pool, you choose the route. You pick the pool, set the slippage tolerance, and broadcast a transaction to the public mempool. You’re not just stating the goal — you’re specifying the whole path.
This model flips that. You stop giving the kitchen a recipe. You give the kitchen your order — “make this taste good, here’s my budget” — and a room full of cooks competes to plate it.
The signed message itself is cheap. It’s an off-chain signature (usually EIP-712), so you pay no gas just to express the intent. The solver who wins pays the gas and bundles the settlement. That’s why these swaps feel “gasless” — the cost moves to whoever fills you.
If you’ve never watched where a swap settles, this is a good moment to learn to read the on-chain data behind one. The intent is off-chain, but the settlement is right there on the block explorer.
The case for handing your trade to a solver network
I’ll argue the optimistic side first, because it’s genuinely strong. There are four planks.
Better execution through competition. When you broadcast your own AMM trade, you get one route — the one you picked. In a solver competition, several solvers submit competing solutions at once, and the auction picks the one that returns the most to you. CoW Protocol’s docs describe this directly: solvers compete and the winner is the one offering users the most surplus. You’re outsourcing routing to specialists who do it all day.
Gasless, signature-based UX. You sign once. No gas estimate, no “transaction pending” anxiety, no failed swap that still costs you a fee. For someone who swaps a few times a year, removing that friction is not a small thing. I’ve abandoned more than one trade because the gas math spooked me at the last second.
Batch auctions claim to reduce MEV and sandwich attacks. This is the headline. On a normal swap, your pending transaction sits in the public mempool where anyone can see it. Bots can slot a buy in front of you and a sell behind you — a sandwich attack — and skim the difference. Ethereum’s own MEV explainer breaks down how this front-running works. An intent-based DEX routes your intent to a private solver set instead of the open mempool, so those bots can’t see your trade before it settles. The solver absorbs the MEV risk, not you. Note the verb: it claims to reduce this, and reduce is not eliminate.
Surplus returned to the user. When a solver finds a better price than quoted, several designs hand that improvement back to you rather than pocketing it. On paper, the incentives line up: solvers fight to give you more, because giving you more is how they win the auction.
There’s a fifth thing that gets less attention but matters to me. The intent model collapses a decision I used to make badly. On an AMM I had to set slippage tolerance myself — too tight and the trade failed, too loose and I left money on the table. With a signed intent, I’m stating the outcome and letting the auction sort the path. One fewer knob for me to get wrong.
That’s a real argument. If I only read that half, I’d be sold. The friction it removes is exactly the friction that used to make me close the tab.
How the big three differ under the hood
Not every intent-based DEX runs the same machine. The biggest mistake I made early was treating them as one thing. They are not.
| Mechanism | How it matches your order | The competing agent |
|---|---|---|
| CoW Protocol | Batch auction, uniform clearing price; can match opposite-direction traders peer-to-peer (Coincidence of Wants) before touching any pool | Solvers |
| UniswapX | Dutch auction — the price decays until someone takes it | Fillers |
| 1inch Fusion | Dutch auction plus RFQ desks quoting inventory | Resolvers |
CoW batches many orders together and settles them at one shared clearing price. If I want ETH and you want to sell ETH in the same batch, it can match us directly — a Coincidence of Wants — before either of us touches a liquidity pool.
UniswapX and 1inch Fusion use a different shape: a Dutch auction. The price starts favorable and decays over time until a filler or resolver decides it’s worth taking. Uniswap’s own blog explains how their Dutch auctions are meant to deliver better swaps. Same family — intent-based — different engine. Don’t conflate batch auctions with Dutch auctions; they fail and centralize in different ways.
The case against trusting an opaque solver network
Now the part the protocol pages can’t publish, because each one is selling its own engine.
You are trusting a network you can’t fully see. When you signed your own AMM trade, the route was ugly but legible — you chose it. When you sign an intent, you’ve handed routing to off-chain agents whose logic you can’t audit in real time. “A competitive market of solvers” is a comforting phrase. It’s also an assumption.
Solver competition can quietly become solver concentration. A market described as competitive can, in practice, be two or three dominant firms with the infrastructure to win most auctions. If the same handful of solvers fill the bulk of intents, the word “competition” is doing a lot of work. I don’t get to see the concentration from inside my wallet, and that’s the point.
Settlement and latency risk are real. Your intent is a promise that a solver must fulfill within a window. Between signing and settling, the market moves. Designs use bonding and slashing to keep solvers honest — they post collateral and lose it for misbehavior — but that’s a mitigation, not a guarantee. A delayed or failed fill is a different failure mode than a reverted AMM transaction, and a newer one.
Is the “surplus” real or marketing? This is the question I keep circling. “Surplus returned to users” sounds great. But unless I can verify it on-chain, against what the open market would have given me at that exact moment, it’s a number in a dashboard. The honest position is not “they’re lying.” It’s “I can’t yet check it myself, so I treat it as a claim, not a fact.”
There’s also a quieter cost the marketing skips: you lose the ability to fully reason about your own trade. On an AMM, my route was mine. I could trace it. With a delegated fill, the “why this price” lives in a solver’s logic I’ll never read. For a lot of people that’s a fine trade — convenience for legibility. But it is a trade, and naming it out loud is the whole point of a mental model.
And the deepest one: **a private solver network is a different trust assumption, not automatically a safer one.** Moving your order out of the public mempool removes the sandwich bots. It also moves you from a transparent-but-hostile environment to an opaque-but-curated one. You traded a visible risk for a less visible one. That can be a good trade. It is not a free one.
It reminds me of a habit from the office. When a vendor quote arrives looking too clean, the seasoned people on my team don’t celebrate — they ask what’s missing from the line items. The polish is the prompt to look harder, not to relax. I bring the same reflex to a quote that arrives pre-optimized by a network I can’t see.
If you want a framework for thinking about who you’re really trusting in DeFi, I wrote a longer piece on how to think about trust in DeFi — the muscle is the same here.
Where I was wrong about intent-based DEXs
For a while I believed the slogan “no more MEV.” I repeated it. Then I sat with it and realized I’d swapped one claim for another without checking either.
My first misconception: that “gasless” meant free. It doesn’t. The gas didn’t vanish — the solver pays it, and they price that cost into the quote they give me. The fee moved. It didn’t disappear. Once I saw that, “gasless” stopped reading as a discount and started reading as a UX change.
My second misconception: that a winning auction price was, by definition, the best price available anywhere. It’s the best price the participating solvers chose to surface in that auction. If the solver set is thin or the moment is quiet, “best of what showed up” and “best that existed” are not the same sentence.
The swap that taught me this was small and boring — a stablecoin-to-ETH test with money I’d be fine losing. The quote looked excellent. But I had nothing to compare it against, because I hadn’t recorded what a plain AMM route would have given me at that second. I had a number and a feeling, not a measurement. That’s the gap. Most of these inputs are stablecoins, and if you don’t know why those hold their peg, my piece on how stablecoins work is the missing context.
What I changed: I stopped accepting “you got surplus” as a result. I started asking surplus versus what, measured how, and can I see it. If I can’t answer those, I file the benefit under “plausible,” not “proven.”
Where I actually land
I don’t think the answer is “these DEXs are good” or “these DEXs are bad.” That framing is the trap.
Here’s the position I hold. The UX win is real and immediate — signing an outcome beats hand-routing a transaction, especially for someone who isn’t a developer. The MEV protection is real but conditional — it works by relocating your order, and relocation has its own costs. And the “surplus” benefit is real in design but unverified in my experience, so I treat it as a claim I’d want to check, not a feature I assume.
The mental model I keep: an intent-based DEX doesn’t remove trust from your swap. It relocates it. You stop trusting your own routing and the hostile mempool, and you start trusting a solver network and the auction that picks the winner. The smart question isn’t “is this safer?” It’s “which set of risks can I actually see — and which one am I more comfortable not seeing?”
So my rule is simple. I use the model where the UX win is worth it and the amounts are small enough that an unverifiable surplus claim doesn’t keep me up. I don’t treat a private solver network as a strict upgrade over the mempool. And I keep a plain-AMM quote handy as a sanity check, because the only way to know if “best price” was actually best is to have something to compare it against.
This horizon keeps spreading, too. Standards like ERC-7683 are pushing intents across chains, so the same trust question is about to show up in cross-chain swaps — where a solver may now be sourcing liquidity on a chain you’re not even watching. More convenience, more surface you can’t see. Same machine, bigger stage. The mental model has to scale with it: every time a layer hides more of the path from you, the right move is to ask what you can still verify, not to assume the hidden part is friendly.
FAQ
What is an intent-based DEX? An intent-based DEX lets you sign the outcome you want — like “swap 1,000 USDC for the most ETH possible” — instead of a specific transaction path. Off-chain agents called solvers then compete to figure out the best route and fill your order at the price they committed to.
What is a solver in crypto? A solver is an off-chain agent that competes to fill your signed intent at the best price. It sources liquidity from AMMs, order books, RFQ desks, its own inventory, or across chains, then submits its solution into an auction against other solvers trying to win the same order.
How does solver competition keep prices fair? Multiple solvers submit competing solutions in an auction at the same time. The one that returns the most surplus — the best price — to the user wins, and is then bound to honor the price it quoted. The competition is the mechanism meant to push execution toward fairness.
Do intent-based DEXs really reduce MEV and sandwich attacks? They route your intent to a private solver set instead of the public mempool, so front-running bots can’t see the pending trade before it settles. The solver absorbs the MEV risk rather than you. It’s framed as reducing this exposure, not eliminating it — the trust simply moves elsewhere.
What’s the difference between a batch auction and a Dutch auction? CoW Protocol batches many orders and settles them at a uniform clearing price, and can match opposite-direction traders peer-to-peer first. UniswapX and 1inch Fusion use a Dutch auction, where the price decays over time until a filler or resolver decides to take it.
What’s the difference between CoW Swap, UniswapX, and 1inch Fusion? All three are intent-based and roughly gasless, but the engines differ. CoW uses a batch auction with a uniform clearing price and Coincidence of Wants. UniswapX uses a Dutch auction with fillers. 1inch Fusion uses a Dutch auction with resolvers plus RFQ desks quoting inventory.
What are the downsides of intent-based DEXs? You rely on a solver network that can centralize into a few dominant firms, routing you can’t fully audit, and settlement or latency risk between signing and filling. There’s also the open question of whether the “surplus returned to users” is verifiable on-chain or mostly a marketing figure.
Written by seonjae — Korean office worker documenting his transition into AI systems, agents, and vibe coding — without a CS background. Shipping in public.
This is the second entry in Crypto Mental Models, the series where I translate DeFi machinery into mental models a non-developer can actually hold. Next up: a closer look at what a settlement transaction looks like on-chain — so you can stop trusting the dashboard and start reading the block.
