Solver competition done twice: Moby Market vs CoW Protocol

CoW Protocol introduced the broader DeFi audience to the idea that you can sign a thing called an “intent” instead of a swap, hand it to a network of strangers, and have them compete to fill it. It worked. CoW solver auctions on Ethereum are one of the few execution venues that beats naive AMM routing reliably, and a meaningful share of EVM volume now flows through batch auctions because of it.

Moby Market borrows that idea and ports it to Solana with a different set of trade-offs. This post is an honest comparison from people who admire CoW’s design, run it as users, and chose to build something different.

The two systems in one paragraph each

CoW Protocol runs batch auctions on Ethereum (and now on its own settlement layer). Users sign intents off-chain; solvers compete to settle batches of intents atomically, and the protocol awards the winning solver based on objective utility (best price, surplus to users). The protocol explicitly internalises Coincidence of Wants — two intents that match each other directly settle peer-to-peer without ever touching an AMM. The solver network is large, the auction cadence is stable, and the protocol has substantial production volume.

Moby Market runs a commit-reveal solver auction on Solana. Users sign a TradingIntent with explicit type information — BestExecution, LiquidityProvision, Arbitrage { paths, min_profit }, or Custom { serialized_logic }. Solvers stake collateral, commit a sealed bid, then reveal during a solver_competition_period. Reputation is tracked on-chain and bad fills decay it permanently. Intent payloads can carry privacy requirements that constrain what the solver is allowed to observe.

Both systems try to align solver incentives with user outcomes. They do it on different chains, with different cryptographic primitives, for different sets of intent shapes.

Where the designs converge

It is worth being clear about how much these systems agree. Both reject the AMM-only fill model. Both believe MEV is an externality that should be priced into the auction. Both publish solver performance and treat it as a public scoring problem. Both let intents express constraints beyond a swap pair and amount.

The agreement matters because it narrows the comparison to genuine design choices: chain, primitive set, intent expressiveness, and the privacy model.

Where the designs diverge: chain and throughput

The most obvious difference is settlement chain. CoW Protocol started on Ethereum and now operates a dedicated settlement layer. Moby Market settles natively on Solana.

The practical implication is throughput and confirmation. Ethereum gives you slow blocks, expensive calldata, and a long tail on inclusion. Solana gives you sub-400-millisecond confirmation, cheap state mutation, and a runtime that can host hundreds of thousands of solver evaluations per minute without anyone noticing. For an intent type that needs to be priced against real-time depth across a dozen DEXs, the Solana runtime makes a measurable difference; for a small intent that only needs the next batch boundary, Ethereum is fine.

Neither chain is universally better. CoW’s longer block times actually help its batch model — coincidence-of-wants matching benefits from a slightly slower cadence because more intents accumulate per batch. Moby Market’s solver competition runs faster because Solana lets it, and the protocol can express intent types (real-time TWAP child orders, for instance) that would not be economical on Ethereum gas.

Where the designs diverge: intent expressiveness

CoW intents are predominantly “swap X for at least Y of Z by some time, with optional limit price”. The model is intentionally narrow — the surplus to users is computed against that simple objective and the solver gets paid based on how much it beats the baseline.

Moby Market intents are typed. BestExecution is the analogue of a CoW intent. LiquidityProvision { pool, range } says “deploy this capital into this pool’s price range, optimise yield”. Arbitrage { paths, min_profit } says “find a sequence of fills that nets at least this much, and you keep the surplus”. Custom { serialized_logic } is the escape hatch: a serialised constraint program that solvers can satisfy.

The cost of typed intents is complexity — solvers have to support each shape, and the protocol has to specify objective functions per type. The benefit is that desks can express requirements that a generic “best price now” intent cannot. A market-making desk that wants its capital deployed into a Phoenix range without continuous price chasing can express it directly; on CoW that becomes a series of swaps wrapped in off-chain orchestration.

Where the designs diverge: privacy

