How Yield reads a pool.

Headline APR is a trap. A pool advertising 500% APR can still lose money once impermanent loss (IL) is accounted for. Studies of concentrated-liquidity positions have repeatedly found that a majority of LPs end up net-negative even after collecting every fee they earned. The APR is real. The loss that quietly eats it is just never shown next to it.

So Yield never ranks by advertised APR, never leads with it, and flags it explicitly when a pool’s yield is mostly emissions rather than fees. Every score, sort, and verdict on this site is built on one number instead:

That number can be negative. When it is, the pool is marked high-risk, not hidden. The whole point is to see the pools that look good and aren’t, as clearly as the ones that are.

Three inputs, each computed deterministically, no model involved:

• Fee APR: the durable part. Fees a liquidity provider actually earns from swap volume (DeFi Llama’s apyBase). This is the only component that counts toward net yield.
• Estimated IL: the expected cost of the pair diverging in price over a year, derived from the pair’s estimated volatility (see below).
• Emissions-decay risk: token rewards (apyReward) that can be cut at any time by the protocol. They are tracked and shown, but never added into net yield, and a pool where they dominate is flagged “tactical, not durable.”

Net yield is simply feeApr − estimatedIlPct. Nothing else is added or subtracted: no assumed compounding, no assumed re-investment of fees, no assumed exit timing.

Every net-yield number depends on one input: how volatile the pair’s price ratio is expected to be. Fetching real price history for every pool on every table render doesn’t scale for a live-ranked list, so Yield uses a fast, transparent heuristic instead of a live price feed, and labels every result an estimate because of it.

The estimate is built in two steps:

1. 1. A base volatility from token class. Stablecoins (USDC, USDT, and similar) are assigned near-zero volatility. Majors (SOL, wrapped BTC/ETH, liquid-staking tokens) get a moderate figure. Everything else (alts and memecoins) gets a higher default. Stable pairs and correlated pairs (like SOL/mSOL) are classified directly from DeFi Llama’s own stablecoin and IL-risk flags and given a low fixed volatility, since the two legs move together by design.
2. 2. Two per-pool adjustments, so pools in the same token class don’t collapse to an identical number:
   • Turnover: a pool with more daily volume relative to its TVL is read as more actively traded, which pushes the volatility estimate up logarithmically (diminishing effect at extreme turnover).
   • Depth: a thin pool (low TVL) is assumed to move further on the same order flow than a deep one, so small-TVL pools get a modest volatility multiplier.

The result is capped at a maximum annualized volatility so no pool produces an unbounded IL estimate. Two SOL/memecoin pools with different volume and TVL will get different volatility, different estimated IL, and different net yield. That variation is intentional: it’s what lets 500 pools be ranked without 500 individual price-history fetches.

A pool’s detail page can be given a real, measured volatility instead of the estimate wherever one is available; the ranking engine and the detail page share the exact same formula either way.

The IL formula itself is the standard, well-known result for a constant-product AMM (the x·y=k curve that Raydium and Orca’s classic pools use). For a price-ratio change r = P_new / P_old:

This returns a negative fraction: the loss versus simply holding the two tokens, from price divergence alone, with fees excluded. It has two convenient properties: IL(1) = 0 (no divergence, no loss), and IL(r) = IL(1/r), meaning a 2× move up and a 2× move down hurt a liquidity position equally. A 5× price divergence alone works out to roughly a 25% loss versus holding; that reference point shows up throughout the app.

The app surfaces this curve at five canonical divergence scenarios: 1.25×, 1.5×, 2×, 3×, and 5×, so the shape of the loss is visible before it’s ever reduced to one number.

For the single “estimated IL” figure used in net yield, Yield doesn’t assume one divergence scenario. It computes an expectation over every possible outcome, weighted by how likely it is. The exit price ratio is modeled as lognormal (the standard assumption for a random-walk price ratio) with the pair’s estimated annualized volatility as its spread, and the expected IL is the integral of the IL curve against that probability distribution:

That integral is evaluated numerically (Simpson’s rule, 400 steps) rather than approximated. A common shortcut, −σ²/8, is accurate for small σ but badly overstates loss once a pair is genuinely volatile, because real IL is bounded (it can’t exceed 100% no matter how far price moves) while the shortcut grows without limit. Integrating the real curve keeps volatile-pair estimates honest instead of alarmist.

