A cross-chain intent engine is the orchestration system that ingests a user's signed intent, runs a competitive solver auction, verifies cross-chain settlement onchain, and refunds the user if execution fails. Eco Routes, Across, CoW Protocol, and the ERC-7683 reference implementation are working examples. The intent engine sits one layer above the messaging transport (Hyperlane, CCTP, LayerZero) and one layer below the wallet or application that submits the intent.
​

The term "bridge" used to cover anything that moved value between chains. In 2026, that definition is too coarse. A bridge is path-explicit (lock-mint, burn-mint, optimistic): the user signs the route. An aggregator price-shops across bridges: the user picks the best route. An intent engine does neither. The user signs an outcome, not a route, and a network of solvers competes to deliver that outcome. The orchestration layer that brokers the auction, enforces atomicity, and handles refunds is the cross-chain intent engine.
​

A cross-chain intent engine is the software stack that turns a signed user intent into a verified onchain settlement on a different chain. It runs four sub-systems: an intent parser that validates the signed message, a solver auction that selects a filler, a settlement verifier that confirms the destination-chain fill against the source-chain commitment, and refund machinery that returns funds if the fill never lands.
​

The user-facing primitive is the intent itself: a structured, signed message specifying source asset, destination asset, recipient, deadline, and acceptable price band. The engine ingests this intent, broadcasts it (or holds it in a private mempool, depending on architecture), and exposes it to a solver network. A solver bids by either submitting a fill transaction on the destination chain or posting a competitive quote in an auction window. Once a fill lands and the cross-chain proof clears, the engine releases source-chain collateral to the winning solver. If no solver fills before the deadline, the engine refunds the user. The ERC-7683 standard, drafted by Uniswap Labs and Across Labs, formalizes the intent message shape and the settlement contract interface so that engines can interoperate.
​

Intent engines are not bridges. A bridge moves an asset along a specific path: lock on chain A, mint a wrapped representation on chain B (or its burn-and-mint inverse). The user signs the path. An aggregator (Jumper, LI.FI, Socket) ranks bridges by quoted price and routes through the cheapest one, but the user still picks among explicit paths. An intent engine inverts the model: the user signs the outcome, and the engine plus its solver network choose, fund, and verify the path. This is what the LI.FI intent post calls "outcome-based routing", and what Across documents as "intent-based bridging".
​

An intent engine works in four stages: parse, auction, settle, verify. The user signs an EIP-712 typed message specifying inputs and outputs; the engine validates and broadcasts it; solvers compete to fill on the destination chain; a cross-chain message (Hyperlane, CCTP attestation, optimistic oracle) confirms the fill back to the source; the engine releases the source-chain collateral. If no solver fills before the deadline, refund machinery returns the user's deposit.
​

Stage 1, intent parsing. The engine accepts a signed intent and validates the signature, deadline, nonce, and asset allowlist. Reference implementations follow the ERC-7683 GaslessCrossChainOrder struct: an `originSettler`, a `user`, a `nonce`, an `originChainId`, an `openDeadline`, a `fillDeadline`, an `orderDataType`, and an `orderData` blob containing the actual swap parameters. The signed message is the user's only onchain action until settlement clears.
​

Stage 2, solver auction. The engine surfaces the intent to a solver network. Solvers are professional market-makers running off-chain quote engines, onchain inventory, and bonded capital. Designs vary: Across uses a public mempool with first-fill-wins economics; CoW Protocol runs sealed-bid batch auctions every ~15 seconds with a single winner per batch; Eco Routes uses a hybrid where intents are visible to a permissioned solver set with continuous quoting. The auction's design dictates who profits from spread, how MEV is captured or refunded, and how long a user waits.
​

Stage 3, destination-chain fill. The winning solver executes the user-specified output on the destination chain. For a USDC bridge from Optimism to Base, the solver sends USDC from its own Base-side inventory to the user's recipient address. The user has the asset within seconds of the source-chain intent landing. The solver is now owed the source-chain collateral, which it cannot claim until settlement is verified.
​

Stage 4, settlement verification and refund. A cross-chain message confirms the fill happened. Designs split here: CCTP burns USDC on the source chain and attests via Circle's attestation service, then mints on the destination; Hyperlane uses interchain validator signatures; Across uses an optimistic oracle with a 2-hour challenge window backed by UMA. Once the message lands, the engine releases the solver's bond plus the user's collateral. If the deadline passes without a fill, the refund contract returns the user's deposit on the source chain. Atomic execution means the user either receives the destination asset OR retains the source asset. Never both, never neither.
​

