How LI.FI is solving interoperability
Comprehensive look into my team's strategy to fix crypto UX
Cross-chain UX is ass.
I spent 20 minutes yesterday trying to use a new app on a new rollup. After slogging through three different websites, two network switches, four transaction confirmations, 20 minutes and $15 in gas, I finally had my money where I wanted it.
I’m tired of putting up with this shit, and calling it the “future”.
Most people think cross-chain will always be broken, and I used to think that too. But we’ve been slowing chipping away at it as an industry, and I think we’ve finally cracked it.
I keep saying interop is solved and everyone thinks I'm an idiot.
I get it—If you're using today's tools, you'd think I'm wrong, that interoperability seems more broken than ever.
However, if you could see what I see—see what my team and other builders in the space are working on—you’d realise that we are on the path to fixing this whole damn thing.
I wanted to sit down and show you what's currently broken, and exactly how we're fixing each piece. Maybe then you'll realise I'm not full of shit.
Everything wrong with interop
Before we can claim that interop is solved, we need to define what “solving” interoperability means, and thus first need to define what is broken in the first place.
This is what cross-chain crypto UX looks like in 2025:
Multiple website interactions to use an application (e.g., depositing on Aave may entail a swap UI, bridge UI, and finally Aave’s UI)
No app with unified access to all chains (especially the newest, long-tail ones)
Fragmented view of users’ tokens on different chains
Management of different gas tokens on different chains
Everyone just tolerates this and accepts this as normal.
Meanwhile, we've been building specific products to fix every single pain point on this list:
LI.FI Core → any token to any token swap
Zaps → one user approval for any combination of onchain actions
OIF → permissionless interop support for new, long tail chains
Balance Abstraction → single account-specific view of all tokens across all chains
Gas Management → abstracting gas payment from the cross-chain experience
Let me walk you through exactly how each one works.
LI.FI Core
LI.FI has spent three years obsessing over the same problem: making any-token-to-any-token swaps actually work.
We built a bridge and DEX aggregator that finds the best route every time. 50+ chains, $30B+ in volume moved, and 300+ integrations later — we've completely solved cross-chain swapping.
Zaps
Swapping tokens was just the start. People want to deposit, vote, bid on items, tip friends — actual useful stuff.
But our users kept telling us they had to hop between different websites just to do one thing.
So we built Zaps. One click UX for any combination of actions, across any chains.
Here's how it works: we built a generic execution engine that can run any onchain action (or series of actions) you throw at it.
And then we built an abstraction layer on top of it that effectively translates user intents into executable calldata for arbitrary smart contract interactions across multiple chains. (Without the abstraction layer, you just send and execute random code which just wastes a bunch of gas).
Our system simulates the entire execution path before it gets submitted onchain. It also prevents midway failures through dynamic calldata injection (i.e., if step 2 needs data from step 1's output, we intercept it and automatically inject it as parameters for subsequent function calls).
Let’s say you want to top up your USDC position on Aave on Base, but you only have SOL on Solana. With Zaps, you sign one intent that swaps SOL to USDC, bridges to Base, gets a little bit of ETH for gas, and deposits into Aave - all in a single user action.
Zaps handles all four smart contract interactions, manages the cross-chain messaging, and bundles all token approvals into your initial signature (which wasn’t need in this example though). What used to require four different websites and multiple transactions now happens with one click.
Open Intents Framework (OIF)
Zaps only gets us part of the way to solving interop. Multi-step actions are not very useful if you can only do them for a subset of chains.
A huge blocker is that most new chains — especially the long-tail ones with the newest, coolest apps — aren't connected to anything.
Right now, every new chain launches as an island. Connecting to existing infrastructure means begging bridge teams to add support, hoping (or paying $$) that they prioritise you, and waiting months.
It's completely backwards. New chains should be able to connect to one another instantly.
That's why we're working with the Ethereum Foundation, Open Zeppelin, Across, Hyperlane and other teams on the Open Intents Framework (OIF): an open-source system that lets any chain connect to the entire ecosystem completely permissionlessly.
“Permissionless” implies that it can work in a variety of different contexts, so the technical challenge has been building something generic enough to work with different VMs, block times, verification mechanisms, etc… across hundreds of rollups — all while keeping everything flexible so that teams can customise and plug in whatever components they need.
With the OIF, any component along with Intent Value Chain can be configured and customised:
Order flow can come from wallets or UIs
Funds can be escrowed in a Resource Locked account or a custom escrow contract
Any auction can be configured
Any entity/system can be used to fill user intents (e.g., solvers, solver networks)
Any verification mechanism (i.e., oracle) can be used to verify state
Going forward, a new rollup that launches can connect to every other chain immediately, no permission required. This is how we go from hundreds of isolated chains to one unified experience.
Balance Abstraction
You've got some USDC on Arbitrum, ETH on Base, SOL and some other random shit scattered across dozens of chains.
Instead of checking five different block explorers to see what you own, you get one unified view of every token across every chain with Balance Abstraction.
Zapper, Rabby and some other wallets have done versions of this, but we've built it natively into the user experience. On Jumper, you can see your full balance across all chains, and use them as inputs for your trade.
Gas Management
Nothing is worse than landing on a new chain and realising that you can’t do shit on it because you have zero gas.
You've got your tokens bridged over, you're ready to ape, and then you're stuck because you need 0.001 ETH on some random L2.
On Jumper today, you can get a "gas drop" on the destination chain when you bridge — just enough native tokens to not be completely stranded.
For some routes, Jumper also offers gasless transactions where you pay with your input token and a third-party relayer covers the gas.
But with LI.FI Intents System launching next quarter, we're solving this completely, giving users a fully gasless cross-chain experience.
Users sign their intents off-chain using token permits, giving solvers permission to handle all the onchain execution and gas payments on the users’ behalf.
The best part is that “gas” as as a concept is entirely invisible to the end-user.
Solvers don't charge separate fees, they instead bake the gas cost directly into the spread of the quote that they give to users. This means users see one clean price for their cross-chain transaction. The solver's profit comes from the spread between what they quote you and what they actually execute at.
And now we ship
Hopefully this is my last blog post on interoperability.
I’m frankly tired of talking about how broken cross-chain UX is. I’m ready to finally fix this shit and move on with my life.
We're close. Really close.
Honestly, we don’t need any more research or any new, novel breakthrough ideas. By shipping what we’ve already designed, we will solve interop.
The Open Intents Framework launches this quarter. Zaps comes out next quarter. The gasless experience is already rolling out to users, and OIF will accelerate that once it's live.
All the pieces are finally coming together.
One year from now, I doubt we’ll see any more “cross-chain UX sucks” tweets. And two years from now, I doubt anyone will even use the terms “cross-chain” and “interoperability”.
Because when something actually works, you just stop talking about it.
