The Art of AMM

Victoria Merli

Anton Bukov, co-founder of 1inch, dives deep into why most AMMs are fundamentally inefficient — with up to 95% of liquidity sitting idle — and why “capital efficiency” is often misunderstood in DeFi. In his talk, he explains how shared liquidity, virtual balances, and the new SwapVM architecture unlock composable, multi-strategy market making where capital stays in user wallets and AMMs compete on logic, not TVL.

We’ve distilled the key ideas from his presentation — from fragmentation and locked capital to Aqua, fair vs. unfair liquidity, and why the future of AMMs looks more like programmable strategies than static pools ✨

Automated Market Makers have become one of the most recognizable primitives in Web3, yet their capital efficiency remains poorly understood. Ask ten people what “capital efficiency” means, and you’ll get ten conflicting answers: earning more fees per unit of capital, attracting more liquidity, maximizing trade participation, or minimizing idle balance time. This inconsistency is exactly what led Anton Bukov to explore a more fundamental question: where is capital actually inefficient and how can AMMs fix it?

The Hidden Problem: 95% of Liquidity Is Idle

In today’s AMMs, the majority of liquidity is idle most of the time. Across a typical year, 90–95% of liquidity in major pools does not participate in trades.

It sits inside the contract, passively shaping the price curve but not generating fees. Liquidity that never moves is liquidity that never earns.

Uniswap v2, v3, Curve, SushiSwap — all rely on the same structural limitation: LPs deposit capital, and AMMs wait for takers to come. If no takers arrive in your price range → your capital does nothing.

This is the foundational inefficiency: liquidity is locked in pools, but the market rarely touches it. Most LPs imagine their assets “working”, but in practice, they work only during rare windows of price action.

Fragmentation and Locked Capital

The second problem is deeper and more structural: AMM design inherently fragments liquidity across pools. A single LP who holds USDC, WETH and WBTC must split them across dozens of separate positions:

ETH/USDC 0.3%
ETH/USDC 1%
WBTC/ETH
WBTC/USDC
Stableswap pools
Concentrated ranges
Different fee tiers
Different price windows

Each new pool → more fragmentation → lower capital efficiency.

And then there’s the third problem: Capital is locked. Absolutely locked.

Once an LP deposits assets into an AMM, they instantly lose the ability to use them elsewhere: can't vote in governance, can't use tokens in on-chain economics, can't lend them out, cannot use them as collateral, and can't deploy them across multiple market-making strategies. The AMM does not allow liquidity to be composable.It turns active capital into isolated, passive capital. This model made sense in 2017, but limits innovation today.

The Shared Liquidity Layer: 1inch’s Core Innovation

1inch introduces a paradigm shift to solve fragmentation and locked capital: the Shared Liquidity Layer, implemented in Aqua.

The idea reverses 7 years of AMM design: Liquidity no longer lives inside AMM pools,It lives with the LP wallet itself, AMMs receive permissioned, on-demand access to this liquidity, capital becomes shareable, not siloed, LPs no longer need to split assets across dozens of pools, liquidity becomes unlocked and composable across DeFi.

Instead of each AMM fighting for its own pool of capital, they now tap into a shared reservoir.

This enables two breakthroughs:

LPs maintain full ownership and optionality.
AMMs can compete on logic and performance, not on TVL extraction.

Architecture Breakdown: Virtual Balances & the Access Controller

At the heart of Aqua is a simple but powerful model: virtual balances + Access Controller (AC).

Virtual balances represent how much of an LP’s capital an AMM can use. Unlike pooled balances, virtual balances are not physically locked; they are permissions and state references.

When an AMM executes a trade, it calls the Access Controller (AC): to pull the required amount from the LP’s real balance and push the output back to the LP after execution.

This architecture enables:

one capital base → multiple AMMs
multi-strategy execution from one wallet
no fragmentation
no isolation of assets
clear permissioning and safety boundaries

Effectively, Aqua turns liquidity into an on-chain API, not a deposit.

Multi-Strategy LP Positions and Full Capital Utilization

With virtual balances, LP capital becomes multi-purpose. Instead of deploying USDC into a single Uniswap v3 pool, an LP can simultaneously allow capital to participate in: concentrated liquidity strategies

dynamic fee strategies
multiple AMM architectures
lending/borrowing loops
leveraged market-making
hedged liquidity positions
advanced “smart” strategies created by developers

This is closer to what professional market makers do — except automated and democratized.

For the first time in AMM history, one unit of capital can work in multiple places at once, with no duplication and no fragmentation. This leads to something previously impossible: approaching 100% capital utilization.

Fair vs. Unfair Liquidity

One of the most overlooked ideas in AMM design is that not all liquidity is created equal. Anton introduces a distinction between fair and unfair liquidity and this becomes essential once liquidity is no longer locked in pools but becomes shareable across the ecosystem.

Fair liquidity is the kind that behaves like a true market-making participant. It earns because it takes on risk, provides quotes, captures spread, and responds to price movement. This is the type of liquidity that AMMs were originally meant to cultivate — liquidity that earns by genuinely facilitating trading.