Beyond the net-yield number, every pool gets a durability label and a single dominant risk, picked by fixed, deterministic thresholds, not by the model:

• IL: estimated IL exceeds the fee APR outright. The pool is losing to volatility faster than it earns; net yield is negative or close to it, and the pool is marked high-risk regardless of any other factor.
• Emissions: emissions make up more than 60% of total yield. The advertised APR is mostly a reward the protocol could cut at any time, not fee income.
• Low volume: daily volume is under 5% of TVL. Capital is parked rather than generating meaningful fees; the APR may not be earned at the rate it implies.
• Depth: TVL is under $50,000. Exiting a nontrivial position could move the price and cost real slippage on top of any IL.
• None: none of the above trip; the pool clears every threshold.

Separately, a pool is durable if emissions make up less than half its total yield, and tactical otherwise: a slightly looser threshold than the 60% emissions-risk flag above, so a pool can be labeled tactical on durability before it trips the harder emissions-dominant warning. The overall verdict chip (durable / tactical / high-risk) combines net yield, durability, and dominant risk into the single tag shown in the Explorer.

The Explorer is a sortable, filterable table of every pool Yield tracks, ranked by net yield by default, not by TVL, not by raw APR. Columns: pool, fee APR, emissions APR (flagged separately), estimated IL, estimated net yield, TVL, volume/TVL, and the verdict chip.

Filters cover DEX, minimum TVL, pair type (stable / correlated / volatile), maximum estimated IL, and a toggle to hide emissions-dependent pools outright. If you sort the table by raw APR instead of net yield, the app shows an explicit inline reminder that net yield is what actually matters. Sorting by APR is allowed, but never silently.

Clicking anywhere on a row opens the pool’s detail page; on narrow screens the table collapses into cards with the same information.

Every pool’s detail page includes an interactive simulator: drag a price-divergence slider (or pick one of the five canonical scenarios) and see, immediately, the exact IL at that divergence and what $1,000 supplied to the pool would be worth versus $1,000 simply held in the two tokens.

It also computes a breakeven: at the pool’s current fee APR, how many days of fees it would take to offset the IL at the selected divergence, assuming volume, and therefore fee income, holds steady. That’s an assumption worth naming out loud, and the app does, every time it shows the number.

For concentrated-liquidity positions, picking a price range is its own decision with its own tradeoff: a tighter range earns more fees per dollar of capital but exits the earning zone sooner if price moves, while a wider range stays in range longer for a smaller share of the fees. Yield estimates that tradeoff instead of leaving it to guesswork.

For a chosen holding horizon (24 hours, 7 days, or 30 days), the app models the pair’s exit price as lognormal around its current level, using the same estimated volatility as the rest of the engine, and computes the probability that price stays inside a given ± band around the current price. Widen or narrow the band and the estimated in-range probability moves with it: a tight band might capture an estimated 15% of expected moves, a wide one 90%+.

Yield also surfaces one suggested band explicitly: the narrowest range whose estimated in-range probability clears roughly 80%, labeled clearly as an estimate, alongside a labeled spectrum from tight to wide. This is a scenario, never an instruction: nothing on this page tells you to set any particular range, and the app never touches your position.

The numbers above are entirely deterministic. Nothing on this page so far involves a model. Turning them into one honest, specific, plain-language sentence per pool is where an LLM earns its place. That layer is called Fable 5, and it runs on Anthropic’s Claude (Haiku), called only from the server.

Fable 5 is bound by hard rules baked into its system prompt:

• It only phrases numbers the engine already computed. It never invents or estimates a new figure.
• It never predicts price direction, and it never tells you to supply, deposit, buy, or sell, or that you “should” do anything. Everything is framed as data and tradeoffs.
• It states the net picture, names the single dominant risk, and gives the tradeoff in one or two sentences. Nothing more.
• It responds in strict JSON only, which the server parses defensively (stripping stray code fences, rejecting anything that doesn’t match the expected shape) before it ever reaches the page.

Every pool is also given a distinct, deterministically-chosen “writing angle”: lead with the risk, lead with the net figure, contrast headline APR against what survives, pose the question an LP would actually ask, and others, so verdicts across different pools don’t read like the same template with the numbers swapped in. The angle for a given pool is stable (the same pool always gets the same angle), but the phrasing itself is generated fresh.

