DEV Community: Sergey Sereda

How to Use Krystal's Auto-Farm Vaults: A Practical Guide

Sergey Sereda — Tue, 15 Sep 2026 21:13:56 +0000

Krystal's Auto-Farm isn't a single feature. It's a vault, an AI agent, a permissions system, and an instruction language — and most users either skip the configuration or use the defaults without understanding what they're getting. This guide walks through what each piece does and how to actually set it up for real returns.

Auto-Farm is the highest-level product Krystal offers. It looks like one click: choose a risk level, pick a target return, click "Create." Then an AI agent takes over your LP positions 24/7. The reality is more layered. Behind that single click is a vault, an agent, a permissions toggle, a scope guardrail, a free-form instruction block, and an execution config that controls slippage, gas, and timing.

If you don't understand those layers, the defaults will run your money in ways you didn't intend.

What an Auto-Farm Vault Actually Is

Krystal's product stack is nested (per docs/products/vaults/vault-vs-strategy.md):

Liquidity Position — «a single position on a DEX (e.g., Uniswap V3), typically represented by an NFT issued by the protocol.» One range, one pair, your wallet holds the NFT.
Liquidity Strategy — «a managed approach to a specific trading pair, composed of one or a series of positions that are periodically rebalanced. Strategies could include automation tools like auto-rebalance, auto-exit, and fee compounding.» Still your positions, but Krystal automates the lifecycle.
Liquidity Vault — «can hold multiple Liquidity Strategies across different pools and tokens. This allows users to build and share more customized, advanced strategies under a single, smart-contract-governed framework.»
Auto-Farm Vault — a Liquidity Vault plus an AI agent that selects pools, deploys capital, and manages positions end-to-end (per docs/products/vaults/auto-farm.md).

Two products exist in this layer: Auto-Farm Vaults (Krystal-managed AI agent) and Community Vaults (user-created, with a performance fee paid to the vault owner). They use the same vault framework but different operators. Auto-Farm Vaults are owned by Krystal's AI; Community Vaults are owned by whoever created them, and you pay them a fee on top of Krystal's fee.

The crucial fee detail (per docs.krystal.app/ecosystem/fees.md): inside an Auto-Farm Vault, «No additional fees for automation, zap, or rebalance within a VAULT» — only the vault's 10% performance fee on generated rewards applies. Compound, harvest, rebalance, and exit inside the vault are all free. So a pool showing 50% gross APR nets you about 45% after Krystal's cut.

How the Agent Runs

The Auto-Farm AI agent (per docs/products/vaults/auto-farm/agent-interface.md) works on an event-driven 24/7 loop, not on a fixed timer. Each evaluation cycle it does four things:

Reads your full Instructions text.
Reads vault state — TVL, idle balance, active positions, pending fees, gas.
Reads market state per candidate pool — TVL, 24h volume, APR (24h and 7d), volatility, fee tier.
Matches conditions, decides an action plan, executes it.

You can monitor the agent through four tabs in the interface:

Agent Overview — «What is the agent doing right now?» Status, goal, what it's managing, next run.
Chat — «How can I interact with the agent using natural language?» Ask it questions about your vault, request actions, get explanations.
Action Logs — «What actions were attempted and what were the outcomes?» Every plan the agent tried, with success/partial/failed status.
Terminal — «How did the agent arrive at its decisions?» The raw decision prompt, inputs, and assumptions the agent used.

The Chat and Terminal tabs are where the agent stops being a black box. Chat lets you iterate without leaving the UI; Terminal shows you exactly what the agent saw before it acted.

The Four Layers of Configuration

Auto-Farm Config (per docs/products/vaults/auto-farm/manage-an-auto-farm-vault.md) splits into four sections that map cleanly to what the agent is allowed and instructed to do.

Permissions — What the Agent Can Do

Six actions are available, mapped from user-facing names to internal action keys:

Add Liquidity → swap_and_mint (open a new LP position)
Remove Liquidity → withdraw_and_swap (close a position, convert to base currency)
Increase Liquidity → swap_and_increase (add funds to an existing position)
Rebalance → adjust_range (move the range on the current position)
Compound → compound (reinvest fees back into the position)
Harvest → harvest (collect fees, optionally convert to base currency)

These six are the agent's entire vocabulary. Any custom logic must use combinations of these six. There is no "swap to USDC and exit" action separate from withdraw_and_swap. There is no "bridge to another chain" action. If you want the agent to do something outside this set, you have to do it manually or use an external tool.

Practical permission presets by strategy:

Conservative. swap_and_mint, withdraw_and_swap, adjust_range, compound, harvest. No swap_and_increase — the agent can rebalance and exit but cannot add more capital to a struggling position. This forces you to decide manually whether to commit more.
Balanced (default). All six enabled.
Aggressive. All six enabled, plus a higher take-profit and tighter stop-loss in Execution Config.

The critical permission to never disable is withdraw_and_swap. Without it, the agent has no way to exit a position that goes bad. Stop-loss exits depend on it.

Scopes — Where and How Broadly the Agent Can Operate

Scopes are hard guardrails the agent cannot violate. They fall into three groups.

Pool-level constraints (you set thresholds; the agent rejects any pool that fails):

MIN_POOL_TVL_USD — minimum pool TVL (e.g. $200,000)
MIN_POOL_VOLUME_24H_USD — minimum 24h trading volume (e.g. $50,000)
MIN_VOLUME_TVL_RATIO — volume/TVL ratio (e.g. 0.3 — ensures the pool actually trades)
MAX_FEE_TIER_PCT — reject pools above this fee tier (e.g. 1.0%)
MIN_POOL_AGE_DAYS — reject pools younger than this (e.g. 3 days)
MAX_PRICE_VOLATILITY_PCT — reject pools above this volatility (e.g. 75%)
MIN_APR_24H_PCT — minimum 24h APR for entry
MIN_APR_7D_PCT — minimum 7d APR for sustained yield