Unfair liquidity is something entirely different. It emerges when structural asymmetries allow one participant to extract value without contributing to healthy price discovery. The early DeFi landscape was full of these imbalances: slow price updates, predictable routing, latency advantages, and arbitrage paths that were practically guaranteed profit for bots rather than LPs. The result is a distorted system in which LPs bear the volatility risk, while adversarial actors capture most of the economic value.

When capital becomes accessible to multiple AMMs simultaneously, competition shifts from “who can attract the most idle TVL” to “who can build the most effective strategy.” Instead of rewarding AMMs that lock liquidity inside rigid pools, the ecosystem starts rewarding those that deliver real performance and fair pricing.

This shift sets the stage for the next architectural leap: AMMs that behave more like programmable strategies than static pools.

Swap VM: A New AMM Architecture

Swap VM (SVM) — a modular instruction-based virtual machine for building AMMs.

The logic behind this is elegant. If liquidity is now shared and unlocked, AMMs no longer need to implement a full-stack architecture with deposits, withdrawals, balance accounting, settlement, invariant enforcement, and state updates. Instead, the entire AMM can be decomposed into small, reusable operations — “instructions.”

Swap VM becomes the engine that executes these instructions. Developers can mix and match them like LEGO bricks, assembling entirely new AMMs without rewriting thousands of lines of boilerplate code.

In the presentation, this concept is illustrated perfectly by the slide:

This visual shows precisely the metaphor Anton uses: modules like “Concentrate,” “Decay Spread,” “Flat Fee,” and “Swap” appear as puzzle blocks. Each one represents a single isolated behavior that can be combined with others into a full AMM logic pipeline. It reflects the idea that AMM development becomes a creative and composable process — far more accessible than the monolithic approaches used today.

To make this concrete, Anton introduces the data model behind SVM: a simple struct called SwapRegisters, containing only four integers — balances in and out, and amounts in and out. Every AMM instruction interacts only with this tiny piece of state. No token transfers. No liquidity accounting. No pool ownership.

It transforms AMM development from heavy infrastructure engineering to instruction-level composition.

Instead of interaction with full token contracts and pool logic, the AMM works only with these virtual registers. Developers write logic that modifies these values, and the VM ensures safety and composability.

This standardization unlocks something that never existed in DeFi: a marketplace of AMM instructions, where hundreds of AMMs compete not for liquidity, but for performance, pricing strategies, and expressiveness.

The Mooniswap Problem and the Gradual Price Shift Solution

Anton then circles back to one of the earliest innovations from the 1inch ecosystem: Mooniswap. The project explored the idea of spread decay — slowing down how quickly the price curve updates after each trade. The reason was simple: instant updates created predictable arbitrage opportunities, allowing bots to extract value from LPs before they could earn the spread.

In Mooniswap, the “virtual balances” would gradually converge back to the real balances over a defined time period. This delayed convergence gave LPs a larger portion of the arbitrage opportunity.

Aqua generalizes this idea elegantly. The shared liquidity model enables price behavior where: virtual balances shift immediately to reflect a new quote, real balances converge more slowly, following a decay path, arbitrage is no longer fully extractable by bots, the system behaves like a micro-auction where LPs capture more value.

Developer Empowerment

The conclusion of Anton’s talk focuses on what this new architecture means for the future of DeFi development.

With shared liquidity and Swap VM, building an AMM stops being a privilege reserved for teams with millions in TVL and deep protocol engineering expertise. Instead, anyone — from a researcher to a small team — can compose liquidity strategies, deploy new AMMs, and compete purely on algorithmic performance rather than capital capture.

The architecture removes one of the greatest barriers in the industry: you no longer need liquidity to start experimenting with AMM design. Liquidity is shared. Capital remains unlocked.Developers build strategies, not pools.

Code-Level Burden and Instruction-Level Innovation

Today, building an AMM means rebuilding the same massive foundation every time: deposit and withdrawal flows, balance accounting, settlement logic, safety checks, invariant enforcement. The swap logic — the actual “brain” of the AMM — is only a tiny piece of this iceberg. Everything beneath it is repetitive, fragile, and slows innovation.

SwapVM removes this burden entirely.

In the new model, developers work only with what truly defines an AMM: instructions that operate on a minimal data structure. If a behavior can be expressed as an instruction, it can be added to the VM without rewriting the entire protocol.

Traditional AMMs force developers to rebuild the whole stack: with SwapVM, all underlying layers disappear — leaving only swap logic.

This change unlocks a new level of flexibility. Instructions can represent anything: an NFT-gated check before execution, a one-directional limit order, a DCA mechanism, or even multiple auction types — one where the selling price decays over time, and another where the cost grows while aiming to buy a fixed amount. What used to require separate protocols now becomes a set of modular behaviors inside one unified system.

SwapVM turns AMM development from heavy engineering into strategy assembly. From rewriting infrastructure — to composing logic.

innovation no longer requires TVL, a large team, or duplicating architecture. It only requires an idea expressed as an instruction.