Summary: Intents change the on-chain user experience from “how do I execute this?” to “what result am I after?” In this post, we’ll guide decision-makers on how to create a high-quality intent solver that reliably identifies the best paths across different chains, markets, and builders. We’ll use practical architectures, standards (like ERC-7683/7521/7702/4337), and proven strategies from CoW Protocol, UniswapX, and Flashbots.

Intent Routing 101: Building a Solver That Finds the Best Path (Not the Worst One)

Decision-makers often share a common frustration: “We’ve set up intents, but the execution quality isn’t reliable.” The real distinction between a worst-path and a best-path solver isn't just in having a sleek user interface--it's all about how you model the state, craft the objective, explore the route options within deadlines, and integrate with the current auction and settlement systems.

Here’s a solid, 1600-2000-word game plan for creating an intent solver that you can confidently roll out in those 2026 budgeting cycles.

1) The 2025 intent landscape in one page

Cross‑chain intents are getting a makeover with the new ERC‑7683 brought to life by Across and Uniswap Labs. This framework is all about setting up shared order and settlement interfaces to help fillers and apps work together, rather than rehashing relayer networks. We’re already seeing it in action with projects like the Across Origin/Destination Settlers on Base and Arbitrum, which encode intents using fields such as fillDeadline, orderDataType, and orderData. Check it out here: (eips.ethereum.org).
When it comes to per-swap intents, UniswapX really stands out. It uses Dutch auctions where fillers duke it out to fulfill a user’s signed order. This setup comes with some great perks--like gas-free swaps and protection from MEV--plus it has unique auction mechanics tailored for each chain. More details can be found here: (docs.uniswap.org).
Now let’s talk about batched intents. The CoW Protocol bundles orders into batch auctions, featuring a competitive pool of solvers. Their Fair Combinatorial Batch Auctions (FCBA) ensure uniform directional clearing prices (UDCP), keep MEV at bay, and aim to maximize user surplus. Solvers are bonded and whitelisted, and they earn rewards weekly through CIP-controlled methods. For the full scoop, visit: (docs.cow.fi).
What about orderflow auctions and privacy? Flashbots MEV‑Share opens up OFA interfaces that focus on privacy, validity conditions, and builder inheritance, along with simulation endpoints. At the same time, SUAVE/BuilderNet are moving towards neutral, TEE-backed building and cross-domain orderflow. Keep an eye out for BuilderNet v1.2 launching in February 2025, which aims to simplify onboarding and boost security. Learn more here: (docs.flashbots.net).
When it comes to account capabilities and wallets, ERC‑4337 (AA) and EIP‑7702 (EOA code delegation) are game changers. They let EOAs sign intents that solvers can execute, bringing in batching, sponsorship, and privilege de-escalation--key elements for improving enterprise UX and gas abstraction. Plus, there’s ERC‑7806 (still in draft) that focuses on intent-centric smart accounts built on top of 7702. More info here: (docs.erc4337.io).
In the world of research and emerging practices, multi-objective solvers, like genetic algorithms, are showing tangible user-surplus improvements within batch-auction deadlines. New OFA designs are also incorporating “failure-cost” penalties to ensure quality in permissionless environments. Dive into the research here: (arxiv.org).
And beyond Ethereum? Anoma is paving the way with its concept of generalized intent machines, focusing on gossip, multi-party matching, and solver interfaces. This could lead to some interesting innovations like ring-trading and cross-domain settlement paradigms that Ethereum teams could gradually adopt. Check out the details: (specs.anoma.net).

Here's the deal: a best-path solver is basically an engineering system that picks the ideal venue--whether that’s a Dutch auction, a batch auction, or an OFA. It also takes care of encoding portable orders (think ERC-7683/7521), keeps your info private, and makes sure to optimize a risk-aware goal while juggling real-time constraints.

2) Define “best path” precisely (and measure it)

A worst-path router is designed to boost quoted output at all costs, but it overlooks execution risks, spills order flow, and often ends up timing out. Your solver needs to focus on maximizing a multi-objective score while keeping everything within the set constraints:

Objective vector F to maximize:
- User surplus (which is basically output minus the reference AMM price when you included it)
- Negative gas (whether it’s ETH or some tokenized gas, depending on the venue)
- Negative slippage (considering the price impact against simulated settlement)
- Negative execution risk (like the chance of a revert, failing to get included, or adversarial reordering)
Constraints:
- Stick to UDCP/UCP guidelines when you're bidding into the CoW FCBA; always make sure you’re hitting individual best prices--this is our fairness rule. (docs.cow.fi)
- Respect all signed limits, deadlines, and exclusivity windows in those ERC‑7683 orders; it's all or nothing, folks. (eips.ethereum.org)
- Keep those EBBO guarantees in check: your performance should never be worse than a direct on-chain execution. (docs.cow.fi)
- Adhere to privacy rules from MEV‑Share (like builder lists and data-sharing scope). (docs.flashbots.net)

Practical Metric Pack for Weekly Reviews:

Delivered Surplus per $1,000 Notional: p50/p95 by chain and venue
Inclusion Time: p50/p95
Failure-Adjusted Win-Rate in Auctions: (bids that actually land and pay out as promised)
Gas per Filled Leg
Slippage vs Post-Trade TWAP
Leakage Incidents: (public mempool exposure) and sandwich proximity

3) Architecture of a production solver

Think in Four Planes

When you're tackling a problem, it's super helpful to think across these four key areas:

Intent Intake: This is all about figuring out what people really want. It's the starting point where you gather the user's goals and needs.
State Modeling: Here, you take what you've learned in the first step and create a model that represents the current situation. It's like building a map of where you are right now.
Search/Optimization: Now, you dive into the nitty-gritty of finding the best solutions. This is where you explore different options and tweak them to make sure you're getting the most bang for your buck.
Submission/Settlement: Finally, you take everything you’ve worked on and put it into action. This is the stage where decisions get made, and solutions are finalized.

By keeping these four planes in mind, you can navigate complex problems with greater ease!

3.1 Intent intake

Embrace native app intents (that's your UI) along with ERC‑7521 “UserIntent” envelopes designed for smart wallets, and don't forget about those ERC‑7683 cross‑chain orders. Here’s what to keep an eye on:
- fillDeadline (that’s your strict timeout)
- orderDataType (EIP‑712 typehash for structured data)
- orderData (think tokens, amounts, chains, recipients) (eips.ethereum.org)
Venue adapters:
- UniswapX Dutch auction maker: You’ll want to decode the decay schedule and keep tabs on the filler rules for each chain. (docs.uniswap.org)
- CoW FCBA: Make sure to handle batch windowing and the solution format (that’s price vector + trade set). UDCP has to hold. (docs.cow.fi)
- MEV‑Share: Check out the OFA preferences (think privacy builders and validity conditions) along with event stream subscriptions. (docs.flashbots.net)

3.2 State modeling

Liquidity graph:
- Think of the nodes as different tokens hanging out across various domains. The edges represent all the connections, like AMMs, RFQ market makers, bridges, and those cross-chain settlement legs (you know, the ERC‑7683 “legs”).
- When it comes to edge costs, we’re talking about gas fees in the native token, fees from different pool tiers, and the price impact. For bridges, don’t forget about filler quotes and the time it takes to settle.
Gas and block dynamics:
- There’s a forecast for the EIP‑1559 base fee that targets a specific block. You’ll want to calculate the marginal inclusion fee for each venue. And if you’re bundling things together, the next-block forecast is spot on, thanks to the EIP‑1559 calculations. Check it out on GitHub.
Risk model:
- We’ve got inclusion risk based on whether the builder set is private or public, plus a glimpse at the chance of a revert from simulation deltas. Also, keep an eye on the OFA “failure-cost” exposure if you decide to use it. More details can be found on arXiv.

3.3 Search and optimization

Deterministic baseline: We’re looking at a multi-source, multi-sink shortest path using Bellman-Ford for spotting negative cycles, which helps us catch those arbitrage splits. On top of that, we’ve got a MILP in place for optimizing split ratios under EBBO and UDCP constraints.
Anytime multi-objective metaheuristics: Think NSGA-II or something similar for co-optimizing surplus, gas, slippage, and risk. We want to keep our runtime nice and snug between 0.5 and 1.0 seconds, perfect for those CoW-like deadlines. You can check out more about it here.
Cross-chain assembly:
- We need to create minimal leg sets that meet ERC-7683 requirements (meaning all legs need to execute). Select origin/destination settlers that have on-chain addresses so you can keep an eye on your operations. For more details, dive into this link.
Safety filters before submission:
- Always respect UDCP; double-check those limit prices; and make sure there are no “unfair” bundles compared to the best price for each order. You can learn about this more in the docs here.

3.4 Submission and settlement

CoW FCBA: Make sure to submit multiple solutions in each batch to boost your chances of selection. Also, double-check that your on-chain settlement aligns perfectly with the committed solution, bit-for-bit. (docs.cow.fi)
UniswapX: Stick to your filler strategy, keep an eye on auction decay windows, and don’t forget to honor gas-free fills if that’s what the chain config requires. (docs.uniswap.org)
MEV-Share/Flashbots:
- Use mev_simBundle to simulate your strategies. Lean into builder inheritance to ensure user privacy is respected, and be ready to support bundle cancellations with replacementUuid for those ever-changing market conditions. (docs.flashbots.net)

4) Example: A best‑path solver for a cross‑chain stablecoin swap