An intent engine, a bridge, and an aggregator solve overlapping problems with different control surfaces. A bridge moves a specific asset along a specific path the user picks. An aggregator price-shops across bridges and DEXes. An intent engine inverts the model: the user signs an outcome, and a solver network competes to deliver it with verified atomic settlement and built-in refunds.
​

The differences show up in three places. First, what the user signs. A bridge signature commits to a path (lock-mint via Stargate, for example). An aggregator signature still commits to a chosen path, just one the aggregator selected. An intent signature commits only to inputs, outputs, and a deadline. Second, who absorbs failure. A bridge fail leaves the user holding a wrapped asset, a pending proof, or a customer-support ticket. An aggregator fail still leaves the user inside whichever underlying bridge it routed through. An intent engine's failure mode is a refund: the user gets the source asset back or never lost it. Third, who captures the spread. Bridges and aggregators take a fee on the user-facing quote. Intent engines run an auction in which solvers compete down to a thin spread, often denominated in basis points rather than fixed dollar fees.
​

The blurring is real. LI.FI's product is an aggregator with an intent-flavored API on top: a developer can submit an outcome to LI.FI's SDK and receive a routed quote, but the underlying execution still runs through path-explicit bridges. Squid Router and Socket sit in a similar hybrid zone. CoW Protocol started as a single-chain batch-auction DEX; its cross-chain extension is closer to a pure intent engine. Across started as an optimistic bridge and rebuilt around intents in 2023; it is now a single-protocol intent engine. The 2026 picture is a spectrum, not a binary.
​

A complete intent engine has five components: a signed-intent format (typically ERC-7683 compatible), a settlement contract on the source chain, a solver network with bonded capital, a cross-chain verification transport, and refund machinery. Some engines bundle these tightly; others compose them from external protocols. The composition determines latency, cost, and trust assumptions.
​

The intent parser ingests the signed user message, validates the signature against EIP-712 typed-data rules, checks the deadline and nonce, and enforces asset allowlists. ERC-7683 specifies two intent shapes: `GaslessCrossChainOrder` for off-chain signed orders that solvers submit, and `OnchainCrossChainOrder` for orders opened directly via a contract call. The parser is the only component every engine implements identically when ERC-7683 compatible. Open Intents Framework publishes reference parsers.
​

The solver auction is the part with the most design variation. Three patterns dominate. First-fill-wins (Across, early Eco Routes designs): solvers race to submit the destination fill, and the first valid fill wins the source collateral. Sealed-bid batch (CoW Protocol): solvers submit competing solutions every ~15 seconds, and the protocol picks the surplus-maximizing batch. Continuous quote with permissioned solvers (parts of Eco Routes): a curated solver set quotes continuously, and the engine routes each intent to the best live quote. Each pattern trades off speed, price, and MEV resistance differently.
​

The settlement verifier is the cross-chain transport that confirms a destination fill happened. Engines compose this from external messaging layers rather than building it. Eco Routes uses Hyperlane for general messaging and Circle's CCTP for USDC-native transport. Across uses an optimistic oracle backed by UMA with a 2-hour fraud-proof window. CoW's cross-chain extension uses LayerZero. Anoma's intent-native chain handles verification through its own consensus rather than a bolted-on message layer.
​

The settlement layer is the pair of source-chain and destination-chain contracts that hold collateral, release funds, and enforce refunds. ERC-7683 defines settler interfaces: `IOriginSettler` (`open`/`openFor`/`resolve`/`resolveFor`) accepts user funds on the origin chain, and `IDestinationSettler` (`fill`) records the destination fill that releases collateral to the solver after verification, and `refund()` returns funds to the user if the deadline passes. Eco Routes, Across, and UniswapX each implement variants of this interface; the standardization effort behind ERC-7683 is precisely to make these contracts portable across engines.
​

