DeFi Yield Farming with AI Agents: Automated Liquidity Mining

Liquidity mining is a race against dilution. When a new pool launches with a 200% APY in governance token rewards, that rate collapses within days as capital floods in. The protocols that sustain meaningful yields are those where the base lending rate is high because genuine borrowing demand exists — not just mercenary capital chasing token emissions that will inflate away. An AI agent that can distinguish these two yield types, rotate capital between hundreds of pools across multiple chains, auto-compound rewards before they decay in value, and split profits with co-investors trustlessly — that agent has a permanent structural edge over any human operator.

This guide covers how to build such an agent using the Purple Flea Trading API for execution and Purple Flea Escrow for trustless profit distribution among agent syndicates.

Why Automated LP Management Changes the Game

Traditional liquidity provision requires constant manual oversight. A position in a Uniswap V3 concentrated liquidity pool can go out of range if the price moves beyond your set bounds — at that point you stop earning fees entirely and simply hold a static mix of the two assets, fully exposed to price drift with zero yield. Rebalancing manually is expensive in gas and mental overhead.

Automated LP management solves this with three core capabilities:

• Range monitoring: Track the current price against your LP position bounds in real time. Trigger a rebalance event when price approaches within 5% of either boundary.
• Gas-adjusted rotation: Only rotate to a new range if the estimated additional fees from the new position exceed the gas cost of the rebalancing transaction within a configurable time horizon (e.g., 72 hours).
• Compound harvesting: Collect accumulated fees from the position and reinvest them into the pool, compounding the effective yield. For a position earning $50/day in fees, daily compounding at 18% APY adds approximately 0.5% to the effective annual return versus weekly compounding.

For stable pairs (USDC/USDT, USDC/DAI) the math is especially favorable. Volatility is near zero, impermanent loss is negligible, and tight concentrated liquidity ranges earn disproportionately high fee shares. Agents managing stablecoin LP positions on Uniswap V3 and Curve routinely outperform pure lending rates by 3-8% APY.

Understanding Risk-Adjusted Returns in Yield Farming

Raw APY figures are nearly meaningless without understanding what risk is embedded in them. A yield farming position with 40% APY might be less attractive than one with 8% APY once you account for:

Impermanent Loss (IL)

When you provide liquidity to a volatile pair like ETH/USDC, you implicitly sell ETH as its price rises and buy ETH as its price falls. If ETH doubles in price during your LP tenure, you lose approximately 5.7% compared to simply holding the 50/50 mix outside the pool. For a 40% APY position with high ETH volatility, IL can consume 15-25% of returns in a bull market, leaving you with 15-25% effective APY — still good, but not the number on the tin. Your agent should model expected IL using historical volatility data before committing capital.

Smart Contract Risk

Every new protocol is a new attack surface. The canonical metric is time-value-locked: how many dollars of capital have been secured in this contract for how many months without exploit? Aave V3 with $12B TVL across 24 months is categorically different from a new fork with $50M TVL across 3 weeks. Agents should enforce a minimum TVL threshold and minimum age requirement for any protocol they interact with.

Token Emission Risk

Rewards denominated in governance tokens are only worth what those tokens trade for. An agent that claims COMP, CRV, or CVX rewards and immediately sells them into stablecoins locks in the current price and eliminates token-price uncertainty. Alternatively, the agent can model expected token price based on emission schedules and staking demand to decide when to hold vs. sell.

Python: Yield Optimizer Agent Core Logic

The following Python script demonstrates a production-ready yield optimization agent. It polls the Purple Flea Trading API for current pool APYs, computes risk-adjusted scores, and rotates capital to the highest-scoring position when the spread justifies gas costs.

import asyncio
import httpx
import math
from dataclasses import dataclass
from typing import List, Optional

PURPLE_FLEA_API = "https://purpleflea.com/trading-api"
API_KEY = "your_api_key_here"
# Get a free API key at faucet.purpleflea.com

@dataclass
class PoolPosition:
    protocol: str
    pool_id: str
    asset_pair: str
    base_apy: float          # denominated in deposit asset
    reward_apy: float        # denominated in reward token
    tvl_usd: float
    age_days: int
    il_30d: float            # historical IL over 30 days
    current_capital: float   # our deployed capital in USD

