DeFi Lending Strategies for AI Agents: Aave, Compound & Spark Explained

DeFi lending protocols are among the most useful tools an AI agent can hold in its financial toolkit. They serve two completely different purposes simultaneously: passive yield for agents with idle capital, and leverage access for agents that want to amplify their market exposure without selling existing holdings. A USDC-holding agent can earn 4–8% APY on Aave V3 while doing nothing else. An ETH-holding agent can borrow against that ETH to access trading capital, effectively turning a 1 ETH position into 1.3 ETH of deployed capital at a cost of whatever the borrow rate is. When that rate is lower than the expected return on the borrowed capital, the agent prints money. When it is not, the agent bleeds. Managing this ratio is the core skill of DeFi lending.

Why AI Agents Use Lending Protocols

Human DeFi users often supply assets and walk away, checking in weekly. AI agents can do something humans cannot: monitor health factors in real time, respond to rate changes within seconds, and execute complex rebalancing operations across multiple protocols simultaneously. This changes the risk-reward calculus significantly. Strategies that would be too operationally intensive for a human — like recursive leverage loops that require active monitoring — become viable when an agent is checking health factors every 60 seconds and can trigger an auto-repay transaction in under three seconds.

The three leading protocols each occupy a slightly different niche. Aave V3 has the deepest liquidity and most supported assets — 30+ collateral types across Ethereum, Arbitrum, Base, and Polygon. Compound V3 takes a simpler architecture with fewer but larger markets and a focus on USDC as the primary borrowable asset. Spark Protocol is the MakerDAO-affiliated fork of Aave V3 offering subsidized DAI borrow rates that are often 1–2% below market. Purple Flea's lending API abstracts across all three with a unified interface, routing your supply and borrow operations to the protocol with the best current rate for your chosen asset pair.

Aave V3 Architecture: Supply, Borrow, and Health Factor

Before implementing any strategy, you need a precise mental model of how Aave V3 works. The protocol maintains two markets per supported asset: a supply market (where lenders earn interest) and a borrow market (where borrowers pay interest). Your position is characterized by three numbers:

• Total Collateral (in USD): the USD value of all assets you have supplied as collateral.
• Total Debt (in USD): the USD value of all assets you have borrowed.
• Health Factor (HF): the ratio of weighted collateral to debt. HF below 1.0 triggers liquidation.

Each asset has a Loan-to-Value (LTV) parameter — the maximum percentage of that asset's value you can borrow against — and a Liquidation Threshold slightly above the LTV. ETH on Aave V3 Ethereum has an 80% LTV and an 82.5% liquidation threshold. This means for every $1,000 of ETH you supply, you can borrow up to $800 USDC, but you will not be liquidated until your debt reaches $825.

Three Strategies: Conservative, Moderate, and Aggressive

Implementing the Conservative Strategy

from purpleflea import PurpleFleaClient
import os

pf = PurpleFleaClient(api_key=os.environ["PURPLEFLEA_API_KEY"], mnemonic=os.environ["AGENT_MNEMONIC"])

async def deploy_conservative_yield(amount_usdc: float):
    """Supply USDC to the highest-yielding protocol. No borrowing."""
    # Find the best supply rate across Aave, Compound, Spark
    rates = await pf.lending.get_supply_rates(token="USDC")
    best = max(rates, key=lambda r: r["apy"])
    print(f"Best rate: {best['protocol']} at {best['apy']:.2%} APY")

    # Supply to the winning protocol
    result = await pf.lending.supply(
        protocol=best["protocol"],
        token="USDC",
        amount=amount_usdc,
        chain="arbitrum",  # Arbitrum has lower gas costs
    )
    return result
    # Returns: {"tx_hash": "0x...", "supplied": 5000.0,
    #           "protocol": "aave_v3", "apy": 0.0672, "chain": "arbitrum"}

async def check_position():
    pos = await pf.lending.get_position()
    print(f"Supplied: ${pos['total_supplied_usd']:,.2f}")
    print(f"Earned today: ${pos['interest_earned_today_usd']:,.4f}")
    print(f"APY blended: {pos['blended_supply_apy']:.2%}")

Implementing the Moderate Strategy

async def deploy_moderate_strategy(eth_amount: float):
    """Supply ETH, borrow 30% USDC, deploy USDC for additional yield."""
    # Step 1: Supply ETH as collateral on Aave V3
    supply_result = await pf.lending.supply(
        protocol="aave_v3", token="ETH", amount=eth_amount, chain="ethereum"
    )
    eth_usd = supply_result["usd_value"]
    print(f"Supplied {eth_amount} ETH (${eth_usd:,.2f})")

    # Step 2: Borrow 30% of ETH value in USDC — keeps HF around 2.75
    borrow_amount = eth_usd * 0.30
    borrow_result = await pf.lending.borrow(
        protocol="aave_v3", token="USDC",
        amount=borrow_amount, chain="ethereum"
    )
    hf = borrow_result["health_factor"]
    print(f"Borrowed ${borrow_amount:,.2f} USDC. Health factor: {hf:.2f}")

    # Step 3: Deploy borrowed USDC for yield
    yield_result = await pf.lending.supply(
        protocol="spark", token="USDC", amount=borrow_amount, chain="ethereum"
    )
    print(f"Deployed USDC to Spark. APY: {yield_result['apy']:.2%}")
    return {"health_factor": hf, "net_apy_estimate": yield_result["apy"] - borrow_result["borrow_rate"]}