Refund machinery is what makes intent engines categorically different from bridges. If no solver fills the intent before the `fillDeadline`, the source-chain settlement contract becomes refundable by anyone (the user, a relayer, an automation bot). The user's collateral returns to their source-chain address. This is what gives intent engines their atomic execution guarantee: the user holds either the source asset or the destination asset at every point in time, never both, never neither. Bridges that lock-and-mint do not have this property. A stuck mint leaves the user holding a wrapped representation with no claim back to the underlying.
​

Five engines dominate the 2026 landscape: Eco Routes (CCTP plus Hyperlane plus a solver network, optimized for stablecoin payments), Across (single-protocol intent engine with optimistic settlement), CoW Protocol (batch-auction engine extended cross-chain), UniswapX (intent-flavored DEX execution from Uniswap Labs), and Anoma (an intent-native L1 rather than an engine bolted onto existing chains). LI.FI sits adjacent as a hybrid aggregator with an intent-flavored API.
​

Eco Routes is the worked example used through this article. It targets stablecoin-native execution across 15 chains including Ethereum, Optimism, Base, Arbitrum, HyperEVM, Plasma, Polygon, Solana, BSC, and Worldchain (per Eco documentation, March 2026). The engine supports USDC, USDT, USDC.e, oUSDT, USDT0, USDbC, and USDG. Transports are Circle's CCTP (for USDC-native paths) and Hyperlane (for general messaging across non-CCTP routes). The solver network competes via continuous quoting, with intents surfaced through the Routes API and the Routes CLI. Developer entry point is `git clone https://github.com/eco/routes-cli` followed by `pnpm dev publish --source optimism --destination base`.
​

Across Protocol ships a single-protocol intent engine with an optimistic settlement layer backed by UMA. The 2-hour challenge window keeps fills cheap (no per-message attestation cost) but adds latency for the solver to recover collateral. Across co-authored ERC-7683 with Uniswap Labs and has the longest-running solver economics dataset in production. Public TVL and volume data sit on DeFiLlama.
​

CoW Protocol originated the batch-auction model on Ethereum mainnet for DEX trades and has since extended into cross-chain via its CoW Swap product. The batch-auction design returns surplus to users when solvers find prices better than the limit quote, a property that pure first-fill engines do not preserve. CoW publishes auction data and solver leaderboards at docs.cow.fi.
​

UniswapX is Uniswap Labs' intent-based execution layer, initially launched single-chain in 2023 and extended cross-chain through the ERC-7683 standard it co-authored. UniswapX uses a Dutch-auction price decay: the quote starts above market and falls until a filler accepts it, which compresses spread without requiring sealed bids.
​

Anoma takes the most ambitious architectural position: instead of running an intent engine as a contract on existing chains, Anoma is a chain whose consensus and execution are intent-native. Users submit intents to a counterparty-discovery protocol, and the network finds matches across heterogeneous resource types. The Anoma documentation frames this as "the unification of decentralized counterparty discovery, solving, and verifiable settlement". It is the theoretical end-state several practical engines reference.
​

LI.FI is best understood as a hybrid: an aggregator that exposes an intent-style developer API. A developer can submit a high-level outcome to LI.FI's SDK and receive a routed transaction, but the underlying execution composes path-explicit bridges and DEXes. This is a legitimate and useful product category. The LI.FI team has been public about leaning into intent framing, and it sits in a different design slot from pure intent engines that run their own solver auctions and settlement contracts. deBridge, Squid Router, and Socket sit in similar hybrid territory.
​

Intent orchestration covers the lifecycle from intent submission to settlement release. Engines differ on auction mechanism (first-fill, sealed-bid, continuous quote, Dutch auction), transport (Hyperlane, CCTP, LayerZero, UMA optimistic oracle, native L1 consensus), and refund timing. The tradeoffs determine latency, cost, MEV exposure, and trust surface. Choose the engine whose orchestration matches the use case.
​

Stablecoin payments and corporate treasury movements typically prioritize fast finality with low spread and predictable refunds. Eco Routes targets this slot by combining CCTP's native USDC burn-mint with Hyperlane's general messaging for non-CCTP legs, keeping spreads in basis points and final settlement under a minute for most paths. DeFi composability, where the destination action is a swap or LP deposit rather than a simple receive, benefits from CoW's batch auction or UniswapX's Dutch auction because both extract more solver surplus back to the user. Long-tail asset bridging where neither side is a stablecoin still routes mostly through hybrid aggregators because the solver inventory cost on intent engines is dominated by stablecoin float.
​