def risk_adjusted_score(pool: PoolPosition) -> float:
    """Compute a risk-adjusted score for a yield farming position.
    Higher is better. Accounts for IL, smart contract risk, and
    reward token haircut.
    """
    # Haircut reward APY by 30% to account for token price risk
    effective_apy = pool.base_apy + (pool.reward_apy * 0.70)

    # Deduct expected IL (annualized from 30d historical)
    annualized_il = pool.il_30d * 12
    net_apy = effective_apy - annualized_il

    # Smart contract risk discount: newer/smaller protocols penalized
    tvl_factor = math.log10(max(pool.tvl_usd, 1_000_000)) / 10
    age_factor = min(pool.age_days / 365, 1.0)
    sc_confidence = (tvl_factor + age_factor) / 2

    return net_apy * sc_confidence

async def fetch_top_pools(
    asset: str = "USDC",
    min_tvl: float = 10_000_000,
    min_age_days: int = 90
) -> List[PoolPosition]:
    """Fetch pool data from Purple Flea Trading API."""
    async with httpx.AsyncClient() as client:
        resp = await client.get(
            f"{PURPLE_FLEA_API}/v1/pools",
            params={
                "asset": asset,
                "min_tvl": min_tvl,
                "chains": "ethereum,arbitrum,base",
                "include_il_history": "true"
            },
            headers={"X-API-Key": API_KEY}
        )
        data = resp.json()

    pools = []
    for p in data["pools"]:
        if p["age_days"] < min_age_days:
            continue
        pools.append(PoolPosition(
            protocol=p["protocol"],
            pool_id=p["pool_id"],
            asset_pair=p["pair"],
            base_apy=p["base_apy"],
            reward_apy=p["reward_apy"],
            tvl_usd=p["tvl_usd"],
            age_days=p["age_days"],
            il_30d=p["il_30d_pct"],
            current_capital=0.0
        ))
    return sorted(pools, key=risk_adjusted_score, reverse=True)

async def should_rotate(
    current: PoolPosition,
    candidate: PoolPosition,
    gas_cost_usd: float,
    capital_usd: float,
    horizon_days: int = 30
) -> bool:
    """Determine if rotating is justified after gas costs."""
    apy_spread = risk_adjusted_score(candidate) - risk_adjusted_score(current)
    if apy_spread <= 0:
        return False
    # Additional yield from rotation over the horizon
    incremental_yield = capital_usd * (apy_spread / 100) * (horizon_days / 365)
    breakeven_ratio = incremental_yield / gas_cost_usd
    return breakeven_ratio > 3.0  # require 3x gas cost coverage

async def compound_rewards(pool_id: str, wallet_address: str):
    """Claim and reinvest accrued rewards."""
    async with httpx.AsyncClient() as client:
        resp = await client.post(
            f"{PURPLE_FLEA_API}/v1/positions/{pool_id}/compound",
            json={
                "wallet": wallet_address,
                "sell_rewards_to": "USDC",
                "reinvest": True
            },
            headers={"X-API-Key": API_KEY}
        )
        result = resp.json()
    print(f"Compounded: {result['rewards_usd']:.2f} USDC reinvested")

async def main():
    wallet = "0xYourAgentWallet"
    capital = 50_000  # USD

    while True:
        pools = await fetch_top_pools()
        best = pools[0]
        print(f"Best pool: {best.protocol}/{best.asset_pair}")
        print(f"  Score: {risk_adjusted_score(best):.2f}%")

        # Compound existing rewards every 24h cycle
        await compound_rewards(best.pool_id, wallet)

        await asyncio.sleep(86400)  # check daily

asyncio.run(main())

Compound Yield Mathematics

The compounding interval has a meaningful impact on final returns, especially at higher APYs. For a $50,000 position at 12% nominal APY:

The formula is A = P * (1 + r/n)^(n*t) where P is principal, r is nominal APY, n is compounding periods per year, and t is time in years. At 12% APY, the difference between annual and daily compounding is $381 on a $50k position. At 25% APY with daily compounding, the difference against annual compounding is over $2,800 — worth automating.

JavaScript: Automated LP Range Manager

The following JavaScript module manages Uniswap V3 concentrated liquidity positions. It monitors price relative to tick range, detects when a position goes out of range, and triggers rebalancing via the Purple Flea Trading API.

import { createPublicClient, http, parseAbi } from 'viem'
import { arbitrum } from 'viem/chains'

const PURPLE_FLEA_API = 'https://purpleflea.com/trading-api'
const UNISWAP_V3_POOL_ABI = parseAbi([
  'function slot0() view returns (uint160 sqrtPriceX96, int24 tick, uint16, uint16, uint16, uint8, bool)',
  'function positions(bytes32 key) view returns (uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128, uint128 tokensOwed0, uint128 tokensOwed1)'
])

const client = createPublicClient({
  chain: arbitrum,
  transport: http('https://arb1.arbitrum.io/rpc')
})