Range constraints (control how concentrated the agent's positions are):

MIN_POSITION_RANGE_WIDTH_PCT — narrowest allowed range
MAX_POSITION_RANGE_WIDTH_PCT — widest allowed range (e.g. 0.2% for stablecoin pairs, 50% for volatile pairs)

Asset constraints (whitelist and blacklist):

ALLOWED_TOKENS — token whitelist (USDC, USDT, WETH, etc.)
BLOCKED_TOKENS — specific token addresses to avoid (scams, exploits)
ALLOWED_PROTOCOLS — DEX whitelist (Aerodrome, Curve, Uniswap V3)
BLOCKED_PROTOCOLS — DEX blacklist (Uniswap V4 BSC, etc.)
BLOCKED_POOLS — specific pool addresses

The default vault has no scopes set. That means the agent can pick any pool, any token, any range. If you don't configure scopes, you're trusting the AI's defaults with no guardrails. Add them before activating the agent.

Instructions — The Logic

Instructions are a free-form text block the agent reads every evaluation cycle. Two ways to create them:

Generate with AI. Krystal drafts an instruction set based on your Goal + risk level + return target. You review and edit.
Write manually. Full control. You write the conditions, the agent follows them.

The agent supports a 6-step decision order on each cycle. You should structure your instructions around this order:

EXIT — for each active strategy past the minimum age, check stop-loss, take-profit, APR collapse, or volatility spike. Exit if any trigger fires.
OUT_RANGE — for each strategy where the price has left the range, call adjust_range to recenter.
HARVEST — collect fees above the harvest threshold (or convert to base currency).
INCREASE_LIQUIDITY — add capital to the highest-PnL strategy, respecting capital caps.
POOL_SELECTION — filter candidate pools against Scopes.
ENTRY — open a new position on the best qualifying pool.

This order is mandatory in practice: the agent protects capital first, maintains positions second, realizes gains third, and only then deploys idle capital. If you reorder this in your instructions, the agent will still try to follow your text but the platform's safety layers may reject conflicting plans.

Instructions also include standard patterns you'll reference repeatedly:

POOL_SELECTION — list of conditions a pool must satisfy to be eligible (TVL ≥ X, volume ≥ Y, ratio ≥ Z, fee tier ≤ W, age ≥ N, volatility ≤ V, 24h APR ≥ A, 7d APR ≥ B).
ENTRY — when to actually mint a position; how to size it (capped by Execution Config); what range width to use.
OUT_RANGE — when to recenter; minimum shift threshold so the agent doesn't burn gas on tiny adjustments.
INCREASE_LIQUIDITY — when to add to an existing position instead of opening a new one; capital cap per pool.
DUST_CLEANUP — swap stray non-base tokens above a USD threshold into base currency before harvest or increase.
HARVEST — when to collect fees (threshold-based and time-based triggers); gas-aware skip if fees don't justify the cost.
EXIT — when to close a position (PnL trigger, APR trigger, volatility trigger); stop-loss slippage escalation.

Range width is computed by the platform using pool_price_volatility_pct × RANGE_VOL_MULT. You do not need to specify this formula in Instructions — it is built-in. You only set the bounds (MIN_POSITION_RANGE_WIDTH_PCT, MAX_POSITION_RANGE_WIDTH_PCT) and the multiplier.

Execution Config — How Actions Are Executed

This is the system-level safety layer the agent cannot violate:

Slippage — MAX_SLIPPAGE_PCT (default for swaps, mints, rebalances), STOP_LOSS_SLIPPAGE_L1_PCT (when ROI drops below L1 threshold), STOP_LOSS_SLIPPAGE_L2_PCT (when ROI drops below L2 threshold, the worst case).
Timing — POOL_ACTION_TIMEFRAME_HOURS (minimum strategy age before EXIT or INCREASE is eligible), COOLDOWN_ACTION_MINUTES (minimum time between any two actions).
Capital limits — MAX_VALUE_PER_STRATEGY_USD (max capital per position), MAX_CAPITAL_PER_POOL_USD (max exposure to a single pool), MIN_USD_PER_ACTION (don't bother if the action is too small), MIN_DUST_SWAP_USD (dust cleanup threshold).
Gas — MAX_GAS_PRICE_GWEI (skip actions if gas exceeds this).
Range/sizing — PRICE_IMPACT_PCT (target slippage on entry swaps), RANGE_VOL_MULT (range width multiplier), OUT_RANGE_MIN_SHIFT_PCT (minimum shift for a rebalance to be worth it).

Stop-loss slippage escalation is the one most users get wrong. Set STOP_LOSS_SLIPPAGE_L1_PCT to 2-5% and STOP_LOSS_SLIPPAGE_L2_PCT to 5-15%, with thresholds like -10% / -50%. When the position drops 10%, the agent accepts up to 5% slippage on the exit. When it drops 50%, slippage tolerance climbs to 15%. The exit always succeeds, but the price gets worse as the loss gets worse. Tune these conservatively or you will get slippage-drained exits on black swan days.

The Three Knobs You Set at Creation

When you create an Auto-Farm Vault (per docs/products/vaults/auto-farm/create-an-auto-farm-vault.md), you set three preferences that the AI uses to draft your initial instructions:

Risk Level

High Risk — Memes, trending tokens, riskier bets with higher volatility.
Balanced — High-cap, established DeFi tokens with moderate risk.
Safe — Stablecoin pairs and low-volatility strategies.

This shapes which pools the agent will consider by default. It does not enforce a hard risk cap — Scopes are what enforce hard limits. Risk Level is a hint that biases the AI-generated instructions.

Expected Return

Max Gain — chase top-performing pools for maximum upside.
Growth Mode — target ~15-30% APR with balanced optimization.
Steady Yield — target ~5-15% APR with more stable strategies.

Again, this is a target. The actual APR depends on the market and your Scopes. If you set Max Gain but your Scopes reject pools above 50% APR, the agent will struggle to find qualifying pools.

Farming Style

Passive — relaxed strategy with weekly or less frequent adjustments.
Smart — dynamically adjusts based on volatility and fees.
Active — rebalances frequently to maximize yield.

Active styles earn more in sideways markets but cost more in gas and create more taxable events. Passive styles are cheaper but miss fast moves.

Goal Field vs Instructions: What Goes Where

The Goal field and the Instructions field look similar — both are free-form text — but they play different roles.

Goal is what you write at vault creation (1-2 sentences). The Krystal AI generator uses it as input to draft your initial Instructions. You rarely edit the Goal afterwards.
Instructions are the tactical logic the agent reads every evaluation cycle. You can edit Instructions any time, and the next evaluation cycle uses the new version.

The clean rule: Goal is intent. Instructions are conditions and actions. Put the philosophy in Goal. Put the thresholds, triggers, and decision logic in Instructions.

Concrete anti-patterns to avoid:

Don't write specific thresholds in Goal — "TVL ≥ $200k" belongs in Scopes, not Goal.
Don't write specific APR minimums in Goal — "8% APR minimum" belongs in Instructions or Scopes.
Don't write range widths in Goal — "0.1% range" belongs in Scopes.
Don't write action sequences in Goal — "Harvest when fees exceed 5%" belongs in Instructions.
Don't write the chain in Goal or Instructions. Each Auto-Farm vault is bound to a specific chain at creation — the agent already knows it, mentioning it confuses interpretation. Record chain separately for your own reference.

Good Goal examples from Krystal's docs:

"Build a conservative strategy on blue-chip DeFi pools with stable yields."
"Maximize APR on ETH pairs while managing IL."
"Farm trending pools but exit quickly when yields drop."

Notice: all three are intent + risk profile + asset class + yield target, in one or two sentences. No thresholds. No specific percentages. The AI uses this as a brief and drafts the Instructions.

How to Actually Start

Four steps, in order:

Click Create Auto Farm Vault. Describe your goal in 1-2 sentences. Examples from Krystal's docs:
- "Build a conservative strategy on blue-chip DeFi pools with stable yields."
- "Maximize APR on ETH pairs while managing IL."
- "Farm trending pools but exit quickly when yields drop."

Focus on intent and constraints, not exact steps. The AI drafts the strategy; you review.

Pick Risk Level, Return Mode, and Farming Style. Three clicks. These are starting points, not commitments — you change them later by editing Instructions.
Review the AI-generated strategy. This is the step most people skip. The AI will propose a set of pool filters, range widths, harvest thresholds, and stop-loss triggers. Edit anything that doesn't match your actual risk tolerance. At minimum, set Scopes before turning the agent on.
Verify your wallet, activate the agent, deposit funds. By default Auto-Farm Config is not activated — you have to turn it on. Verification is required for security. Deposit is optional at creation; you can add capital later.

After activation, monitor through Agent Overview (status) and Action Logs (what it did). Use Chat to ask the agent why it took a specific action. Use Terminal if you need to debug an unexpected behavior.

Common Mistakes

Skipping Scopes. Without Scopes, the agent can pick any pool. Defaults are sensible but not protective. Add ALLOWED_TOKENS, BLOCKED_PROTOCOLS, MIN_POOL_TVL_USD before activation.
Setting Max Gain with a Safe risk level. The settings contradict each other. The AI will pick a compromise that satisfies neither. Pick one consistent profile.
Confusing Instructions with Scopes. Instructions are the agent's logic ("exit when X"). Scopes are the agent's guardrails ("never touch pool Y"). Both are needed; one alone is incomplete.
Leaving withdraw_and_swap disabled. Without this permission, the agent cannot exit. Stop-loss cannot fire. You'll be locked in.
Setting STOP_LOSS_SLIPPAGE_L2_PCT too tight. On a real crash, the exit won't fill at 2% slippage. You'll sit in a position that should have closed. Set L2 to 10-15%.
Not monitoring Action Logs. The agent will tell you what it did. If you never check, you won't catch a misconfigured strategy until the PnL shows it.
Treating the AI draft as final. The "Generate with AI" output is a starting point. Review every section.

When Auto-Farm Is the Wrong Tool

Auto-Farm Vaults assume you trust the agent's defaults for everything you didn't explicitly configure. The agent only sees on-chain state + Krystal's indexer. No external feeds, no portfolio-wide view, no custom math. If your strategy needs:

External data (GoPlus, honeypot.is, holder concentration, token age) — the agent works only with on-chain data plus what Krystal indexes. Token age and holder data are not in scope. Run an external script, manually add the result to BLOCKED_POOLS or BLOCKED_TOKENS, and the agent stays away.
Cross-protocol coordination (Aave borrow + LP simultaneously, lending supply + LP) — the agent handles LP positions only. Anything outside the vault must be coordinated manually. The agent cannot borrow to fund a position.
Custom scoring (Sharpe ratios, multi-factor risk scores) — the agent executes actions, not math. Simplify to a single APR threshold the agent can read; if you need a composite score, compute it externally and reduce it to a binary "include / exclude" decision the agent can act on.
Portfolio-level PnL — the agent sees per-position PnL via Terminal, not aggregate across all vaults. If you need portfolio-level alerts, monitor them yourself.
Real-time price oracles outside the position — the agent reads price through Terminal context. No external price feed integration. If your stop-loss depends on a custom oracle, you have to implement it externally.
Multi-pool allocation % — the agent picks one pool per ENTRY. If you want 30/30/40 split across three pools, you encode that into Instructions as conditional logic, but the runtime behavior is "pick one best pool, then consider the next." Coarse, not surgical.
Historical funding rates (perps), liquidation levels, social signals — out of scope. The agent has no concept of these.

For any of these, use a different tool or run external scripts alongside the vault. The agent is best when your strategy fits cleanly into the 6-action vocabulary. Anything that needs more is a sign that Auto-Farm is the wrong layer for that strategy.

Variables the Agent Sees

The agent reads a fixed set of variables from vault state, position state, and pool state. If you write Instructions that reference variables by name, these are the names you can use.

Per vault:

vault_tvl_usd — total vault value
vault_base_currency — base currency token (USDC, USDT, ETH, native gas token)
vault_idle_balance_usd — undeployed capital
vault_pending_fees_usd — uncollected fees total

Per strategy / position:

strategy_id — unique identifier
strategy_value_usd — current LP value
strategy_pnl_usd — unrealized PnL in USD
strategy_pnl_pct — PnL as percentage
strategy_age_hours — hours since position opened
strategy_pool_address — pool contract address
strategy_range_lower_pct — lower bound as % from current price
strategy_range_upper_pct — upper bound as % from current price
strategy_in_range — boolean: price within range
strategy_pending_fees_usd — uncollected fees for this strategy
strategy_pending_fees_token0 — pending fees in token0
strategy_pending_fees_token1 — pending fees in token1

Per candidate pool:

pool_address, pool_tvl_usd, pool_volume_24h_usd, pool_apr_24h_pct, pool_apr_7d_pct, pool_price_volatility_pct, pool_fee_tier_pct, pool_age_days, pool_token0_address, pool_token1_address, pool_protocol, pool_current_price

Execution context:

current_gas_price_gwei, estimated_gas_cost_usd, max_value_per_strategy_usd, execution_slippage_pct, min_dust_swap_usd

Per token balance:

token_balance_amount, token_balance_usd

If your Instructions reference a variable name that isn't in this list, the agent treats it as undefined and skips that condition. Use the exact names above.

The Blank Template

A complete copy-paste starting point for any Auto-Farm Vault. Fill in the bracketed values, set your chain in your own notes (not in the template), and activate the agent after reviewing every section.

## GOAL

[1-2 sentences: intent + risk profile + asset class + yield target]

## SCOPES

### Vault

- BASE_CURRENCY = [USDC | USDT | ETH | native_gas_token]

### Pool constraints

- MIN_POOL_TVL_USD = $[N]
- MIN_POOL_VOLUME_24H_USD = $[N]
- MIN_VOLUME_TVL_RATIO = [N]
- MAX_FEE_TIER_PCT = [N]%
- MIN_POOL_AGE_DAYS = [N]
- MAX_PRICE_VOLATILITY_PCT = [N]%
- MIN_APR_24H_PCT = [N]%
- MIN_APR_7D_PCT = [N]%

### Range constraints

- MIN_POSITION_RANGE_WIDTH_PCT = [N]%
- MAX_POSITION_RANGE_WIDTH_PCT = [N]%

### Asset constraints

- ALLOWED_TOKENS = [token1, token2, ...]
- BLOCKED_TOKENS = [token_address, ...]
- ALLOWED_PROTOCOLS = [protocol1, protocol2, ...]
- BLOCKED_PROTOCOLS = [protocol_name, ...]
- BLOCKED_POOLS = [pool_address, ...]

## INSTRUCTIONS

### DECISION_FRAMEWORK

Evaluate per active strategy in this exact order:

1. EXIT
2. OUT_RANGE
3. HARVEST
4. INCREASE_LIQUIDITY
5. POOL_SELECTION
6. ENTRY

### POOL_SELECTION

A pool qualifies for ENTRY only if ALL of the following are true:

- pool_address is NOT in BLOCKED_POOLS
- pool_protocol is in ALLOWED_PROTOCOLS (if set)
- pool_token0_address AND pool_token1_address are in ALLOWED_TOKENS (if set)
- pool_tvl_usd >= MIN_POOL_TVL_USD
- pool_volume_24h_usd >= MIN_POOL_VOLUME_24H_USD
- pool_volume_24h_usd >= pool_tvl_usd × MIN_VOLUME_TVL_RATIO
- pool_fee_tier_pct <= MAX_FEE_TIER_PCT
- pool_age_days >= MIN_POOL_AGE_DAYS
- pool_price_volatility_pct <= MAX_PRICE_VOLATILITY_PCT
- pool_apr_24h_pct >= MIN_APR_24H_PCT
- pool_apr_7d_pct >= MIN_APR_7D_PCT

Among all qualified pools, select the pool with the highest pool_apr_24h_pct. If two pools tie on APR, select the one with higher pool_tvl_usd.

### ENTRY

Execute swap_and_mint on the selected pool from POOL_SELECTION if ALL of the following are true:

- vault_idle_balance_usd >= MAX_VALUE_PER_STRATEGY_DEPLOY_USD
- The selected pool's strategy_id does NOT already exist in this vault

When executing swap_and_mint:

- Use the platform's range rule (RANGE_VOL_MULT × pool_price_volatility_pct, clamped by MIN/MAX bounds)
- Target position size = MAX_VALUE_PER_STRATEGY_DEPLOY_USD
- If MAX_VALUE_PER_STRATEGY_DEPLOY_USD < MIN_POSITION_SIZE_USD, do NOT open

### OUT_RANGE

For each strategy where strategy_in_range is false:

- Execute adjust_range using the ENTRY range rule
- Skip if the resulting range width differs from the current range width by less than OUT_RANGE_MIN_SHIFT_PCT

### INCREASE_LIQUIDITY

BEFORE executing INCREASE_LIQUIDITY, check ENTRY conditions: if vault_idle_balance_usd >= MAX_VALUE_PER_STRATEGY_DEPLOY_USD AND a new pool qualifies from POOL_SELECTION, execute ENTRY instead, NOT INCREASE_LIQUIDITY.

Otherwise, execute swap_and_increase on the strategy with the highest strategy_pnl_pct if ALL of the following are true:

- Any vault token balance (excluding vault_pending_fees_usd) has USD value >= MIN_USD_PER_ACTION
- strategy_value_usd < MAX_CAPITAL_PER_POOL_USD

If strategy_value_usd >= MAX_CAPITAL_PER_POOL_USD, do NOT increase.

### DUST_CLEANUP

Execute BEFORE HARVEST and BEFORE INCREASE_LIQUIDITY.

For each token in vault where token_address is not vault_base_currency:

- If token_balance_usd >= MIN_DUST_SWAP_USD
- AND token_address is NOT pool_token0_address AND is NOT pool_token1_address of any active strategy

Then swap the entire token_balance_amount to vault_base_currency using swap_and_increase on the strategy with the highest strategy_pnl_pct.

### HARVEST

For each strategy where strategy_age_hours >= POOL_ACTION_TIMEFRAME_HOURS:

Execute harvest (converting fees to vault_base_currency) when ANY of the following are true:

- strategy_pending_fees_usd >= strategy_value_usd × HARVEST_PERC
- A TAKE_PROFIT exit is being triggered in the same evaluation cycle

Skip harvest if ALL of the following are true:

- strategy_pending_fees_usd < estimated_gas_cost_usd × HARVEST_GAS_RATIO

Conversion target: vault_base_currency.

### EXIT

For each strategy where strategy_age_hours >= POOL_ACTION_TIMEFRAME_HOURS:

Execute withdraw_and_swap (converting to vault_base_currency) when ANY of the following are true:

- strategy_pnl_pct < STOP_LOSS_PERC
- strategy_pnl_pct >= TAKE_PROFIT_PERC
- pool_apr_24h_pct < MIN_APR_24H_PCT
- pool_apr_7d_pct < MIN_APR_7D_PCT
- pool_price_volatility_pct > MAX_PRICE_VOLATILITY_PCT

STOP_LOSS SLIPPAGE ESCALATION:

- If strategy_pnl_pct < STOP_LOSS_SLIPPAGE_L1_THRESHOLD, use STOP_LOSS_SLIPPAGE_L1_PCT for the withdraw
- If strategy_pnl_pct < STOP_LOSS_SLIPPAGE_L2_THRESHOLD, use STOP_LOSS_SLIPPAGE_L2_PCT for the withdraw

## EXECUTION_CONFIG

### Slippage

- MAX_SLIPPAGE_PCT = [N]%
- STOP_LOSS_SLIPPAGE_L1_PCT = [N]%
- STOP_LOSS_SLIPPAGE_L2_PCT = [N]%
- STOP_LOSS_SLIPPAGE_L1_THRESHOLD = [N]%
- STOP_LOSS_SLIPPAGE_L2_THRESHOLD = [N]%

### Timing

- POOL_ACTION_TIMEFRAME_HOURS = [N]
- POOL_ACTION_TIMEFRAME_TP_HOURS = [N]
- COOLDOWN_ACTION_MINUTES = [N]

### Capital

- MAX_VALUE_PER_STRATEGY_USD = $[N]
- MAX_VALUE_PER_STRATEGY_DEPLOY_USD = $[N]
- MIN_POSITION_SIZE_USD = $[N]
- MAX_CAPITAL_PER_POOL_USD = $[N]
- MIN_USD_PER_ACTION = $[N]
- MIN_DUST_SWAP_USD = $[N]

### Gas

- MAX_GAS_PRICE_GWEI = [N]

### Range / sizing

- PRICE_IMPACT_PCT = [N]%
- RANGE_VOL_MULT = [N]
- OUT_RANGE_MIN_SHIFT_PCT = [N]%

### Strategy-specific

- STOP_LOSS_PERC = [N]%
- TAKE_PROFIT_PERC = [N]%
- HARVEST_PERC = [N]%
- HARVEST_GAS_RATIO = [N]

Worked Example: Conservative Stablecoin Vault

Same template, filled in for a USDC/USDT stablecoin vault on Base. Tighter ranges, higher TVL floor, very low volatility tolerance, low stop-loss.

GOAL:
Maximize fee generation through ultra-tight, stable-stable liquidity
(USDC/USDT only), with disciplined capital preservation via dual APR
filter (24h+7d), elevated pool liquidity threshold, and tight stop-loss
execution. Position ranges max 0.2% width to capture near-peg fee density
without IL exposure. Convert all earnings to USDC.

SCOPES:
- BASE_CURRENCY = USDC
- MIN_POOL_TVL_USD = $200,000
- MIN_POOL_VOLUME_24H_USD = $100,000
- MIN_VOLUME_TVL_RATIO = 0.3
- MAX_PRICE_VOLATILITY_PCT = 0.5%
- MIN_APR_24H_PCT = 8%
- MIN_APR_7D_PCT = 5%
- MAX_CAPITAL_PER_POOL_PERC = 50%
- MIN_POSITION_RANGE_WIDTH_PCT = 0.1%
- MAX_POSITION_RANGE_WIDTH_PCT = 0.2%
- ALLOWED_TOKENS = [USDC, USDT]

INSTRUCTIONS: [Standard 6-pattern framework from the Blank Template]

EXECUTION_CONFIG:
- STOP_LOSS_PERC = -1%
- TAKE_PROFIT_PERC = +8%
- STOP_LOSS_SLIPPAGE_L1_PCT = 2%
- STOP_LOSS_SLIPPAGE_L2_PCT = 5%
- HARVEST_PERC = 0.5%
- HARVEST_DAYS_MAX = 30
- HARVEST_GAS_RATIO = 50
- MAX_VALUE_PER_STRATEGY_USD = 50% of vault

What this config does, in plain English:

Only USDC/USDT pools qualify (ALLOWED_TOKENS).
TVL must be at least $200k and 24h volume at least $100k — filters out shallow pools.
Volatility must be ≤ 0.5% — a stable-stable pool should not be moving much; high volatility means depeg risk.
APR must be at least 8% over 24h and 5% over 7d — filters out pools with collapsing yields.
Range width is between 0.1% and 0.2% — tight enough to capture near-peg fee density, wide enough to not rebalance every block.
Stop-loss at -1% — tight, because stable-stable means any meaningful move is a depeg event.
Take-profit at +8% — locks in fee gains before they get competed away.
Harvest at 0.5% of position value — small fee thresholds, because stablecoin fees accumulate slowly and you want to compound them aggressively.
Max 50% of vault per pool — prevents the agent from concentrating everything in a single pool.

This is a "set and forget" config. Once activated, you mostly watch Action Logs for any unexpected exits and rebalance the vault's capital allocation when the agent reports it.

Validation Checklist Before You Activate

Before flipping the agent switch:

[ ] Goal field is 1-2 sentences, abstract intent only — no thresholds, no actions.
[ ] Scopes cover pool constraints, range constraints, and asset constraints.
[ ] Instructions follow the 6-step decision order (EXIT → OUT_RANGE → HARVEST → INCREASE_LIQUIDITY → POOL_SELECTION → ENTRY).
[ ] All 6 action patterns present (POOL_SELECTION, ENTRY, OUT_RANGE, INCREASE_LIQUIDITY, DUST_CLEANUP, HARVEST, EXIT) — or whatever subset your strategy needs, but documented.
[ ] All variable names used in Instructions match the names in the Variables section above.
[ ] No external API references (GoPlus, honeypot.is, Twitter, etc.).
[ ] No custom math (Sharpe ratios, custom risk scoring).
[ ] No cross-protocol coordination (Aave borrows, lending supply).
[ ] Execution Config has slippage (default + L1 + L2), timing, capital limits, gas ceiling.
[ ] STOP_LOSS escalation thresholds defined — L1 and L2.
[ ] HARVEST trigger defined (percentage + optional time fallback).
[ ] BLOCKED_POOLS / BLOCKED_TOKENS list populated if there are known bad actors.
[ ] Chain recorded separately (in your own notes, not in Goal or Instructions).
[ ] Wallet verified before activation.
[ ] Deposit is sized so a single MAX_VALUE_PER_STRATEGY_USD mistake can't wipe the vault.

If any checkbox is missing, fix it before activation. The agent will run with whatever defaults the platform fills in for missing fields, and those defaults may not match your intent.

The Takeaway

Auto-Farm is the easiest path to active LP management on Krystal, but it's also the easiest path to running your money with defaults you didn't read. The three-step wizard at creation is the surface. The four-layer config underneath — Permissions, Scopes, Instructions, Execution Config — is where real returns and real risk live.

A working setup is usually:

Risk Level + Return Mode + Farming Style that match each other (e.g. Balanced + Growth Mode + Smart).
Scopes that reject scam pools and cap fee tier + volatility (your hard floor).
Instructions that follow the 6-step decision order (EXIT → OUT_RANGE → HARVEST → INCREASE → POOL_SELECTION → ENTRY), with stop-loss and take-profit triggers defined.
Execution Config with realistic slippage escalations (L1 = 2-5%, L2 = 10-15%) and a sensible cooldown (5-15 minutes).
Monitoring through Action Logs and Chat, not just the Overview screen.

Treat the AI-generated draft as a starting point. Edit it. Add Scopes. Activate. Then watch Action Logs for the first week before trusting the agent with more capital.

This guide is based on the official Krystal documentation for Auto-Farm Vaults (verified January 2026). Vault mechanics, fees, and AI agent behavior may change as Krystal iterates on the product. Always cross-check the live docs at docs.krystal.app before deploying real capital.

LP Automation Tools Compared: VFat, Krystal, and MaxFi

Sergey Sereda — Fri, 11 Sep 2026 16:02:09 +0000

Three tools automate concentrated-liquidity positions. VFat and Krystal are the established names; MaxFi is the new entrant with an aggressive zero-swap rebalance logic. The mechanic that makes MaxFi great in a bounce-back market is the same one that can hurt you badly in a continued-down market. Here's what each one charges, what each one does on a price drop, and how to pick.

Active liquidity management has three popular automation tools right now: VFat, Krystal, and MaxFi. They all claim to do the same thing — keep your LP range in the money — but they rebalance very differently. And how they rebalance determines whether you keep your gains or get steamrolled on a bad day.

What Each Tool Does

VFat — yield aggregator and concentrated-liquidity manager. Uses its own Sickle contracts, self-custodial. Charges a small platform fee per rebalance on top of swap costs.
Krystal — multi-chain liquidity-farming agent with many DEXs. Heavy on Auto-Farm Vaults and AI-driven monitoring. Charges per-action fees plus auto-compound and auto-harvest fees on LP earnings.
MaxFi — newer product from the Snuggle team. Runs on Robinhood Chain, Base, and Arbitrum, including tokenized US stocks against USDG on Robinhood Chain. Uses a zero-swap rebalancing logic that sticks to the current price and never crystallizes impermanent loss at extreme moves. The rebalance delay is user-configurable from 1 hour to 168 hours. Charges a 15% performance fee on LP earnings only. Configuration is per-position with a preset library of three levels (Aggressive / Moderate / Conservative) auto-tuned per pool from on-chain liquidity data; you can also customize range width and rebalance delay manually on top of any preset. Range width is a single parameter that applies equally to both sides of the current price — you cannot widen one side independently of the other.

A note on Snuggle vs. MaxFi. Snuggle and MaxFi are products of the same team and share the zero-swap rebalancing logic. MaxFi is the broader, more active version: it expands on Snuggle by adding Robinhood Chain support (tokenized US stocks and ETFs) and a much wider set of pools across Robinhood Chain, Base, and Arbitrum, plus AI-managed strategies. So when this article talks about MaxFi's zero-swap mechanic, the same logic applies to Snuggle — the difference is mostly in surface area, not in how the rebalance itself works.

The Key Difference: How They Rebalance

VFat and Krystal use the classic swap-to-rebalance approach. When your position goes out of range, they sell one token and buy the other to bring the position back inside the new range. That swap happens at the worst possible moment — right after a price extreme — and costs you in three ways:

The DEX swap fee (0.01–1% depending on the pool)
Slippage on the trade (often 0.5–5% in volatile moves)
MEV / sandwich attacks (0.2–1% on public mempools)

You also crystallize your impermanent loss permanently. If the price reverses immediately, you've already bought high or sold low. That loss is locked in forever.

MaxFi uses a different approach — zero-swap rebalancing. When your position goes out of range, MaxFi repositions the range to touch the current price using only the tokens you already hold. No swap. No slippage. No MEV. The AMM itself rebalances you as price drifts back through your range. Impermanent loss is deferred, not crystallized.

Sounds perfect. It is, with one big asterisk.

The Tail Risk Nobody Mentions

Zero-swap rebalancing works brilliantly when the market is mean-reverting: price spikes, your range gets re-anchored, price drifts back, the AMM rebalances you at better average prices, you collect fees the whole time.

But what happens when the price doesn't bounce back — when it just keeps going down?

In a classic swap-based tool, a falling price triggers an ETH→USDC swap at the lower price. You exit your ETH exposure into USDC. Painful trade, but your capital is partly protected.

In a zero-swap tool, the price falls through your range and the position stays 100% ETH. No swap, no protection. The range just gets re-anchored to the new, lower price, with you sitting in the depreciating token. The next 10% drop does the same thing. And the next. Each "rebalance" is a no-op: you're already all-ETH, so there's nothing to swap, and the range simply slides lower with you.

You only get back to a balanced position if the price reverses and traders start pushing it back through your range. If the trend is one-way down, you ride the entire drop with no hedge.

Here's the scenario at a glance:

Market Behavior	VFat / Krystal (Swap-Based)	MaxFi (Zero-Swap)
Range-bound oscillation	OK — earns fees, but pays swap costs on every rebalance	Best — earns fees with zero structural cost; defers IL
Drift down then bounce	OK — crystallizes IL at the bottom, but recovers	Best — no IL crystallized, AMM rebalances you on the way back
Sustained 50% rise	OK — locks in gains via repeated sells	OK — accumulates USDC on each range exit
Sustained 50% drop	Best — converts ETH to USDC on each dip, preserves capital	Worst — stays 100% ETH through the entire decline, takes the full hit

The row that matters most: the one-way drop. That's where MaxFi's elegance becomes a liability.

This isn't a theoretical concern. ETH has dropped 50%+ multiple times in its history (2018, 2022, mid-2025). A position opened just before any of those drops would have ridden all the way down on a zero-swap tool.

There's a second consequence worth naming explicitly. In a swap-based tool, every dip sells a slice of your ETH into USDC — your average entry price for ETH drops with each dip. You're locking in "I bought cheaper." In a zero-swap tool, your average entry price never improves on a one-way move: each rebalance just re-anchors the range to the new lower price, with the position sitting 100% ETH. No swap, no better average.

And the second cost is dead time: when the price sits below your range, your position is 100% ETH and earns zero LP fees. You only start earning again when the price reverses and re-enters your range — and even then, only on trades that cross through it. The pool is effectively idle for the entire drawdown.

Where You Configure Automation: Per-Position vs Per-Vault

This is a structural difference that doesn't show up in the fee tables but matters a lot when you're running many positions.

VFat is per-position only. Every CL position you open gets its own Auto-Rebalance, Auto-Harvest, Auto-Compound, and Auto-Exit settings. There is no "apply this rule to N positions at once." Ten positions = ten separate automation configs to maintain.
Krystal runs on three nested levels (per docs/products/vaults/vault-vs-strategy.md):
- Liquidity Position: «a single position on a DEX (e.g., Uniswap V3), typically represented by an NFT issued by the protocol.»
- Liquidity Strategy: «a managed approach to a specific trading pair, composed of one or a series of positions that are periodically rebalanced. Strategies could include automation tools like auto-rebalance, auto-exit, and fee compounding.»
- Liquidity Vault: «can hold multiple Liquidity Strategies across different pools and tokens. This allows users to build and share more customized, advanced strategies under a single, smart-contract-governed framework.»

A Vault's core capabilities (per docs/products/vaults/what-is-liquidity-vault.md): «Manages multiple LP assets · Auto collect and convert fees · Enables auto-compounding, rebalancing, exiting · Bundle multiple LP actions (e.g., migrate, rebalance) into fewer txs · Auto-farm with enabled AI Agent.» Auto-Farm Vaults add an AI agent that selects pools, deploys capital, and manages positions end-to-end hands-free (per docs/products/vaults/auto-farm.md).

Crucial fee detail (per docs.krystal.app/ecosystem/fees.md): inside a Vault, «No additional fees for automation, zap, or rebalance within a VAULT» — only the Vault's performance fee on generated rewards applies (10% for Auto-Farm Vault, 10% default / 5% sharing for Community Vault). This means a single fee layer and a single automation layer across all positions inside the Vault.

MaxFi is per-position with a strong preset library. Three presets (Aggressive / Moderate / Conservative) per pool are auto-generated from on-chain liquidity data; you tune one position at a time, but the presets make that fast.

Practical takeaway: if you want one rulebook applied across many positions, Krystal is the only one of the three that does that natively. VFat and MaxFi force per-position config, which is fine for 1–5 positions and gets painful past 10.

Adding Capital After Opening

Once a position is open, the three tools treat capital additions differently:

MaxFi does not let you add funds to an existing position. The only mechanism that grows the position is auto-compound — the matching-token side of accrued fees is reinvested into the new range after each rebalance (maxfi.tech/docs → Auto-Compound). There's no "Add Funds" / "Top Up" / "Increase Position" flow in the docs. If you want more exposure to a working position, you open a new one — and end up with several positions on the same asset at different investment sizes.
Krystal does support it. The Position Details page has an explicit "Add Liquidity" button (per docs.krystal.app/products/liquidity-management/lp-transactions/provide-liquidity.md), so you can deploy more capital into an existing position in one click.
VFat does support it. You can deploy more capital into an existing VFat position.

Practical takeaway: if your strategy involves scaling into a working position over time, Krystal and VFat are the cleanest fit. MaxFi forces you to manage multiple positions on the same asset.

UI and Pool Coverage

Two more practical differences worth naming:

VFat's UI is cleaner. It does one thing — concentrated-liquidity management — and the dashboard stays focused. Less clutter, fewer popups, fewer side menus. If you only need LP automation and don't care about cross-chain yield dashboards, VFat is the calmer interface to live in.
Krystal has the broadest pool coverage. It lists positions across 9 chains and 19+ DEXs (Uniswap V3/V4, PancakeSwap, SushiSwap, Aerodrome, Camelot, THENA, Raydium, Thruster, Shadow, and others). That breadth is the main reason Krystal's UI looks busier — it's showing you a lot of surfaces, vaults, strategies, and chains in the same app.
MaxFi is somewhere in between. Roughly 200 pools across tokenized US stocks, Bitcoin, Ethereum, meme, AI-agent, altcoin, base ecosystem, stablecoin, and Robinhood meme categories — a much wider list than the docs page summary suggests, but a clean layout with a clear "Earn / Positions / Docs" navigation. The trade-off is choice vs focus: Krystal has more chains and DEXs, MaxFi has a single-chain concentration but a focused pool library.

If "I just want to manage a handful of LP positions and not think about it" is your priority, VFat and MaxFi win. If "I want every pool I can imagine on every chain, in one app" is your priority, Krystal wins.

Per-Operation Fees at a Glance

What you actually pay for each action — per tool, before any market costs.

Operation	VFat	Krystal	MaxFi
Deposit LP token / both tokens	0%	Free	Free
Deposit single token (with swap)	0.09% of swapped slice	0.05–0.25% (Zap, by pool tier)	Free
Withdraw	0% / 0.09% if swap	Free / tier swap fee	Free
Auto rebalance fee	0.01% of position (≤0.05% pool) → up to 0.05% (higher-fee pool)	0.01% → up to 0.05% of position (by pool tier)	Free (no swap, no position fee)
Swap on rebalance	0.09% of swapped slice (VFat) + 0.01–1% DEX pool fee	0.1% of volume (Krystal) + 0.01–1% DEX pool fee	None — zero-swap mechanic
Manual harvest / compound	0.9% of rewards each	Manual compound 0.05–0.25% by tier (of compound amount)	Free (single 15% performance fee)
Auto-compound / auto-harvest	Auto-Harvest 1.2% / Auto-Compound 1.8% of rewards	2% of LP fees each	Free (single 15% performance fee)
Performance / reward fee	n/a	10% of rewards (Auto-Farm Vault) / 10% default, 5% sharing (Community Vault)	15% of LP earnings only
Slippage	Yes — depends on market	Yes — depends on market	None — no swap
MEV / sandwich risk	Possible on public mempool	Possible on public mempool	Impossible — no swap, nothing to sandwich

Three things jump out from this table:

VFat and Krystal charge on every action. Every rebalance pays a swap fee plus a platform fee plus a DEX pool fee plus (in Krystal's case) auto-compound and auto-harvest fees on the LP earnings.
MaxFi has zero per-operation fees. The only charge is 15% of LP earnings, paid at the end on what the position actually made.
The difference in mechanics shapes the fee profile. VFat and Krystal have predictable per-event costs but crystallize impermanent loss on every swap. MaxFi's only cost scales with profit and IL is deferred, not locked in.

Fee Comparison on a $10,000 ETH/USDC Position

Setup: $10,000 in an ETH/USDC concentrated-liquidity position, ±15% range, 0.01% fee tier pool. ETH moves 50% up or 50% down from entry. A ±15% range means each 15% move triggers a rebalance — so each scenario produces 3 rebalances.

VFat (≤ 0.05% fee tier pool)

Assumes a ~$5,000 swap slice per rebalance (half the $10k position, swapped into the other token).

Action	Per-Event Cost	× 3 Rebalances
Rebalance fee (VFat)	0.01% × $10k = $1	$3
Swap fee (VFat, 0.09% of slice)	0.09% × $5k = $4.50	~$13.50
DEX pool fee (0.01% of slice)	0.01% × $5k = $0.50	~$1.50
Structural protocol cost (predictable)		~$6 / event — ~$18 over 3

The two lines below are not protocol fees — they're market costs that depend on volatility and pool depth at the moment of the swap. Splitting them makes the actual range honest:

Market Condition	Slippage (per event)	MEV / sandwich (per event)	× 3 Rebalances
Calm market, deep pool	0.1–0.5% ($5–$25)	0.1–0.3% ($5–$15)	+$30–$120
Normal volatility	0.5–2% ($25–$100)	0.2–0.5% ($10–$25)	+$105–$375
Wild move, thin pool	2–5% ($100–$250)	0.5–1% ($25–$50)	+$375–$900

Realistic total over 3 rebalances: ~$125–$395 in normal conditions. The $775 ceiling only happens during genuinely stressed moves on a thin pool.

Krystal (auto-rebalance, ≤0.05% fee tier)

Same ~$5,000 swap slice per rebalance.

Action	Per-Event Cost	× 3 Rebalances
Auto-rebalance fee	0.01% × $10k = $1	$3
Swap fee (Krystal, 0.1% of volume)	0.1% × $5k = $5	~$15
DEX pool fee (0.01% of slice)	0.01% × $5k = $0.50	~$1.50
Structural protocol cost (predictable)		~$6.50 / event — ~$20 over 3

Same split for market costs:

Market Condition	Slippage (per event)	MEV / sandwich (per event)	× 3 Rebalances
Calm market, deep pool	0.1–0.5% ($5–$25)	0.1–0.3% ($5–$15)	+$30–$120
Normal volatility	0.5–2% ($25–$100)	0.2–0.5% ($10–$25)	+$105–$375
Wild move, thin pool	2–5% ($100–$250)	0.5–1% ($25–$50)	+$375–$900

Plus 4% of LP fees (2% auto-compound + 2% auto-harvest) — on top of everything.

Realistic total over 3 rebalances: ~$125–$395 + 4% LP earnings in normal conditions. Same $775 ceiling only in stressed moves.

MaxFi (15% performance fee only)

Action	Per-Event Cost	× 3 Rebalances
Rebalance	free	$0
Swap	none (zero-swap)	$0
Slippage	none	$0
MEV	impossible (no swap)	$0
Performance fee	15% of LP earnings only	15% × LP earnings
Approx. total over 3 rebalances		15% × LP earnings, $0 structural cost

The structural cost gap is the whole point: $0 vs $60 every time the range breaks — before you even count slippage and MEV. MaxFi wins the cost comparison by construction, not by negotiation.

How the Scenarios Play Out

Same $10,000 ETH/USDC position, ±15% range, 0.01% pool, three rebalances each direction:

Scenario	VFat	Krystal	MaxFi
+50% rise, then back to entry	Lost 0.01% platform + ~$140–$390 in swap cost. Net: negative or break-even.	Same as VFat + 4% of any LP fees. Slightly worse.	15% of any LP fees earned during the round-trip. No structural cost.
+50% rise, held to top	Sold into the rise; captured partial upside but missed the peak. Net: positive but capped.	Same as VFat + 4% LP fee cut.	Accumulates USDC on each range exit; captures upside. Net: positive, capped by range.
−50% drop, then bounce back	Crystallized IL at each dip. Recovery partial; you'll never get the full IL back. Net: negative or marginal.	Same as VFat.	Zero IL crystallized; AMM rebalances you during the bounce. Net: best of the three.
−50% drop, no bounce	Swapped ETH→USDC at each dip; preserved part of capital. Loss limited to swap costs.	Same as VFat.	Stayed 100% ETH through the whole drop. Took the full 50% hit. Net: worst of the three.

How to Pick

VFat — fine for low-frequency rebalancing on chains you trust. Cheap per rebalance, but you pay the swap and IL tax every time.
Krystal — multi-chain and feature-rich. Best if you want AI monitoring across many chains. Higher overhead than VFat.
MaxFi — best in mean-reverting markets; worst in sustained one-way moves. If you believe the asset is going to bounce, MaxFi wins. If you believe it's going to grind down, MaxFi bleeds.

A practical rule: only use MaxFi-style zero-swap tools when you have a stop-loss plan outside the position. The tool optimizes for fees in the happy path; it doesn't protect you from a trend.

Which Service When

Three tools, three jobs. The right pick depends on your portfolio size, how often you can watch the position, and what kind of market you're trading.

Pick by Portfolio Size

1–3 positions. You can manage these by hand. Every automation fee is a cost you can avoid by rebalancing yourself when conditions change. Manual keeps every basis point of your earnings.
5–10 positions. This is where automation starts to pay for itself. Watching 5–10 ranges and rebalancing each one to market takes real time every day. VFat's small per-rebalance fee is usually cheaper than the missed opportunities of doing it manually.
10+ positions. Automation is no longer optional. At this scale you need Krystal's multi-chain coverage or VFat's reliability — running it all by hand becomes impossible. MaxFi makes sense too if you want to defer fees and your positions are mostly in mean-reverting pairs.

Pick by Time Away from Your Laptop

The more time you expect to be offline (vacations, conferences, weeks where you're traveling), the more the automation fee becomes worth it. But the rebalance delay you set should match both your absence and the asset class — different assets need different response times.

Asset-by-asset delay rules of thumb:

Tokenized US stocks (Robinhood Chain and similar). Set 72h over the weekend, when the underlying stock market is closed but the on-chain AMM can drift on thin liquidity. The pool price moves even though the underlying stock hasn't — every rebalance during that drift looks like a loss, but the AMM and the stock price converge again on Monday. Shorter delays work fine during working days when both the AMM and the underlying market are active.
Meme coins. Set ~1 hour. APY is high on these pools and you want to catch almost every move. Long delays here mean missing the runs that make meme LP positions pay off.
Major assets (BTC, ETH, SOL). Set ~24 hours. You want to avoid reacting to brief spikes; only rebalance once the market structure has clearly changed. A 24h delay filters out noise without missing real moves.
Short-term altcoins and low-volume pools. Match the delay to the asset's volatility — typically between 1h and 24h. Pick shorter if the pool is liquid enough to absorb swaps without big slippage.

Match the tool to your absence:

Days to a couple of weeks. A short rebalance delay on VFat or Krystal is enough. VFat's rebalance delay is configurable from 0 to 255 minutes (just over 4 hours), so it filters out brief noise but is meant for short absences. Krystal's delay is configurable per position. The bot catches the rebalance for you while you're offline.
Weeks to months. Look for tools with longer rebalance windows or hands-off presets. MaxFi's configurable delay (1 hour to 168 hours / 1 week) covers most trips and matches the asset-class rules above; for longer absences, VFat and Krystal both keep running unattended.
You're effectively offline full-time. At this point you're paying for the service, not just the automation. VFat and Krystal both run well in fully unattended mode. MaxFi shines if you pair it with a stop-loss plan (see below).

Pick by Market Expectation

Range-bound or mean-reverting market. MaxFi is the best tool. Zero-swap rebalancing means you keep earning fees through the bounce-back instead of paying every step.
Trend day, up. VFat and Krystal sell into the rise. You capture the move in slices. MaxFi accumulates USDC on each range exit — also works, but VFat/Krystal are the conventional play here.
Trend day, down. VFat and Krystal swap ETH → USDC on each dip and protect your capital. MaxFi stays 100% ETH through the whole drop, which is the worst case for it.

The MaxFi-Specific Risk You Need to Plan For

Three things MaxFi does differently from the other two — and three things you have to set up yourself.

1. No stop-loss on the position itself. MaxFi's automation is rebalance-only. There is no Auto-Exit equivalent to VFat's feature — you can't tell MaxFi "close this position if price drops to X." If you want a hard floor, you have to build it outside the protocol.

2. Rebalance delay exists to filter noise — use it for that. The 0–168h delay setting is meant to wait out brief spikes before triggering a rebalance. A typical use case: tokenized US stocks on Robinhood Chain. The stock market is closed on weekends, but the on-chain pool price can drift on thin liquidity during those 72 hours. If MaxFi rebalances during the drift, the position appears out of range and looks like a loss — but the underlying stock price hasn't actually moved, the AMM has just moved around an illiquid book. Set a 72h delay on stock pools so the bot waits out the weekend and only rebalances once Monday's trading brings the AMM and the underlying price back together. Same logic for low-volume hours on thin pools.

3. The downside of zero-swap during a sustained drop. If price drops through your range and keeps dropping, every rebalance in a zero-swap tool just slides your range lower with you. The position will end up 100% ETH at the bottom, even if it took ten rebalances to get there. That's the danger: you don't sell anything on the way down, so if the price later bounces back, you sell your ETH back into USDC only when the price rises back into your range. You sell low relative to the drop, even though the trend is now reversing — you sell "by a good price" relative to the bottom, but by a cheap price relative to where you started. The fee earnings you collect along the way cushion the loss, but only partially.

The good scenario for MaxFi: price drops below the range in one move, then bounces back. You accumulate 100% ETH at the lower (cheap) price, then as price recovers into your range, you sell at gradually rising prices — earning fees the whole way up and selling at a "good price" relative to the dip.

That's why the only safe way to run MaxFi is with a stop-loss plan outside the position. Here's the safer option:

Set a manual exit trigger (price X below range, time T since range break) and close the position by hand before further declines.

Without that, MaxFi is the wrong tool for a position in a coin you expect to trend hard in either direction.

The Takeaway

VFat charges a small fee per rebalance and pays for it in swap costs and IL crystallization. Best when rebalances are rare.
Krystal is the multi-chain option with a richer feature set and more fees layered on top of the same swap-based mechanics.
MaxFi wins on cost-per-rebalance (zero structural cost) and is best in mean-reverting markets. Its zero-swap rebalance is also its biggest risk in a sustained downtrend — your position rides the entire drop with no protective swap.

Pick by what you expect from the market. Range-bound or bounce-back? MaxFi. Trend day? VFat or Krystal with manual oversight.

Not financial advice. Fee schedules change — verify on each tool's official docs before committing capital. ETH/USDC at 0.01% tier exists on some DEXes but is less common than 0.05% — adjust assumptions if you're working with a different pool. Numbers were current at time of writing.

Sources:

VFat fee schedule: docs.vfat.io/fees
Krystal fee schedule: docs.krystal.app/ecosystem/fees
Krystal vault structure (Position / Strategy / Vault): docs/products/vaults/vault-vs-strategy.md
Krystal Vault core capabilities: docs/products/vaults/what-is-liquidity-vault.md
Krystal Auto-Farm Vault: docs/products/vaults/auto-farm.md
Krystal Provide Liquidity (Add Liquidity button on Position Details): docs/products/liquidity-management/lp-transactions/provide-liquidity.md
Snuggle fee schedule: snuggle.fi/docs
MaxFi docs (zero-swap rebalance, presets, fees): maxfi.tech/docs

Tools:

VFat · Krystal · MaxFi · Snuggle

AI Engineer: The Role Your Company Needs

Sergey Sereda — Wed, 19 Aug 2026 07:20:00 +0000

Companies are hiring "AI developers" to write prompts and glue models to APIs. The role they actually need is different: an engineer who treats AI as a system to be designed, measured, and controlled — not a magic box to be prompted. This role barely exists on the market, which means the companies that hire for it first win.

Walk into any company building an AI project and you'll find one of two people in charge:

The prompt engineer. Crafts elegant prompts, demos beautifully, and produces agents that work in the meeting room and fall apart with real customers.
The traditional developer. Builds robust software, tests everything, and treats the AI as an awkward API call — underusing what models can actually do.

Both are half the answer. The whole answer is a new role that combines them: the AI engineer. And almost nobody is hiring for it — which is exactly why it's the most valuable role in software right now.

What an AI Engineer Actually Does
The AI engineer builds the layer around the model — everything that isn't the prompt. Concretely, their day looks like this:

Context engineering. Designing what the model sees, in what structure, at what moment. Not just writing prompts, but building the pipeline: what data gets loaded, how it's organized, how retrieval finds the right documents. They treat context like code — versioned, reviewed, tested.
Tool and agent architecture. Deciding what the agent can do, not just what it can say: which tools, what schemas, how the loop handles errors, where humans step in. They design autonomy the way architects design access — deliberately, with boundaries.
Evaluation. Building the test sets and scoring systems that make the agent measurable. They can answer "did this week's change improve things?" with numbers, not feelings. This is the skill that separates AI as a gamble from AI as an engineering discipline.
Production thinking. Observability, tracing, cost control, guardrails, security. They build agents that survive real users, real data, and real failures — not just demos.
Domain translation. The part you can't teach in a bootcamp: understanding the business deeply enough to encode its rules — the unwritten policies, the data relationships, the edge cases — into something the model can use. The best AI engineers are half engineer, half chief operating officer.

How to Find the Right Person (and Be the Right Person)
If you're hiring:

Don't hire for prompt skills. Hire for engineering discipline plus evidence of AI production experience — eval sets, traces, guardrails, shipped failures and fixes.
Ask for the boring work: "Show me your test set. How do you score it? What did you learn from the last regression?" A candidate who can't show evaluation cannot own an agent.
Look for the hybrid: someone technical enough to build, curious enough to learn your business, and humble enough to measure.

If you're building this career:

The market is wide open, and the demand is guaranteed — every company running an agent in production will need this role.
Build the proof: ship an agent, maintain it, measure it, write about what you learned. Show eval scores going up over time. That's a portfolio no course can fake.

The Bottom Line
Almost every company needs an AI engineer right now. Almost none know it yet. The ones who hire first win the next decade of software.

The prompt era is ending. Any AI can be prompted; the ones that deliver are designed. The person who designs them — who understands the business deeply enough to encode it, and the engineering deeply enough to make it reliable — is the role that will define software for the next ten years.

Your company can keep hiring prompt writers. Or it can hire the people who build the actual product.

Grid Bot vs Concentrated Liquidity Pool Comparison | Real Test Results

Sergey Sereda — Tue, 18 Aug 2026 22:02:30 +0000

I ran two strategies on the same price range: a grid trading bot on Pionex and a liquidity pool position on VFat (CL10, WETH/USDC on Base). Same range, -15% / +5% (1630–2000). Same idea: earn while the price stays in this area. The results were not close.

I wanted to know what actually works better in my case — so I set up both. Same pair, same range, same time period. Here's what I got:

Grid bot (Pionex): 11.83% APY
LP position (VFat CL10, WETH/USDC on Base): 21.63% APY

Almost twice the return. Same range. Here's why.

How the Grid Bot Earns

A grid bot splits the range into steps. It puts buy orders below the price and sell orders above it. Every time the price crosses a step and completes a cycle (buy low, sell high), you make money — in my case 0.10% per trigger.

The catch: the bot only earns when the price actually crosses the steps. If the price stays flat, the bot does nothing. If it drifts slowly, you earn only when a step gets touched — not for the time in between.

There's also a cost side. The 0.10% per trigger is what I keep after fees. Each side of the trade costs 0.05%, so one full round costs 0.10%. That means the price has to move 0.20% per step just so I keep 0.10% net. Fees take as much as the bot earns.

Grid bots earn from price crossings. They don't care about trading volume. If lots of trades happen between your steps, the bot earns nothing from them.

How the LP Position Earns

An LP position in the WETH/USDC pool earns fees from every trade that happens while the price is inside your range — not just when the price crosses your levels. You lock in 1630–2000, and every swap in that zone pays you a share of the fees.

Simply put:

Grid bot earns only on triggers — small, fixed amounts, only when the price moves across levels. And each round costs you exchange fees.
LP position earns from all the trading volume in your range — all the time. Instead of paying fees, you collect a fee from every swap that happens in your range.

On top of that, some DeFi protocols pay you extra tokens or points on top of the fees. Those points can be converted into real tokens later. It's a second income stream on the same position — one that a grid bot never gives you.

The Results

Same range, same pair, same period:

Grid bot (Pionex), 0.1% per trigger: 11.83% APY
LP (VFat CL10, WETH/USDC, Base): 21.63% APY

The grid bot needed the price to cross its steps many times to collect small slices. The LP position earned the whole time the price stayed in range — every swap in the zone paid it.

That's the main reason for the gap: the grid bot is paid per crossing, the LP position is paid per swap. In a range with steady volume, there are far more swaps than crossings.

When the Grid Bot Wins

I'm not saying grid bots are useless. They can be better in some cases:

Big, fast swings. If the price bounces hard across the range, trigger-based earning works well.
You want the profit in your pocket right away. Each grid cycle is a closed, real gain. LP fees stay in the position until you take them out.
Low volume. If nobody trades in your range, an LP position earns almost nothing. A grid bot can still capture the swings.

LP has risks too: impermanent loss if the price leaves the range hard, and it only earns while it's in range.

What I Learned — and What I Do Now

For my case, the answer is clear: LP is better for me. If the range holds and volume is normal, LP earns much more than a grid bot.

And there's more you can do on top. Even a spot position (just holding ETH) can earn more with the right moves. If the price drops below the bottom of your range:

Use lending/borrowing to borrow stablecoins against your position — no need to sell anything.
Use the borrowed stablecoin to open a new LP position with a new, lower range.
You restart the pool and keep earning in the new zone, instead of sitting out of range and earning nothing.

So the downside of LP — "what if the price falls below the range?" — has a workaround: borrow, reposition, keep earning.

The Takeaway

For range-bound markets with normal volume — the exact situation most people set up grid bots for — LP wins, and it's not close. The grid bot is paid only when the price crosses your steps. The LP position is paid for every swap in your range, the whole time it's in range.

In my test: 11.83% vs 21.63% on the same 1630–2000 range. Same pair, same idea — almost twice the return.

One test on one range, not financial advice. Results depend on volume, volatility, and how long the price stays in range — but the mechanics behind the gap are structural, not luck.

Demo vs Product: Why AI Fails in Production

Sergey Sereda — Mon, 17 Aug 2026 07:51:17 +0000

Every AI demo works. That's the trap. The gap between a demo that wows your leadership and a product that survives real customers isn't the model — it's everything you didn't think about until the demo was over.

I've watched this cycle repeat in companies of every size:

Month 1. Someone builds a stunning demo. The AI answers questions flawlessly. Leadership is excited. The project is approved.
Month 4. The "product" is struggling. Wrong answers. Confusing edge cases. Slow. The team blames the model. Leadership starts doubting the whole thing.
Month 6. The project is quietly shelved. Everyone concludes: "AI doesn't work for us."

Here's the uncomfortable truth: the demo worked. The model didn't get worse. The environment changed. The demo ran in a perfect world. The product runs in yours.

What a Demo Actually Tests
Demos are great at showing what a model can do. They're terrible at showing what a model will do. Here's the difference:

The data. The demo runs on clean, formatted documents. The product runs on PDFs scanned in 2011 and spreadsheets with dead columns.
The systems. The demo touches no other system. The product has to talk to CRM, ERP, tickets, and emails — all speaking different dialects.
The user. The demo has one patient, polite user. The product has hundreds, typing in shortcuts and typos.
The question. The demo asks "It works!" The product asks "Why did it answer this way?"

The model is the same in both columns. The context is not.

The Five Killers of AI Products

Business rules. Your company runs on unwritten rules: discounts apply only to certain tiers, refunds have deadlines, approvals have thresholds. Nobody wrote them down because everyone knows them. The model doesn't. In the demo, the rules didn't come up. In production, they come up every hour.
Messy reality. Demo data is curated. Production data is your data: three naming conventions for the same product, statuses that mean different things in different systems, documents that contradict each other. The model faithfully reproduces the confusion of the source.
Security and access. In the demo, the AI sees everything. In production, you discover that your AI answering questions must know who's asking — and what they're allowed to know. Access rights aren't a feature; they're a lawsuit waiting to happen.
Integration. In the demo, the AI sits alone. In production, it must read from your systems and write back — and your systems were built before AI existed, with APIs that don't always play nice.
Real users. In the demo, the question was "What's the refund policy?" In production, it's "where's my refund??" Real users don't ask like documentation reads. And they ask at 2 AM, in three languages, about products that don't exist yet.

The Demo-to-Product Bridge
None of this means the demo lied. It means the demo showed the model's best moment (the ceiling) — while the product must survive the worst conditions, where all the real-world problems live. The bridge between them is engineering, and it looks like this:

Write the rules down. Before launch, collect the business rules that live in your experts' heads. This is the highest-value work in the whole project — and it's not glamorous. It's documentation.

Test with real data, not curated data. From day one, run the model against your actual documents and real questions from your support logs. The first bad answers are the map of what you need to fix.

Design the guardrails first. Who is the AI allowed to answer? What does it do when it's not sure? Where does a human step in? Decide these before launch, not after the first complaint.

Plan the integration like a normal software project. Because that's what it is. The AI is one component of a system — with the same needs as any other component: access, monitoring, errors, fallbacks.

Expect iteration. The first version will be wrong in ways you can't predict. That's normal software development. The teams that succeed are the ones who built a feedback loop — measure, fix, release — instead of expecting the demo to be the product.

The Takeaway
A demo proves the model can do the task. Only the product proves you can deliver it to real users, every day, at scale.

The companies that succeed with AI don't skip the boring work. They understand that the model is the easy 20%. The hard 80% is everything around it: rules, data quality, security, integration, users — and the discipline to measure and iterate.

The demo was real. The model didn't fail. Your business context — documented, connected, and controlled — is the missing half of the product. That part has no demo. It has to be built.

Your AI Doesn’t Know Your Company

Sergey Sereda — Fri, 14 Aug 2026 19:50:01 +0000

Here’s the most misunderstood thing about AI agents: they don’t remember anything. Your model doesn’t know your business, your products, or your customers. It reconstructs them from scratch — every single time you ask it something.

Most companies treat AI agents like a brilliant new employee: hire it, hand it the keys to the data, and it just knows everything, right?

Wrong. It’s closer to this: every morning, a new temporary consultant walks in, knows nothing about you, and you have exactly one chance to brief them before they answer questions all day. Tomorrow, a different consultant with no memory of yesterday shows up. That’s how an AI model works.

It doesn’t have a brain that remembers your company. It only has short-term memory — and it builds your world again from whatever you put in front of it, with every single request.

This one fact explains most AI failures in business. And it also shows exactly how to fix them.

The Model Is a Consultant With Amnesia
When your team asks the AI “how does our refund process work?”, the model doesn’t remember the refund policy from some internal memory. It takes the documents you loaded into the conversation, the instructions you wrote, and puts together its best guess of your refund process — from scratch.

Three consequences follow:

If you didn’t give it the policy, it will invent one. Not because it’s trying to trick you — because it has to give an answer. When your documents have gaps, the model fills them with whatever sounds believable. That’s what “hallucination” really is: the model guessing when it doesn’t have enough information.
If your documents are messy, the model’s understanding is messy. Your data lives in PDFs, spreadsheets, CRM records, emails — in different formats, different languages, different decades. The model sees what it’s given. Conflicting versions of the truth? It will happily repeat both, in the same answer.
If you change nothing, nothing changes. The model has no memory of yesterday’s answers. Improve your briefing today, and today is better. Stop, and it snaps back to baseline. There is no “learning on the job” — only better briefing.

What This Means for Your Business
This isn’t a weakness to be afraid of. It’s actually a design that works in your favor: you are in total control of what the model knows, at every moment.

That control is a process, and it looks a lot like onboarding a new employee — except you do it every day:

Write the company briefing once. A single main document: who you are, what you sell, how your processes work, what your terms mean, and what the model must never do. One source of truth. This is the most valuable piece of work in any AI project — and almost nobody has it.

Explain the data before feeding it. Before you load documents, write down what they are and how they connect. An invoice file without explanation is just text. With explanation — “these are invoices; number format is INV-YYYY-XXXXX; totals are before VAT” — it becomes knowledge.

Keep the briefing up to date. Products change. Processes change. Policies change. Update the briefing, and the model updates instantly. That’s the one advantage a model has over an employee — no retraining, no culture change, just better documentation.

Test with real questions. Before launch, ask the model the 20 questions your customers actually ask. Where it fails, the failure is a map of your documentation gaps. Fix the briefing, not the model.

The Takeaway
Stop expecting the model to “know” your company. It can’t — and it will never pretend not to, either.

The model’s knowledge of your business is exactly equal to the quality of the context you give it.

The companies that get AI right are not the ones with the most data. They’re the ones who treat context as a product: carefully written, structured, versioned, and maintained — like the best employee onboarding manual ever written.

Because in the end, that’s all the model is asking for: a briefing good enough to do the job.

Feed Your AI Agents Clean Data

Sergey Sereda — Tue, 11 Aug 2026 07:40:40 +0000

Most AI projects run into the same problem: a capable model, a motivated team, and a data set that has accumulated for years without cleanup. The wrong answers usually don't come from the model — they come from the data fed into it.

Teams often assume the fix is "a better model." It almost never is. The model is rarely the problem — the data it receives is.

Here's a rule that's hard to accept but always holds: AI doesn't fix your data. It repeats it. If documents contradict each other, the AI will surface both. If information is outdated, the AI quotes the outdated version. If a file is unreadable, the AI literally cannot process it.

The model is only as good as the data you give it. And most organizations' document collections contain significant noise and duplication.

Common Data Quality Issues
Common patterns in enterprise document stores:

Duplicates. Identical or near-identical files saved in multiple locations with different names.
Near-duplicates. Versioned documents ("Draft", "Final", "v2", "Final_Final") that are 90% the same but treated as separate records.
Outdated content. Documents from years ago still sitting in active knowledge bases, referencing prices, policies, or products that no longer exist.
Contradictions. Different departments maintaining different versions of the same rule, with no central authority.
Unreadable files. Scanned PDFs, images, handwritten notes — files without a text layer the model can access.
Broken structure. Text cells where the schema expects numbers, null values in fields that can't be empty, rows that don't match their headers. Human eyes scroll past this; a machine parsing the file fails or silently misreads it.
Mixed formats. One column carrying several formats — dates as "01/02/2024" and "2 January 2024", amounts as "1000" and "1,000.00". Every downstream query becomes a guess about what the value actually means.
Missing context. Files in multiple languages, full of internal abbreviations, with no dates, owners, or metadata.

All of this flows straight into the AI. The results reflect the input quality.

Feeding the model more data doesn't make it smarter. Feeding it cleaner, more specific data does. Everything else is noise in, noise out.

The Answer Is a Pipeline, Not a One-Time Cleanup
A single cleanup effort isn't enough — new documents arrive constantly. What you need is a pipeline: a repeatable process every piece of data passes through before the AI sees it.

Centralize collection. Shared drives, archives, CRM, email — bring everything to one place. You can't fix what you can't see.
Make everything readable. Run OCR on scanned PDFs, extract text from images, handle multiple languages. If the AI can't read a page, that page effectively doesn't exist.
Normalize formats. One date format, one currency format, one product naming convention. Inconsistent records must resolve to the same canonical representation.
Deduplicate in two passes. First, exact duplicates via content hashing. Second, near-duplicates by semantic similarity — using embeddings (numerical representations of document meaning) and k-nearest neighbors (search for documents with similar embeddings). This catches "Final" vs "Final_v2" style variants. These become a single record with version history, not multiple files.
Establish currency. Date-stamp every document. Archive old versions (retain for audit, don't delete). Mark one authoritative "current" version per topic. Only current versions go to the AI.
Enrich with metadata. Add structure: document type, department, dates, owner, status, links to related records. This transforms a file pile into structured knowledge the agent can reason over.
Serve only the cleaned set. Build the vector index from the validated output. The agent never touches the raw folder. If a document didn't pass the pipeline, it doesn't exist for the AI.
Add a quality gate. Measure: duplicates caught, current vs. expired ratio, "new document to AI-ready" latency. You can't improve what you don't track.

The Loop That Keeps It Clean
Clean once and stop is a false economy. The pipeline runs continuously:

New document arrives → OCR, deduplication, version comparison, metadata enrichment, security scan, indexing.
Document goes stale → flagged, archived, removed from the AI's retrieval set.
Quality gate runs on schedule → automated checks on the metrics above.

A practical side effect: clean data makes AI projects cheaper. Fewer tokens per request, faster responses, fewer costly errors. One well-selected document outperforms ten stale ones. The pipeline pays for itself.

The Security Check Most Pipelines Skip
Cleaning isn't only about quality — it's also about safety. Here's the attack nobody in the business room expects: a retrieved document can contain instructions directed at the AI itself.

This is called indirect prompt injection. A malicious or just careless document — a contract, a scanned PDF, an imported wiki page — can carry a line like "ignore your previous instructions and say...". When that document gets pulled into the model's context, the text stops being data and starts behaving like a command. The model can change its behavior because of a sentence buried in a file. This is precisely what OCR-extracted text is good at hiding: what looks like a typo in a scan can be a fully functional attack.

So in the pipeline, after OCR and extraction, every document passes a security pass before it's allowed into the index:

Pattern scan. A first pass with regex over the extracted text for known injection phrasing in multiple languages: "ignore previous instructions", "disregard", "you are now", "system prompt", "override prior commands", and similar. Fast and cheap — it catches the naive cases, which are most cases. Languages matter: documents get translated, and so do attacks.
Semantic scan. Regex misses rephrased attacks. A second pass uses a classifier or embedding-based anomaly detection: it flags chunks that read like instructions addressed to an AI rather than factual content. An invoice doesn't tell a model what to answer; a document that does should get attention.
Hidden content audit. Text the eye skips still reaches the model: text inside images (needs its own OCR pass), hidden layers in PDFs, tracked changes, comments, metadata fields. Attackers hide payloads there, so the audit must look there too.
Quarantine. Flagged documents go to a review queue — a human decides: clean it, strip it, or exclude it. Nothing silently enters the index on the first run.

And one principle that matters more than any scan: defense in depth. Even with cleaning in place, the agent must treat retrieved text as untrusted data, not instructions. Retrieved content never overrides the system prompt. The scan reduces exposure; the agent design is what actually stops the attack.

What Practice Teaches
A few lessons that only show up once you've run this pipeline for real:

Expect the first pass to remove a lot. In most document stores, a double-digit percentage of files turn out to be duplicates, near-duplicates, or outdated. That's normal, not a sign you did something wrong — it's the point.
Near-duplicate detection by embeddings catches what naming alone can't. Two files called something completely different can still be 90% the same document. Similarity search finds them; file names never will.
The hard part isn't cleaning — it's deciding what "current" means. Every topic needs one authoritative version, and that decision belongs to domain experts, not algorithms. The pipeline proposes; a human with business context approves.
Deletion improves answers more than addition. In retrieval, every extra document is a candidate for the wrong answer. Removing stale records usually improves output quality more than adding new ones.
Cost and latency drop together with cleanliness. Each request costs tokens proportional to what's indexed; a smaller, validated set means cheaper and faster answers without losing quality.
Automate in stages. Let the pipeline archive and merge for a few weeks while you review its decisions. Once it's consistently right, switch to full automation — but keep quality metrics on.

A Production-Grade Example: Databricks
If you want this as a managed system rather than a custom build, platforms like Databricks implement the full pipeline:

Ingestion and OCR at scale. Millions of files, distributed OCR — what used to be a months-long manual project becomes a scheduled job.
Normalization, deduplication, and near-duplicates. Spark runs the embedding pipeline; vector search for k-nearest neighbors is built in.
Models without the plumbing. Serve open models hosted by Databricks — cached weights, optimized inference, pay-per-token (embeddings like GTE-Large included) — or connect external providers like OpenAI, Anthropic, or Bedrock through one governed endpoint: credentials in a single place, rate limits and usage tracking applied centrally. No separate infrastructure to run or maintain.
Metadata and governance (Unity Catalog). Document versions, access controls, full audit trails — so cleaning never accidentally exposes protected data.
One platform for the entire stack. Cleaning, embeddings, vector indexes, and retrieval in one place, not a chain of disconnected tools.

This isn't a vendor endorsement. It's an illustration of what mature data engineering looks like: a governed, scalable system instead of a script that breaks at month three. The pipeline logic matters more than the platform.

The Takeaway
Before considering a larger model, more hires, or new AI initiatives: look at your data.

You don't need a bigger model. You need cleaner data.

A strong model on clean data beats a perfect model on raw, unprocessed data. Every time. The reason most AI projects underdeliver isn't the AI — it's unreliable input: duplicated, outdated, unreadable, and fed straight into the engine.

Clean the data. The model handles the rest.

Context Is the New Code

Sergey Sereda — Mon, 10 Aug 2026 07:46:29 +0000

Many years, the bottleneck in software was writing code. AI just moved the bottleneck. It's no longer "can we build it?" — it's "what context do we give the model?" The companies that win with AI aren't the ones with the biggest models or much more data. They're the ones with the best context.

Here's the shift nobody talks about: AI can already write code, analyze documents, and answer questions faster than any human team. And yet, most AI projects don't deliver 10x results. Why?

Because the hard part moved. It used to be creating the solution. Now it's describing it — completely, precisely, and in a way the model can actually use.

That description is called context. And context engineering is the new core skill of the AI era.

What Is Context, Really?
Context is everything you give the model at the moment it answers: documents, instructions, data, examples. It's the model's working memory — the only memory it has.

Think of it as the brief you hand a consultant before a meeting. The consultant is brilliant — but brilliant is useless without the right brief.

Here's what most companies get wrong: they confuse more context with better context. They stuff the model with every document they own, and the answers get worse. Why?

Everything in context competes for the model's attention. Give it 500 pages, and your key instruction will drown among them. The model doesn't know which of your 200 documents matter for this particular question — so it blends them all into one average, mediocre answer.

A brilliant consultant with a warehouse of unsorted paperwork is slower and more confused than one with three well-chosen documents and a clear goal.

The Big Window Illusion
"Don't worry," the sales pitch says, "our model has a huge context window — you can feed it everything!"

Resist this. A bigger window doesn't solve the problem — it amplifies it. More noise in, more confusion out. The answer to "my AI gives bad answers" is not "give it more stuff." It's almost always "give it the right stuff, at the right moment."

This is where retrieval changes everything: instead of loading your whole library, the system finds the right three documents for each question and loads only those. Your AI becomes not a consultant buried in paperwork, but a consultant who knows exactly which shelf to pull from.

How to Build Better Context (Without Being Technical)
You don't need to write code to improve context. You need to write — clearly.

Create the company briefing. One page: what you do, what your products are, what your terms mean, what the model must never do. This single document improves every AI interaction you have, forever.
Describe data before feeding it. Every dataset you load gets an explanation: what it is, what its fields mean, how it connects to other data. Raw files are material. Explained files are knowledge.
Show examples instead of abstractions. "Answer like these three examples" beats "be professional and helpful" a hundred times over. The model learns patterns from examples, not adjectives.
Delete more than you add. When an answer is wrong, ask: what should the model not have seen? Usually, the fix is less context, not more.
Maintain it like code. Context is not set-and-forget. Products change, policies change, customers change. Version it, review it, update it — like you would any critical document.

The New Economics of Software
For decades, the economics of software were simple: more developers, more features, more cost. AI flips the equation: the marginal cost of building approaches zero. What becomes expensive is specifying — explaining your business to the model well enough to get great results.

And this is good news for the companies that accept it. The skill that used to matter — writing code — is getting cheaper every year. The skill that matters now — understanding your business and explaining it clearly — is becoming your biggest advantage.

Code is no longer the bottleneck. Good context is.

The winners won't be the companies with the most data or the biggest budgets. They'll be the ones who learn to brief their AI like a top consultant: precise, structured, and always up to date.

Stop Feeding Your AI. Start Teaching It

Sergey Sereda — Fri, 07 Aug 2026 20:46:32 +0000

Why the most common mistake I see in AI projects is treating the model like a storage box — and why the human brain is the best user manual we have.

Across finance, e-commerce, and logistics, I keep watching the same mistake play out: when an AI agent underperforms, teams reach for one lever — more data. "Feed it everything we have," they say. The files pile up, and the answers get worse. Not because there's too little data, but because there's too little understanding.

More data doesn't fix a model that doesn't know what the data is, how it connects, and what to do with it. Fixing that requires the same thing you'd give a new employee: a proper onboarding.

Here's the uncomfortable truth: most teams treat AI models like storage boxes, but AI models work more like human brains. And once you understand that, everything changes — how you structure data, how you write prompts, how you evaluate results.

Why the Brain Analogy Is the Right One
An AI model is the closest thing we have to a simplified human brain — and the parallel runs deeper than "it's made of neurons."

Weights = Long-Term Memory
Training adjusts billions of parameters — "weights." This mirrors how a brain consolidates knowledge: you don't memorize each experience, you extract patterns and store them as connections. The model doesn't know your specific invoices; it knows how invoices generally look.

This is why training data quality matters more than volume. You are not teaching the model facts. You are teaching it patterns. A child who learns math through fifty thousand random problems gets less value than one who learns ten well-structured problems with explanations of why the solution works.

Context Window = Working Memory
The context window is your model's working memory — the sticky notes on a person's desk, the brief you hand a consultant before a meeting.

You only have so much room. And everything you put in there competes for the model's attention. Put 500 pages of irrelevant documentation into a small window, and the model will literally lose your instructions — the same way a person forgets the task when you bury it under paperwork.

The message is brutal and liberating: what you leave out of context is as important as what you put in.

The Prompt = The Briefing
A prompt isn't a "query." A prompt is a briefing. Would you hand a senior analyst a folder of data and no instructions and expect a great report? No. You'd tell them:

Who they are (role)
Who the reader is (audience)
What the goal is (outcome)
What constraints apply (format, tone, boundaries)
How to handle edge cases

That's exactly what a system prompt does. A model with a well-written system prompt and mediocre data will outperform a model with perfect data and no instructions — every single time.

Few-Shot Examples = Showing, Not Just Telling
Anyone who has trained a junior employee knows the fastest way to teach isn't explaining — it's showing. "Here are three examples of how we wrote this report. Now do the fourth."

This is few-shot prompting, and it works on models exactly the way apprenticeship works on humans. The model doesn't just learn the rule; it learns the pattern of the rule applied — the tone, the structure, the level of detail.

RAG = The Reference Library
Retrieval-Augmented Generation — the model fetching relevant documents on demand — is the reference shelf next to a consultant's desk. The consultant doesn't memorize the shelf. They know it exists, they know how to search it, and they know when to consult it and when to answer from experience.

A consultant who re-reads the entire library before answering every question is terrible. So is a model that has your whole corpus stuffed in context. Retrieval is about finding the right three documents, not dumping all three thousand.

Where the Analogy Breaks (Say This, It Makes You Credible)
The brain analogy is a lens, not a law. Three honest differences make you sound like you know what you're talking about:

No persistent identity. A model has no memory of your previous conversation unless you rebuild it. Every session is a fresh hire with the same training — you must re-onboard it every time. Work with it: keep a canonical system prompt, keep structure in one place, rebuild context deliberately.
No true understanding. The model predicts tokens; it doesn't "know" the meaning of what it says. It cannot tell you what it doesn't know — it will confidently fabricate (that's "hallucination"). A person who didn't know an answer would say "I don't know." A model says it only if you teach it to.
No causal reasoning by default. Humans infer cause and effect instantly. Models pattern-match. If your data implies a false correlation, the model will faithfully reproduce it.

The expert isn't the person who oversells the metaphor. The expert says: here's the analogy that explains 80% of what you need, and here's the 20% where it breaks. That's how you build trust — and trust turns readers into clients.

The Playbook: Teach, Don't Feed
Here's the sequence we can use with every client. Five steps — none of them is "add more data."

Step 1. Define the job, not the data. Before touching a document, answer: what should this agent do? What does a great answer look like? If you can't describe the job in two sentences, you can't teach it.

Step 2. Map the schema. Every domain has structure: invoices have line items, orders have statuses, tickets have priorities. Write down the entities, their fields, and — critically — how they relate. The model doesn't know what your invoice numbers mean. Explain it.

Step 3. Teach the relationships, not the raw files. Your data lives in silos: CRM, ERP, support tickets. The model doesn't see that a ticket belongs to an order that belongs to a customer. You must build that graph — explicitly — in the context you give it. This is the single most underrated step in AI engineering. Clients ask for "more data" when what they actually need is "the same data, connected."

Step 4. Show examples, set constraints. Three excellent worked examples beat thirty mediocre ones. Write the boundaries: what the agent must never do, what it must always do, how it says "I don't know."

Step 5. Evaluate, then iterate — on structure, not volume. Build a test set of 50 real cases. Score answers. When it fails, ask: is the data there? Is the instruction clear? Is the retrieval finding the right document? In my experience, 90% of failures are structure problems, not data problems. But almost every client starts by adding data.

What I Want You to Remember
If you take one idea from this article, take this:

A model with great data and no instructions is a genius who doesn't know what you want. A model with great instructions is an expert who delivers.

Every time a client says "let's add more data," what they usually mean is "let's get a better result." And the path to a better result runs through understanding — what the data is, how it connects, and what you want the model to do with it.

Treat your AI like a person. Onboard it. Explain the context. Show examples. Set boundaries. And don't drown it in paperwork — you wouldn't do that to a great employee. You'd help them focus.

Your model will thank you. More importantly, your results will.

If you're building an AI agent and it's not performing, I'd bet the problem isn't the model — it's the structure around it.

Show Dev: I built a fast offline calculator hub with Next.js & Cloudflare

Sergey Sereda — Tue, 10 Feb 2026 21:17:47 +0000

Hi everyone! I’m a full-stack engineer and like many of you, I’m tired of “utility” websites that are bloated with ads, cookies, painfully slow, and overloaded with trackers.

So I decided to build qalc.ai — a clean, lightning-fast hub for calculators and practical tools that actually respect the user experience.

It works fully offline after the first load, has no intrusive pop-ups, and only a single small banner ad that can be closed for the entire day without interrupting anything.

Originally, I built most of these tools for myself — things I was constantly calculating or Googling while working with finance, crypto, and everyday conversions. Over time, it turned into a growing collection of calculators and productivity tools that I now keep expanding.

The Tech Stack 🛠️

To keep it fast, scalable, and SEO-friendly:
Frontend: Next.js (App Router) for SSR + ISR
Styling: Tailwind CSS with shadcn UI
Edge & SEO: Cloudflare caching + IndexNow for instant indexing
Logic: Pure TypeScript (no heavy backend)

UX Philosophy:
Works offline
No clutter
No annoying ads
No tracking
Just input → result

I’d Love Your Feedback 🎤

I’d really appreciate a technical roast or constructive feedback:
Performance: Does it feel instant?
UI/UX: Is navigation clear?
Features: What calculator or tool do you Google most often?

👉 https://qalc.ai

Thanks for checking it out — happy hacking! 🚀