One technical detail matters for orchestration choice: the trust surface of the verification transport. CCTP relies on Circle's attestation network, which is a centralized signer set with public addresses. Hyperlane relies on interchain validator sets that can be configured per-route. UMA's optimistic oracle relies on economic security from a 2-hour fraud-proof window and a bonded disputer set. LayerZero relies on its DVN (decentralized verifier network) configuration. There is no transport with zero trust surface; the engineering question is which trust assumption matches the use case. Eco Routes uses CCTP for USDC-native paths because USDC is already a Circle-centralized asset (the trust assumption is identical to holding USDC) and Hyperlane for everything else.
​

Intent engines deliver three benefits over bridges: atomic execution with built-in refunds, solver-competition pricing that compresses spread, and abstracted UX where the user signs an outcome instead of choosing a path. Risks include solver-set centralization, MEV capture in some auction designs, transport-layer trust assumptions (CCTP signers, Hyperlane validators, optimistic oracle disputers), and the regulatory uncertainty of bonded-capital solver networks operating across jurisdictions.
​

The benefits are concrete. Atomic execution removes the "stuck bridge" failure mode that produces most cross-chain support tickets. Solver competition compresses spread: where a path-explicit bridge might charge 5-30 basis points plus a fixed gas pass-through, intent engines on USDC routes routinely settle inside 5 basis points all-in (per public solver data from Across and CoW). Outcome-based signing means the wallet UX is a single transaction with no path selection, which matters more for non-crypto-native users than for power users.
​

The risks are also concrete. Solver networks are professional market-makers with significant bonded capital, which means the set of viable solvers is small (often single-digit per protocol). Concentration is a known risk and a known tradeoff. MEV capture varies by auction design: first-fill-wins engines leak MEV to solvers, while batch auctions and Dutch auctions return surplus to users. Transport trust matters: CCTP outages stop USDC-native intent execution; Hyperlane validator misbehavior corrupts cross-chain proofs. Regulatory uncertainty around solver economics, particularly whether bonded solvers are operating as money-services businesses, is unresolved in 2026.
​

Eco Routes implements the cross-chain intent engine model with stablecoins as the primary use case. Users sign an intent specifying source chain, source asset, destination chain, destination asset, and recipient. A permissioned solver network competes on continuous quotes. Settlement verification uses Circle's CCTP for USDC-native paths and Hyperlane for general messaging. Atomic execution and refund machinery follow the ERC-7683 settlement-contract pattern.
​

The developer surface is the Routes API and the Routes CLI. A new integration starts with `git clone https://github.com/eco/routes-cli`, then `pnpm install && pnpm build && pnpm link`, then `pnpm dev publish --source optimism --destination base` for an interactive wizard that handles chain selection, token selection, configuration, and review. The 15 supported chains as of March 2026 are Ethereum, Optimism, Base, Arbitrum, HyperEVM, Plasma, Polygon, Ronin, Unichain, Ink, Celo, Solana, Sonic, BSC, and Worldchain. Supported stablecoins are USDC, USDT, USDC.e, oUSDT, USDT0, USDbC, and USDG.
​

Eco's two live cross-chain transport components are Circle's CCTP and Hyperlane. CCTP handles USDC-native paths through Circle's burn-mint attestation. Hyperlane handles general messaging for routes that are not CCTP-eligible. These are the two transports. Nothing more should be claimed as a partnership. The solver network operates as a permissioned set with public quote data and public settlement events. For application developers building stablecoin payment flows, treasury automation, or onchain agent-to-agent settlement, Routes API is the integration path; for developers prototyping, Routes CLI is the entry point.
​

Sources and methodology. ERC-7683 specification per eips.ethereum.org (draft, co-authored by Uniswap Labs and Across Labs). Solver economics per Across documentation and CoW Protocol documentation. CCTP attestation flow per Circle developer docs. Hyperlane messaging per hyperlane.xyz. TVL and volume references pull from DeFiLlama. Stablecoin supplies as of Q1 2026 per DeFiLlama: total stablecoin market $319.7B, USDT $189.5B, USDC $78.1B. Eco supported-chain and supported-asset list per Eco documentation, March 2026. Figures refresh quarterly.
​

Continue with the rest of the cross-chain intents cluster and adjacent pillars.