async function getCurrentTick(poolAddress) {
  const [, tick] = await client.readContract({
    address: poolAddress,
    abi: UNISWAP_V3_POOL_ABI,
    functionName: 'slot0'
  })
  return Number(tick)
}

async function checkPositionHealth(position) {
  const { poolAddress, tickLower, tickUpper, positionId } = position
  const currentTick = await getCurrentTick(poolAddress)

  const inRange = currentTick >= tickLower && currentTick <= tickUpper
  const rangeWidth = tickUpper - tickLower
  const distanceToLower = currentTick - tickLower
  const distanceToUpper = tickUpper - currentTick
  const positionInRange = Math.min(distanceToLower, distanceToUpper) / rangeWidth

  return {
    positionId,
    inRange,
    currentTick,
    tickLower,
    tickUpper,
    positionInRange,   // 0 = at edge, 0.5 = perfectly centered
    needsRebalance: !inRange || positionInRange < 0.05
  }
}

async function triggerRebalance(positionId, apiKey) {
  const res = await fetch(`${PURPLE_FLEA_API}/v1/lp/rebalance`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-API-Key': apiKey
    },
    body: JSON.stringify({
      position_id: positionId,
      strategy: 'center_on_price',
      range_multiplier: 1.5,       // ±1.5x current price range
      slippage_tolerance: 0.005    // 0.5% slippage max
    })
  })
  const data = await res.json()
  console.log(`Rebalanced position ${positionId}: new ticks [${data.tick_lower}, ${data.tick_upper}]`)
  return data
}

async function collectAndCompound(positionId, apiKey) {
  const res = await fetch(`${PURPLE_FLEA_API}/v1/lp/collect`, {
    method: 'POST',
    headers: { 'X-API-Key': apiKey },
    body: JSON.stringify({ position_id: positionId, reinvest: true })
  })
  const data = await res.json()
  console.log(`Collected fees: $${data.fees_usd.toFixed(2)} — reinvested`)
}

// Main monitoring loop
export async function runLPManager(positions, apiKey) {
  for (const pos of positions) {
    const health = await checkPositionHealth(pos)
    console.log(`Position ${health.positionId}: inRange=${health.inRange}, center=${(health.positionInRange*100).toFixed(1)}%`)

    if (health.needsRebalance) {
      console.log('Out of range — triggering rebalance')
      await triggerRebalance(health.positionId, apiKey)
    } else {
      // Compound fees every iteration regardless
      await collectAndCompound(health.positionId, apiKey)
    }
  }
}

Profit Sharing with Purple Flea Escrow

Many yield farming operations involve multiple parties: a capital provider who supplies the USDC, an agent developer who built and runs the automation, and possibly a risk analyst who configured the allocation strategy. Splitting profits from a shared pool manually creates trust problems — who controls the wallet? Who decides when to distribute?

Purple Flea Escrow solves this with trustless multi-party profit distribution. The escrow contract holds the yield farming profits and releases them according to pre-agreed percentage splits, triggered automatically when the balance exceeds a threshold.

To set up an escrow vault for profit sharing, POST to https://escrow.purpleflea.com/api/vaults/create with your participant wallet addresses and percentage allocations. The vault address can then receive yield farming profits directly, with no intermediary or manual custody required.

Protocols and Chain Selection for 2026

Not all chains offer the same yield opportunities. Gas costs, liquidity depth, and protocol maturity vary significantly. Here is a comparison of the top chains for yield farming agents in early 2026:

For high-frequency LP rebalancing (daily or more), Arbitrum or Solana are the only practical choices — Ethereum gas costs make daily rebalancing economically unviable except for very large positions (above $500k). For passive set-and-compound strategies, Ethereum mainnet's deep liquidity and battle-tested contracts are often preferable despite the higher gas overhead.

Building a Risk Framework for Your Agent

Every yield farming agent needs explicit risk limits to prevent catastrophic losses from smart contract exploits, oracle manipulation, or liquidity crises. Recommended guardrails:

• Maximum protocol concentration: No single protocol should hold more than 40% of the portfolio. If Aave V3 is exploited, you lose at most 40%.
• Minimum age requirement: Never deploy to a protocol with less than 90 days of live production history, regardless of APY.
• TVL floor: Avoid protocols below $10M TVL. Below this threshold, a single large exit can move the market enough to impact your own withdrawal price.
• Daily loss limit: If portfolio value drops more than 3% in 24 hours, halt all new deployments and alert human operators. This catches oracle manipulation and depeg events early.
• Stablecoin peg monitoring: Track the DEX price of every stablecoin in your portfolio. If USDC depegs below $0.995 on-chain, trigger emergency withdrawals.