Intents and solvers are the two primitives rewriting how blockchain applications execute user requests in 2026. Instead of signing a transaction that dictates how a chain should move state, a user signs an intent that declares what outcome they want, and a competitive network of off-chain actors called solvers races to deliver it. This guide explains the architecture, the standards (including ERC-7683), real solver networks running today, and where this model is replacing traditional AMMs and bridges.
​

If you only take one thing from this guide: intents decouple the user's goal from the execution path, and that decoupling is why intent-based systems are winning on gas, MEV protection, and cross-chain UX. Eco's orchestration layer is one of the production systems built entirely around this primitive.
​

Every traditional Ethereum transaction is imperative. It specifies an exact contract, an exact calldata payload, and an exact gas price. If a block builder reorders it or liquidity moves, the transaction fails or gets sandwiched. Intents flip the model: the user signs a declarative message — "give me 1,000 USDC on Base in exchange for up to 1,005 USDC on Arbitrum, by block N" — and lets a cross-chain intent protocol source the fill.
​

The intent contains three things: the input constraints (what the user is giving up), the output constraints (what they must receive), and a deadline. Everything else — which AMM, which bridge, which solver — is delegated. That delegation is why intent systems routinely beat manually-routed swaps on both price and latency.
​

A solver is an off-chain actor that watches an intent mempool (or pool of signed intents), computes the cheapest path to satisfy an intent, then submits an on-chain fill. Solvers are usually run by market makers, bridge operators, or specialist firms with inventory pre-positioned across chains. The design assumption is that solvers compete, so whoever can satisfy the intent at the tightest spread wins the right to fill it and capture a small spread or a flat fee.
​

Running a solver well requires three things: cross-chain inventory, low-latency price feeds, and a settlement contract that will enforce the intent's constraints when the solver submits the fill. The first two are capex; the third is what ERC-7683 standardizes.
​

ERC-7683 is the Ethereum standard for cross-chain intents, co-authored by Uniswap and Across in 2024 and now supported by most serious cross-chain protocols. It defines a CrossChainOrder struct that any settlement contract can parse, and an ISettlementContract interface that any solver can integrate against. Before ERC-7683, every intent protocol shipped its own message format, so solvers had to write N integrations for N networks. The standard collapses that to one.
​

The struct carries the originating chain, the destination chain, the input token and amount, the output token and minimum amount, a fill deadline, and an orderData blob that carries protocol-specific hints. The key win is that a solver listening to the Across intent pool can also serve UniswapX intents or chain abstraction flows without custom code.
​

Production solver networks are now processing billions per month. The four most battle-tested are:

Emerging networks include Anoma (unified intent machine with full MPC privacy), Essential (declarative state constraints), and a growing set of chain-specific solver markets. Eco's orchestration platform sits above these — it coordinates solvers across rails so a stablecoin transfer originating on one chain can settle via whichever network is cheapest in the moment.
​

A typical intent-based swap in 2026 follows six phases:

From the user's perspective, all six steps look like one action: sign, then see the asset on the destination chain. The mechanics vanish behind the interface, which is the entire point.
​

MEV protection is the most immediate user-visible win. Because the user never broadcasts a transaction with exact swap parameters, there is no public mempool slot for a sandwich attacker to frontrun. The solver bears MEV risk (it submits the fill after prices move), but solvers price that risk into their quote, and competition keeps the spread tight.
​

Gas savings come from two sources. First, the user often pays zero gas — the solver fronts it. Second, solvers can batch many intents into one transaction or route through gas-optimized paths the user would never find manually. For stablecoin transfers this is especially powerful; see our write-up on 1:1 stablecoin swaps for a full breakdown.
​

AMMs still dominate single-chain, small-size spot trading because the constant-product curve is cheap to verify on-chain and the path is simple. Intents dominate when any of the following is true: the trade is cross-chain, the size is large enough that MEV is material, the user wants gasless execution, or the route touches multiple venues. In practice that now covers most stablecoin flows above a few hundred dollars, which is why solver networks for stablecoins are the fastest-growing segment.
​

Chain abstraction — the vision of users never picking which chain they're on — is downstream of intents. Once a user signs a goal instead of a path, the chain is just an implementation detail the solver picks. That is why every serious chain abstraction architecture is built on an intent layer underneath.
​

Orchestration platforms like Eco coordinate solvers across chains so that the intent — say, "move 10,000 USDC from Arbitrum to Base" — can be satisfied by whichever solver has the best inventory in the moment. Eco handles the routing logic so developers don't write one integration per chain per solver. See how to publish a cross-chain stablecoin intent for a concrete walkthrough.
​

ERC-4337 and ERC-7702 give every user a smart wallet that can sign and delegate arbitrarily. Combined with intents, this means a wallet can package multiple user-level goals ("swap, then bridge, then stake") into one signed object and let solvers compete on the whole sequence. That is the foundation for the 2026 wave of one-click DeFi apps. For a concrete primitive, see our explainer on cross-chain signatures for account abstraction.
​

Intents are not free lunches. Three failure modes to watch:

Robust intent protocols solve the first two with diverse solver sets and fallback paths, and the third with a mix of fast optimistic fills and slower but safer final settlement. For a side-by-side look at how the top networks compare on these dimensions, see best intent-based routing protocols.
​

If you're a developer, start by reading ERC-7683 and picking one solver network to integrate. If you're building a cross-chain app, an orchestration layer like Eco will hide the solver diversity from your frontend. If you're a user, you're already interacting with intents whenever you use CoW Swap, UniswapX, or any modern bridge — the primitive is in production right now.
​

A transaction specifies the exact execution path (which contract, which calldata, which gas). An intent specifies only the desired outcome (input, output, deadline) and lets a solver network choose the path. Intents are signed off-chain; transactions must be broadcast on-chain.
​

The solver pays on-chain gas to submit the fill and recovers it from the spread between the user's input and the price the solver sourced. The user usually sees gasless execution, though they still pay an embedded cost in the quote.
​

Yes. Any declarative goal with checkable constraints fits: bridging, limit orders, cross-chain lending, NFT mints with slippage caps. Anoma and Essential are pushing the model into general state-change markets beyond token swaps.
​

ERC-7683 is the Ethereum standard for cross-chain orders, defining a shared CrossChainOrder struct and settlement interface so solvers can serve many protocols without custom integrations. Read the full ERC-7683 spec on GitHub.
​

They are tightly linked but not identical. Intents are the signed declaration primitive; chain abstraction is the user experience where the underlying chain disappears. You need intents to do chain abstraction well, but intents can also serve single-chain use cases like UniswapX.
​