Most conversations about intents start with solvers. How do we onboard more solvers? How do we lower barriers to entry? How do we make participation easier?

But that’s the wrong place to focus.

Even if many teams could become solvers in theory, in practice only a limited number will do it unless there is reliable order flow and a clear business model.

Hence, the right question to ask is about demand: where does the solver orderflow come from?

Because everything is downstream of orderflow. If there’s orderflow, solvers will show up and everything else will also take care of itself: solver competition increases, execution quality improves, pricing tightens, reliability, predictability, and speed get better.

That’s what this piece is about.

In this article, we answer what I think is the fundamental question for the intents space in 2026: where does solver orderflow actually come from? Drawing on conversations with 1,000+ enterprise customers served by LI.FI, we map where demand for execution providers, such as solvers and others, is emerging, and how solvers can position themselves to benefit from it.

Here are 3 Trends Reshaping the Solver Landscape

If you ask ten people what a solver is, you’ll probably get ten different answers.

Some mean professional market makers, that’s the closest to how I think about it. Others mean bridge relayers. Others mean searchers, MEV teams, or simply anyone running a bot that can fill an order. Many teams do solver-like work, but almost no one introduces themselves as “a solver.”

That makes the landscape harder to map. And it makes the market look smaller, and more fragmented, than it actually is.

It also makes things confusing for customers. If you don’t have a shared definition, it’s hard to know who to talk to. It’s hard to scope a relationship. It’s even harder to design around specific execution guarantees.

What’s happening in practice is this: customers know they want solver-like execution for their order flow. They want predictable outcomes, tight spreads, fast execution, and reliability. They’re clear on their use cases.

Here are the ones that come up most often in conversations around intent-based execution.

Trend one: Token issuers want control over execution

A pattern that keeps coming up is that token issuers and large custodians do not only want access to liquidity. They want control over execution.

Here is the simplest version of the use case.

A regulated custody and token services provider has clients moving the same assets across networks every day. They can see the demand patterns. They can manage inventory. They already operate secure infrastructure. So eventually they ask a straightforward question: why should a third party decide how our token moves between networks? And why should we pay for that decision in perpetuity?

Seen this way, generic solvers start to look incomplete.

Generic solvers optimize for their own capital efficiency and profit. That is not a bad thing, but it is not the same objective as an issuer or custodian. Issuers care about predictability, distribution, and controlling the user experience. They also care about the optics of execution, because the token brand is on the line.

When an organization issues a token, manages its distribution, or holds meaningful balances on behalf of clients, execution becomes part of the product - It affects spreads, settlement reliability, and in some cases even reputation.

In that context, the idea of running a solver starts to feel natural. Not because they want to compete with market makers, but because they want to internalize the execution path for their own flows.

So I expect a meaningful category of “issuer aligned solvers” to emerge. These solvers will not try to fill every possible order in the market. They will focus on the issuer’s assets and the flows that matter most. At first, that probably means stablecoins and other high volume assets. Over time, it becomes a strategic lever: if you control the solver, you can shape liquidity distribution and the quality of the routes that users experience.

Trend two: Regulated institutions need compliance

Another demand driver is compliance. Compliance keeps showing up as a hard requirement, not a nice to have.If you are a regulated institution, it is not enough that a route is cheap or fast. You also need accountability. You need to know and inform a lot of data like which entity executed the flow and what policies they follow.

Permissionless liquidity works well in open markets. But it becomes harder to rely on if you’re a regulated institution that needs clear accountability. An onchain pool doesn’t have a legal entity behind it. You can’t KYB a pool. You can analyze transaction history and trace flows, but that’s not the same as knowing who is contractually responsible for execution quality, compliance, or failures.

So a lot of institutional teams end up asking for something that sounds simple: can the execution layer be done by an identifiable entity that we can verify?

This is where solvers become uniquely useful. A solver can be a known operator. A solver can meet compliance policy requirements for institutions. A solver can be onboarded, monitored, and potentially even certified. That creates a path to “compliant liquidity” without forcing the entire market to become permissioned.

Let’s suppose the following scenario:

A large custody platform wants to support stablecoin movement for enterprise clients, but those clients have rules. They need to know who executed the swap or the bridge step. They may require certain jurisdictions, certain screening policies, or clear reporting. In a pool based model, those requirements are basically impossible to enforce. In a solver based model, you can enforce them at the execution layer.

My prediction for 2026 is that we see the rise of compliance oriented solver networks. Not every intent needs that, but for stablecoin treasury flows, enterprise payments, and regulated institutions, it becomes a default requirement and this will be a massive opportunity for solver teams to capitalise on