Scenario Overview

Imagine you're an enterprise treasurer and you need to get $100k USDC on Arbitrum in a hurry--specifically, within 120 seconds. Here’s how you can make that happen, all while keeping costs in check and avoiding any public mempool leaks.

Source: You’ll be funding this from USDC on Base.
Cost Limit: You want to stick to a maximum total cost of 15 bps (basis points).
Privacy: It's super important that you don’t leak any info to the public mempool.

Steps to Achieve the Goal

Select the Right Bridge: Find a reliable bridge that supports USDC transfers from Base to Arbitrum. Look for one that has a good reputation for speed and low fees.
Set up Your Wallets: Make sure your wallets on both Base and Arbitrum are ready to go. Have your USDC on Base handy so you can initiate the transfer right away.
Execute the Transfer:
- Go to the chosen bridge and enter the amount you wish to transfer (in this case, $100k USDC).
- Double-check the fees to ensure they won’t exceed your 15 bps limit.
- Initiate the transfer and keep an eye on the timing--remember, you’ve only got 120 seconds!
Monitor the Transfer: As the transaction proceeds, keep an eye on the status. Use a private monitoring tool if you have one, so you don’t accidentally expose your transaction details to the public mempool.
Confirm Receipt: Once the transfer completes, check your Arbitrum wallet to confirm that the $100k USDC has landed safely.

By following these steps, you can get your USDC on Arbitrum quickly and efficiently, all while sticking to your budget and maintaining privacy. Happy transferring!

How a Good Solver Executes:

When it comes to solving problems effectively, there are some key strategies that really make a difference. Here's a look at how the best solvers tackle challenges:

1. Understand the Problem

Before diving into solutions, it's crucial to fully grasp what the problem is all about. Take a moment to break it down and ask yourself:

What are the key issues here?
Who is affected by this problem?
What are the underlying causes?

2. Gather Information

Knowledge is power! Make sure you're armed with all the necessary info:

Research similar cases or problems.
Talk to people who might have valuable insights.
Look for data that can help clarify the situation.

3. Brainstorm Solutions

Now that you've got a handle on the problem, it's time to get creative! Jot down as many ideas as you can, no matter how out there they might seem. You can:

Use mind mapping to visualize connections.
Involve others for diverse perspectives.
Embrace “outside the box” thinking.

4. Evaluate Options

With a bunch of potential solutions in hand, it's time to sift through them. Consider factors like:

Feasibility: Can we actually implement this?
Impact: How effective will it be?
Resources: What will we need to make it happen?

5. Make a Decision