If the model is rate-limited or returns something unparseable, the request is retried with backoff rather than silently falling back to a generic canned sentence. A real, specific verdict is worth a short wait. A deterministic, engine-written fallback sentence exists only for the case where no model key is configured at all.

The Portfolio page reads your connected wallet’s current holdings (token balances and their current USD value) via Helius, entirely read-only. That much is live today: total value, SOL balance, and every fungible token held, with price and value per token where available.

What it deliberately does not do yet: show fees earned on a specific LP position, IL incurred so far, or a net-vs-hold verdict per position. Those numbers require knowing exactly which pool a position came from, on which DEX, and at what price and size you entered. Data this page doesn’t have a reliable source for yet. Rather than estimate that and risk being wrong about money you actually hold, the app says so plainly instead of guessing. That’s the same principle as everything else here: an honest “we don’t know yet” beats a confident-looking number that isn’t real.

Access to the app is gated: your connected wallet must hold at least 1,000 $YIELD. The gate is enforced on the server, not just hidden or shown in the browser: a technical user pointing a script directly at the API can’t skip it:

1. 1. The client requests a one-time, short-lived nonce from the server.
2. 2. Your wallet signs an off-chain message containing that nonce, a Sign-In-With- Solana-style signature. It moves no funds and approves no transaction; it only proves you hold the private key for the pubkey you’re claiming.
3. 3. The server verifies the signature cryptographically against the claimed pubkey.
4. 4. It checks that pubkey’s on-chain $YIELD balance and, only if the threshold is met, issues a short-lived, signed session cookie.
5. 5. Every data route (pools, verdict, portfolio) re-checks that session and re-verifies the live balance on each request, not just once at login. Sell below the threshold, and access is revoked on the very next call, not just when the session eventually expires.

A wallet with multiple token accounts for $YIELD has its balances summed for the check. If $YIELD hasn’t launched yet or no mint is configured, the gate simply has nothing to grant access to. Nobody is let in by omission.

The wallet connection is read-only. Yield reads your public key and, where relevant, your on-chain balances and positions. Nothing more.

• We never build, request, or send a transaction. To actually supply liquidity you follow a deep link to the real DEX (Raydium or Orca today; Meteora is planned once its pools are available through our data source) and sign there, on their own interface. Yield is never in the transaction path.
• We never handle private keys or seed phrases, and never ask you to paste any secret, ever.
• The only signature we ever request is the off-chain gate message described above, which is not a transaction and approves nothing on-chain.
• Anthropic and Helius API keys are used only inside server-side route handlers and are never sent to the browser.

• DeFi Llama Yields: pools, TVL, fee APR, reward APR, and volume for Solana pools on Raydium and Orca. Statistically anomalous pools that DeFi Llama itself flags as outliers are dropped before they ever reach the table.
• Helius: reading a connected wallet’s token holdings and value for the Portfolio page, and its on-chain $YIELD balance for the token gate.
• Anthropic (Claude): the Fable 5 plain-language verdict, called server-side only, on numbers the engine already computed.

Volatility and impermanent loss are computed in-house from the model described above, not fetched from a third-party price feed. See “The volatility model” for exactly how.

Worth saying plainly, in one place:

• Volatility is a fast estimate from token class, turnover, and depth, not measured from live price history. Two pools can share an estimate that a full price-history model would split apart, and vice versa.
• Expected IL assumes a lognormal, no-drift price ratio over a one-year horizon. Real markets trend, jump, and correlate in ways a single volatility number can’t fully capture.
• Net yield assumes fee income and volume stay roughly where they are now. A pool’s real future fees depend on future volume, which nothing here predicts.
• Portfolio reporting is holdings and value only today: no per-position fees-earned, IL-incurred, or net-vs-hold yet, for the reasons explained above.
• Range-scenario probabilities are the same volatility model applied to a shorter horizon. They inherit the same assumptions and the same honest uncertainty.

None of this is downplaying the numbers. It’s the opposite. Knowing exactly what a number does and doesn’t account for is the difference between an estimate you can actually use and a headline you can’t.

Yield is an information tool, not a financial advisor. Every figure here is an estimate. Past performance never guarantees future results. Providing liquidity carries real risk, including total loss. You supply liquidity yourself, on the DEX; we’re never in the transaction and never hold your funds.