Trend three: Payments and commerce demand deterministic execution

The third driver is commerce and payments use-cases

Trading users are often willing to accept some variance, because they are already thinking in speculation and price discovery. Payments users are not.

In payments, you want to know that the merchant gets paid. You want the user to see one final amount. You want refunds to be predictable. You want the system to fail cleanly. Most importantly, you want the system to behave the same way every time.

That pushes you toward solver style execution. By solver style execution I mean a model where one solver or filler commits to an outcome, routes the steps, manages inventory and rebalancing, and owns failure handling. The user sees one goal, and the solver takes responsibility for getting there.

A commerce platform does not want to ask a user to bridge, then swap, then manage gas. The user just wants the outcome. This is basically the pure “intent” model: pay X, receive Y, settle fast, handle edge cases.

A solver can package all of that into a single fulfillment responsibility. If execution fails, there is a clear party responsible for recovery logic. If execution succeeds, the solver gets paid for providing certainty.

This is why I’m confident payments will be one of the strongest forces turning solvers into real infrastructure in 2026. Not because payments is a new idea, but because payments needs the solver’s strengths more than most DeFi use cases.

What Solvers Need in 2026

If solvers are going to serve issuers, regulated institutions, and commerce, they’ll need to be enterprise ready.

They’ll need reliable multichain operations. Strong monitoring. Redundancy that survives partial outages. Clean failure handling and clear reporting. They’ll need capital-efficiency tooling so they’re not forced to pre-fund inventory on every chain. And they’ll need standardized frameworks - because today’s fragmentation forces solvers to integrate one-by-one with each new intent system.

Let me underline that last point.

If every protocol invents its own intent format, the solver market stays small. Integration overhead becomes the bottleneck. But if formats converge around shared standards and frameworks, the solver market can scale. More participants can enter. Capital can move more freely. Specialization becomes possible.

To accelerate the adoption of intent-based app development and to smooth out the early friction solvers face the space needs more standardization.

That means frameworks that give developers the flexibility to customize workflows to their needs, while giving solvers a common surface area to integrate against.

The goal is simple: solvers should be able to build once and scale across intent systems, instead of doing bespoke integration work for each new protocol.

This is where the Open Intents Framework (OIF), built by LI.FI, OpenZeppelin, and the Ethereum Foundation, comes in.

The Open Intents Framework is a public, open-source starter kit for cross-chain intents. It’s described as a full-stack framework that allows intents to be deployed, discovered, and solved without needing permission.

It includes the onchain contracts and a reference solver implementation, so teams don’t have to rebuild the entire stack from scratch each time.

What I like about OIF is that it makes the “solver problem” feel more solvable. It is trying to turn solvers into something closer to standard infrastructure rather than bespoke integrations. Ethereum Foundation contributors describe OIF as modular infrastructure across the intent layers, like origination, fulfillment, settlement, and rebalancing, and they frame it as neutral infrastructure for the ecosystem.

I’m excited that at LI.FI we’re building in this direction with LI.FI Intents. LI.FI Intents is built for this world, and its codebase also serves as the foundation for the Open Intents Framework. That means there’s deep alignment in how both are designed and in the problems they’re trying to solve.

Closing Thoughts

I started writing this thinking solvers were a niche part of DeFi. After watching what different teams actually need for UX, I do not think that is true anymore.

If you’re a solver reading this, here’s what you need to take away from the article:

The next wave of order flow won’t come from random retail swaps. It will come from issuers who want control, institutions who need compliance, and commerce platforms that demand deterministic execution. These players don’t just want the best price. They want reliability, accountability, and integration into their product stack.

That changes what it means to win.

If that is the direction the market is going, then execution has to level up. Not just better pricing. Better operations. Better monitoring. Better failure handling. And less custom plumbing for every new app.

Winning in 2026 won’t be about being the fastest bot in a fragmented system. It will be about being integrated into the flows that matter. It will be about meeting compliance requirements. About being trusted with recurring, high-value order flow.

The end goal is simple. Cross-chain UX should feel boring. Click, sign, outcome. If we get execution right, everything built on top of it becomes easier.

If you position yourself correctly, you’re becoming part of the financial plumbing for cross-chain commerce.

This is the future of intents. That’s a big opportunity, and it’s there to be taken.

If you’re a solver and want to tap into order flow from LI.FI, we’re actively onboarding teams to LI.FI Intents. You can explore the onboarding resources, or reach out to me directly on Telegram: https://t.me/jemorla .