Once you've weighed the options, choose the solution that stands out. Don’t forget to trust your instincts here--sometimes, your gut can lead you in the right direction.

6. Implement the Solution

Now comes the fun part: rolling out your solution! Make sure to:

Communicate clearly with everyone involved.
Assign tasks and responsibilities.
Keep track of progress and adjust as needed.

7. Review and Reflect

After everything's in motion, take a step back and evaluate how things went. Ask yourself:

What worked well?
What didn’t go as planned?
What can we do better next time?

By following these steps, a good solver not only tackles the immediate challenge but also sets the stage for better problem-solving in the future. It’s all about learning and growing along the way!

Encode ERC‑7683 order

Create the orderData with origin as Base, destination as Arbitrum, token set to USDC, minimum output of 99,850 USDC, and the recipient being the treasury wallet. Make sure to set fillDeadline to now + 120s. (docs.across.to)

2) Venue Selection

I’d recommend going for intents-based bridging using Across Origin/Destination Settlers (it's already in production on Base/Arbitrum) instead of relying on the old school bridge + AMM setup. It’s way better due to less latency and less filler competition. Check it out here!

3) Route Construction

First up, let’s compute two potential legs: (a) a direct ERC‑7683 cross‑chain transfer using Across; and (b) a UniswapX Dutch auction route that grabs liquidity on Base and then settles using a speedy bridge.
Next, we need to check out the fillers’ quotes and gas fees: if the UniswapX filler gives you a net that’s better than Across after considering gas and decay, go for it; if not, stick with Across. (docs.uniswap.org)

4) Privacy and Inclusion

Go ahead and submit through MEV‑Share, but make sure you're only working with builders that your compliance team has given the thumbs up to. First, simulate the bundle, and then aim for the next block on Base. Don't forget to use a private transaction for the settlement leg to keep everything under wraps. Check out more details here.

5) Risk Guards

If the probability of block inclusion drops below a certain threshold (like during a gas spike), go ahead and cancel the bid and then resubmit it with a new adjusted bid using eth_cancelBundle. Check out the details in the Flashbots documentation.

6) SLA Outcome

We knocked it out of the park with our surplus report: we pulled in 100,012 USDC on Arbitrum in just 38 seconds! The total cost? A mere 9.7 bps. Plus, we had zero exposure in the public mempool since we stuck with private builders. Everything fell right into place with EBBO and fillDeadline too!

5) Avoid the 12 classic worst‑path mistakes

Going for that greedy “max output” without thinking about gas, slippage, or risk penalties.
Overlooking UDCP/UCP and fairness--these solutions often get turned away in CoW FCBA. (docs.cow.fi)
Disregarding fillDeadline/exclusivity in ERC‑7683; fillers just won't pay attention to you. (eips.ethereum.org)
Broadcasting large orders in the public mempool; you're basically asking for sandwich attacks. Better to use private builders/MEV‑Share. (docs.flashbots.net)
Skipping simulations before submitting; your revert risk goes through the roof. Check out mev_simBundle. (docs.flashbots.net)
Sticking to one venue only (like just AMMs) and ignoring OFA/auctions.
Relying on stale pool state or base‑fee estimates means you might miss those crucial inclusion windows. (github.com)
Only using a single path means you're missing out on split‑flow opportunities across different routes. (arxiv.org)
If your settlement doesn't match the committed solution, CoW will just reject your fill. (docs.cow.fi)
Not being able to cancel a bundle means you're stuck with a bad price. (docs.flashbots.net)
Not isolating chain risk; you’re left without any fallback if a destination builder set starts to go south.
Sharing order flow with unvetted builders; this can really compromise user privacy guarantees. (docs.flashbots.net)

6) Plug into standards that de‑risk integration