CoW intents are visible. Solvers see them; the network reasons about them. That is fine for a $5,000 swap; it becomes a problem at size, where a desk’s intent is itself information that other actors will trade against in the broader market.

Moby Market intents carry a PrivacyRequirements field. The intent can specify that the size is committed (Pedersen), that the sender is masked (stealth address), and that the solver only sees the constraints needed to compute the fill. The privacy program verifies Groth16, PLONK, STARKs, or Bulletproofs proofs depending on which trade-off matters more — proof size, verification time, or prover cost.

This is the design choice that most often determines which protocol a serious desk picks. If the intent itself is alpha, CoW’s openness becomes a leak. If the intent is just routine flow, the leak is acceptable and the benefit of CoW’s larger solver base outweighs it.

Where the designs diverge: MEV protection

Both protocols protect against MEV, but the mechanisms differ. CoW protects via batch auctions: a single solver settles the batch atomically, so there is no in-flight transaction to sandwich. The protocol guarantees that no solver can reorder or extract value beyond the auction price.

Moby Market uses commit-reveal. Solvers commit to a sealed bid in one transaction, then reveal in a later transaction within the competition window. Adversarial reordering is meaningless because the committed bid is unchangeable, and a solver who reveals a different price than they committed loses staked collateral. The same protection extends to child orders inside a TWAP — each child’s timing is randomised inside a window so the parent order’s shape is not observable from sequencing alone.

Both designs are well-defended. The CoW model is slightly more elegant because batch atomicity is conceptually simpler than commit-reveal. The Moby Market model handles a broader range of intent types where batch boundaries are not the natural unit.

Where Moby Market is clearly weaker

Moby Market is younger. CoW Protocol’s solver network is deeper, more battle-tested, and has years of public performance data. If you sign a CoW intent right now, dozens of solvers will compete for it; if you sign a Moby Market intent right now, the network is smaller and the competitive surplus is correspondingly smaller. That changes over time as the solver economics attract operators, but the gap is real today.

CoW also has a mature integrations ecosystem. Wallets natively support CoW Swap; aggregators include it; risk teams already have models for CoW exposure. Moby Market’s integration surface is the Rust workspace and a reference TypeScript client — production-grade but not yet ubiquitous.

Where Moby Market is clearly stronger

The expressiveness gap is real. A desk that needs to express a TWAP, a VWAP, a privacy-constrained intent, or a pool-range LP commitment as a first-class protocol object reaches for Moby Market because CoW does not model those primitives. The privacy surface is the other clear advantage: if amounts or addresses must be hidden on-chain, CoW’s transparent intent model does not solve the problem.

Solana throughput is a meaningful advantage for intent types that need fast iteration — a TWAP with 288 child orders over 48 hours wants cheap, fast settlement per child, and Solana gives that essentially for free. The same workload on Ethereum would be expensive enough to compress the strategy.

How to pick

If you trade on EVM, your intent fits the swap model, and the size is small enough that intent visibility is not alpha leakage: use CoW. The solver depth alone will give you the best fill.

If you need any of: Solana settlement, typed intent semantics beyond swap, on-chain privacy on amounts or addresses, or execution-algo semantics inside the protocol — use Moby Market.

Many desks will end up using both for different parts of their flow, which is fine. The protocols are designed for slightly different problems and the comparison should not be zero-sum.

What we learned writing this

Building Moby Market against CoW’s reference design forced clarity on what intent-based execution actually requires. Three things stood out. First, batch auctions are powerful but they are not the only way to align solver incentives — commit-reveal works too and unlocks faster cadences. Second, intent typing is worth its complexity cost the moment users care about execution semantics beyond “best price now”. Third, privacy as a first-class part of the intent payload is non-negotiable for institutional flow, and retrofitting it later is much harder than baking it in from the start.

CoW Protocol got many of the hard things right. Moby Market is, in part, a thank-you note written in Rust on Solana with a different set of trade-offs.