Health Factor Monitoring and Auto-Repay

The most critical component of any leveraged lending position is the automated safety system. An agent that holds a leveraged position must monitor the health factor continuously and trigger a partial repay before the liquidation threshold is reached. The difference between a managed drawdown and a catastrophic liquidation is the speed of the auto-repay transaction:

import asyncio

AUTO_REPAY_THRESHOLD = 1.2
ALERT_THRESHOLD = 1.5
POLL_INTERVAL_SECONDS = 60

async def monitor_health_factor(pf, notify_fn=None):
    """Poll health factor every 60 seconds. Auto-repay if HF drops below 1.2."""
    while True:
        position = await pf.lending.get_position()
        hf = position["health_factor"]

        if hf < AUTO_REPAY_THRESHOLD:
            # Emergency: repay 20% of debt to bring HF back to ~1.5
            debt_usd = position["total_debt_usd"]
            repay_amount = debt_usd * 0.20
            repay_result = await pf.lending.repay(
                protocol="aave_v3", token="USDC",
                amount=repay_amount, chain="ethereum"
            )
            if notify_fn:
                await notify_fn(f"AUTO-REPAY: HF was {hf:.2f}. Repaid ${repay_amount:,.0f}. New HF: {repay_result['health_factor']:.2f}")

        elif hf < ALERT_THRESHOLD:
            if notify_fn:
                await notify_fn(f"ALERT: Health factor at {hf:.2f}. Consider partial repay.")

        await asyncio.sleep(POLL_INTERVAL_SECONDS)

Flash Loan Arbitrage: Borrow $1M for One Transaction

Flash loans are Aave's most powerful primitive for AI agents. A flash loan lets you borrow any amount of any supported asset with zero collateral — as long as you repay it within the same Ethereum transaction. This sounds impossible until you realize that transaction atomicity means the repayment is guaranteed: if you cannot repay, the entire transaction reverts as if it never happened. For arbitrage agents, this enables a critical pattern: borrow $1M USDC, buy ETH on one DEX where it is cheaper, sell ETH on another DEX where it is more expensive, repay the $1M plus the 0.09% Aave flash loan fee, pocket the difference — all in a single block.

async def execute_flash_arb(pf, opportunity: dict):
    """Execute a DEX arbitrage using Aave flash loan.

    opportunity = {
        "token": "ETH",
        "buy_dex": "uniswap_v3",
        "sell_dex": "curve",
        "buy_price_usd": 2840.50,
        "sell_price_usd": 2849.20,
        "optimal_size_eth": 35.2,
        "expected_profit_usd": 305.84
    }
    """
    # Verify the opportunity is still valid before borrowing
    current_prices = await pf.prices.get_batch([
        {"token": opportunity["token"], "dex": opportunity["buy_dex"]},
        {"token": opportunity["token"], "dex": opportunity["sell_dex"]},
    ])
    spread = current_prices[1]["price"] - current_prices[0]["price"]
    if spread < 5.0:  # Minimum $5 spread to cover gas + flash loan fee
        return {"status": "skipped", "reason": "spread_too_small"}

    # Execute flash loan arbitrage as a single atomic transaction
    loan_amount_usdc = opportunity["optimal_size_eth"] * current_prices[0]["price"]
    result = await pf.lending.flash_loan_arb(
        borrow_token="USDC",
        borrow_amount=loan_amount_usdc,
        steps=[
            {"action": "buy",  "token": "ETH", "dex": opportunity["buy_dex"]},
            {"action": "sell", "token": "ETH", "dex": opportunity["sell_dex"]},
        ],
        protocol="aave_v3",
    )
    return result
    # Returns: {"profit_usd": 298.40, "gas_cost_usd": 12.30,
    #           "net_profit_usd": 286.10, "tx_hash": "0x..."}

Risks: Liquidation, Rate Volatility, and Smart Contract Risk

No DeFi strategy discussion is complete without an honest risk inventory. Three risks dominate:

Borrow rate volatility is subtler. Aave V3 rates are algorithmically determined by utilization. When the USDC market goes from 50% to 95% utilization — which can happen in hours during market stress — the borrow rate can jump from 5% to 40% annualized. An agent that opened a position at 5% borrow can suddenly find its carry trade inverted. Monitor the spread between your yield and borrow rate; unwind when the spread compresses below 1%.

Smart contract risk is background but non-zero. Aave V3 has been audited extensively and holds over $20B TVL, but no smart contract is perfectly safe. Diversify across protocols rather than concentrating all capital in one. Purple Flea's lending API supports automatic rebalancing across Aave, Compound, and Spark to spread this risk while chasing the best rates simultaneously.