ERC‑7683 cross‑chain intents
- Embrace the order structures and settler interfaces from 7683 so your solver can play nice with current filler networks. Don’t forget to run some tests against Across’ production settlers on Base and Arbitrum. (eips.ethereum.org)
ERC‑7521 general intents for SC wallets
- Take advantage of a single entry point to check signatures while leaving the intent parsing to versioned handler contracts. This way, you’ll be ready for future intent templates as they roll out. (eips.ethereum.org)
EIP‑7702 + ERC‑4337
- Give EOAs the ability to “transform” into smart accounts by delegating code. This opens up options for batching, sponsorship, and privilege de-escalation--super important for enterprise custody and managing policies. (eips.ethereum.org)

Tip: Make sure your solver’s signing and validation layers can handle both ERC‑7521 “UserIntent” and ERC‑7683 “CrossChainOrder.” Then, you can convert these into a common format for your plans--think legs, constraints, and risk.

7) Best‑in‑class simulation and debugging

Pre‑inclusion simulations
- MEV‑Share: Use mev_simBundle to match bundles while targeting the previous block for a more realistic state. Check it out here.
- Flashbots: You can simulate or send bundles, and it even forecasts the base fee for the next block; just resend it for each block. More details on GitHub.
Post‑mortem tooling
- Use debug_traceCallMany with state overrides for those “what-if” scenarios; this will help you capture revert reasons and call frame traces. Learn more here.
Operational playbooks
- Set up automated bundle cancellations or replacements using replacementUuid whenever the spreads collapse or if builders change. Get the scoop here.

8) What to borrow from leading venues

UniswapX Dutch Auctions
- Quote decay helps cut down on adverse selection and speeds up execution. Make sure your solver keeps an eye on decay curves and pre-funds gasless fills whenever it's relevant. (docs.uniswap.org)
CoW FCBA
- Batch together multiple users to take advantage of coincidences in what people want. Use EBBO and UDCP to get rid of pesky toxic MEV patterns, and aim to create multiple combinatorial bids for each batch. (docs.cow.fi)
Flashbots OFA and BuilderNet
- Share your privacy and validity preferences; you can limit the builder sets if needed. Also, keep an eye on TEE-based verifiable ordering as it develops to help lessen reliance on any single builder. (docs.flashbots.net)
ERC-7683 Production Deployments
- Treat cross-chain transactions like a priority: explicitly encode each leg and choose settlers that are already up and running on your target domains. (docs.across.to)

9) Emerging practices to watch (and pilot)

We've got failure-cost penalties in OFAs that escrow bonds and hit you with penalties for solutions that are executed but unpaid or not fully delivered. This setup boosts execution quality in permissionless markets and totally aligns with your enterprise SLAs. Check it out here.
There are some pretty cool multi-objective solver stacks out there that blend deterministic baselines with evolutionary search. They come with a “never worse than baseline” guarantee and can wrap up in under a second, even when auction deadlines are looming. Dive into the details here.
Then we have the generalized intent machines from Anoma. They create these nifty gossip overlays where solvers can find multi-party matches (think ring trades) and settle on target chains. This is super useful for RFQ networks and helps with cross-ecosystem onboarding. Learn more about it here.

10) Implementation checklist (90‑day plan)

Week 1-2: Requirements and Standards

First up, let's decide on the intent formats we want to support: ERC‑7521 (for wallets) and ERC‑7683 (for cross-chain interactions). We'll go ahead and draft those internal schemas and lay out the sign/verify paths. Check out more about it here.
Next, we need to choose our venues. We’re looking at CoW FCBA, UniswapX, and MEV‑Share. Don't forget to create a list of builder sets and set those privacy defaults. You can find the details here.

Week 3-4: State, Simulation, and Gas

Implement the EIP‑1559 next-block base-fee forecast and get that gas token modeling going; let’s also wire up the Flashbots simulation. (github.com)
Add the debug_traceCallMany for digging into failure analysis with those state overrides. (chainnodes.org)

Week 5-6: Optimization Core

We’ll kick things off with baseline routing that includes negative-cycle detection combined with MILP split optimization. Don’t forget to enforce those EBBO/UDCP constraints for CoW! You can dive deeper into this here.
Next up, we’re adding a multi-objective metaheuristic (NSGA-II) that’ll work within a computing budget of 500-1000 ms, plus an anytime fallback for good measure. If you want to know more, check out the details here.

Week 7-8: Cross‑chain Legs and Settlement

Get those ERC‑7683 settlers integrated! We need to test the Across Origin/Destination addresses on Base and Arbitrum. Plus, let's whip up some SLA monitors for the fillDeadline. Check out the details here.

Week 9-10: Privacy and OFA Plumbing

We’ve got a lot going on with MEV‑Share intake, diving into privacy scopes, figuring out builder inheritance, and tackling bundle cancellations. Plus, we’re setting up private submission defaults for larger notional amounts. You can get all the details here.

Week 11-12: Guardrails and KPIs

Let’s steer clear of any solutions that don’t stack up against EBBO. We’ll need to auto-cancel any bundles that are taking a nosedive. Plus, we should roll out those dashboards for tracking surplus, failure-adjusted win-rate, gas per leg, and inclusion latency.

Compliance Note for Enterprises

Hey everyone, just a quick reminder for all enterprises out there: when you're looking to adopt EIP-7702 delegation, make sure you're using only audited delegate code. It’s super important to put in place role-based policies, like spend limits and allowlists, along with clear replay protection in signatures. For more details, check out the full spec here: EIP-7702.

11) A brief comparison: batch vs Dutch vs OFA

Batch auctions (CoW)
- These work best when you can pool together trades from different users to take advantage of matching demands and keep things fair by avoiding intra-batch ordering games. It’s all about satisfying fairness (UDCP), and the solvers usually handle some complex multi-route combos. Check it out here.
Dutch auctions (UniswapX)
- If you’re looking for quick individual trades and a gasless experience, this is the way to go. Your advantage lies in fine-tuning decay calibration and getting bids privately. Just keep in mind that meta-aggregator activity might still slice up your trades behind the scenes. More info can be found here.
OFA with privacy (MEV‑Share/BuilderNet)
- This one is a winner for those who want to set specific preferences about visibility (who sees what), secure private inclusion, and even manage refunds. Pair this with solid simulations and cancellation logic for the best results. Dive deeper here.

A best-path solver brings all three methods together and picks the best one based on the intent in real-time.

12) What success looks like

Teams that follow this blueprint usually see some pretty solid results, including:

An improvement of 20-80 basis points in effective price compared to basic AMM routing on medium-sized orders during times of volatile gas, along with reduced inclusion variance.
A drop in the number of reverts thanks to pre-inclusion simulation and cancellations.
Speedier cross-chain settlements by standardizing intents (shoutout to ERC-7683) and using production settlers whenever possible (docs.across.to).

13) How 7Block Labs can help

7Block Labs takes care of everything when it comes to intent stacks for big enterprises and high-volume startups. We handle ERC‑7683/7521 order plumbing, solver optimization engines, OFA/auction connectivity, and ensure compliance with top-notch privacy policies. First up, we kick things off with a two-week architecture sprint, and then we roll out an A/B tested solver in about 10-12 weeks, all while making sure you see those measurable surplus gains.

If you're looking for a solver that consistently chooses the best path instead of the worst, let’s go ahead and make sure to include that blueprint in your 2026 roadmap.

Sources and recommended reading

Check out the ERC‑7683 spec and production notes; it's all about what’s happening across deployments on Base and Arbitrum. You can find more info here.
Take a look at the CoW Protocol stuff like FCBA, UDCP/EBBO, and the lowdown on solver onboarding and rewards. Details are available here.
Here’s an overview of UniswapX, including their whitepaper and how Dutch auction mechanics play out. Dive into it here.
Don’t miss the Flashbots MEV‑Share docs! They cover simulations, bundle cancellations, and updates for SUAVE/BuilderNet from November 2024 to February 2025. Check it all out here.
For the nitty-gritty on ERC‑7521, EIP‑7702, and ERC‑4337, you can find documentation about intents and account capabilities here.
There's some interesting research on multi-objective solvers and how OFA failure-cost mechanisms work. Get the scoop here.
Lastly, check out the specs for the Anoma intent machine which covers generalized matching and solving. More details can be found here.