Options Trading Strategies for AI Agents: Covered Calls, Puts, and Spreads

Options are the most powerful instrument in a trader's toolkit — and AI agents are uniquely suited to exploit them. No emotional bias, no fatigue-induced mistakes, instantaneous Greeks recalculation, and 24/7 operation. This guide covers the full options strategy stack for agents: fundamentals, Black-Scholes pricing, delta hedging, covered calls, protective puts, iron condors, and how Purple Flea Trading perpetual futures serve as options-like instruments in a crypto-native portfolio.

1. Options Fundamentals for AI Agents

An option is a contract that gives the buyer the right but not the obligation to buy (call) or sell (put) an underlying asset at a specified price (strike) before or on a specified date (expiry). The seller of the option collects a premium upfront in exchange for bearing this obligation.

For AI agents, options are interesting for three reasons: (1) they allow precise risk definition — maximum loss is the premium paid, (2) they generate income through premium collection strategies, and (3) they allow directional bets with defined leverage through buying calls/puts.

Calls vs. Puts

A call option profits when the underlying rises above the strike price. A put option profits when the underlying falls below the strike. The premium is determined by the option pricing model — intrinsic value plus time value plus volatility premium.

2. The Greeks: What Every Agent Must Track

The "Greeks" are sensitivity measures that quantify how an option's price changes in response to various market conditions. An agent that tracks all five Greeks in real time can manage a multi-leg options portfolio with precision no human trader can match.

3. Black-Scholes Pricing in Python

The Black-Scholes model prices European options using five inputs: underlying price (S), strike price (K), time to expiry (T, in years), risk-free rate (r), and implied volatility (sigma). Here's a complete Python implementation with all five Greeks:

import numpy as np
from scipy.stats import norm
from dataclasses import dataclass
from typing import Literal

@dataclass
class OptionGreeks:
    price: float
    delta: float
    gamma: float
    theta: float   # per calendar day
    vega: float    # per 1% change in IV
    rho: float     # per 1% change in interest rate
    iv: float      # implied volatility used

class BlackScholes:
    """
    European option pricing via Black-Scholes.
    For American options (early exercise), use binomial tree instead.
    """

    @staticmethod
    def d1(S: float, K: float, T: float, r: float, sigma: float) -> float:
        return (np.log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))

    @staticmethod
    def d2(S: float, K: float, T: float, r: float, sigma: float) -> float:
        return BlackScholes.d1(S, K, T, r, sigma) - sigma * np.sqrt(T)

    @classmethod
    def price(cls, S: float, K: float, T: float, r: float, sigma: float,
              option_type: Literal['call', 'put']) -> float:
        if T <= 0:
            return max(0, S - K) if option_type == 'call' else max(0, K - S)
        d1 = cls.d1(S, K, T, r, sigma)
        d2 = cls.d2(S, K, T, r, sigma)
        if option_type == 'call':
            return S * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
        else:
            return K * np.exp(-r * T) * norm.cdf(-d2) - S * norm.cdf(-d1)

    @classmethod
    def greeks(cls, S: float, K: float, T: float, r: float, sigma: float,
              option_type: Literal['call', 'put']) -> OptionGreeks:
        if T <= 0 or sigma <= 0:
            return OptionGreeks(price=0, delta=0, gamma=0, theta=0, vega=0, rho=0, iv=sigma)

        d1 = cls.d1(S, K, T, r, sigma)
        d2 = cls.d2(S, K, T, r, sigma)
        price = cls.price(S, K, T, r, sigma, option_type)

        # Delta: rate of change of price w.r.t. underlying
        if option_type == 'call':
            delta = norm.cdf(d1)
        else:
            delta = norm.cdf(d1) - 1

        # Gamma: rate of change of delta (same for calls and puts)
        gamma = norm.pdf(d1) / (S * sigma * np.sqrt(T))

        # Theta: daily time decay (divide by 365)
        term1 = -(S * norm.pdf(d1) * sigma) / (2 * np.sqrt(T))
        if option_type == 'call':
            theta = (term1 - r * K * np.exp(-r * T) * norm.cdf(d2)) / 365
        else:
            theta = (term1 + r * K * np.exp(-r * T) * norm.cdf(-d2)) / 365

        # Vega: per 1% change in IV
        vega = S * norm.pdf(d1) * np.sqrt(T) * 0.01

        # Rho: per 1% change in interest rate
        if option_type == 'call':
            rho = K * T * np.exp(-r * T) * norm.cdf(d2) * 0.01
        else:
            rho = -K * T * np.exp(-r * T) * norm.cdf(-d2) * 0.01

        return OptionGreeks(
            price=round(price, 4), delta=round(delta, 4),
            gamma=round(gamma, 6), theta=round(theta, 4),
            vega=round(vega, 4), rho=round(rho, 4), iv=sigma
        )

# Example: BTC call option
btc_price = 85000
strike = 90000    # out-of-the-money call
days_to_expiry = 30
iv = 0.65         # 65% annualized implied volatility (typical for BTC)
risk_free = 0.05  # 5% risk-free rate

g = BlackScholes.greeks(
    S=btc_price, K=strike,
    T=days_to_expiry/365,
    r=risk_free, sigma=iv,
    option_type='call'
)

print(f"Option price: ${g.price:,.2f}")    # → ~$4,120
print(f"Delta: {g.delta:.4f}")            # → ~0.3521
print(f"Gamma: {g.gamma:.6f}")            # → ~0.000012
print(f"Theta (daily decay): ${g.theta:.2f}") # → ~-$85/day
print(f"Vega (per 1% IV): ${g.vega:.2f}") # → ~$420/1% IV move

4. Why AI Agents Excel at Options Trading

Options strategies demand continuous attention that human traders cannot sustain. Consider what's required to manage a 10-leg options portfolio properly:

• Recalculate all Greeks every minute as the underlying moves
• Monitor gamma risk as options approach expiry (gamma spikes violently near expiry)
• Adjust delta hedges when delta drifts beyond tolerance bands
• Roll positions before expiry to avoid assignment
• Respond to IV changes that affect the entire portfolio's vega exposure
• Execute multi-leg spread adjustments atomically to avoid legging risk

A human trader managing this manually would need to be at the screen 24/7. An AI agent does it automatically, with sub-second reaction time and zero emotional interference. The agent never hesitates to cut a losing position because of loss aversion, and never overweights a winning position due to overconfidence.

5. Covered Call Strategy Implementation

A covered call is the most conservative options strategy: you hold the underlying asset and sell call options against it, collecting premium. Your upside is capped at the strike price, but you earn yield on the position regardless of price direction (as long as the underlying doesn't crash below your cost basis).

from dataclasses import dataclass, field
from typing import Optional, List
import time

@dataclass
class CoveredCallPosition:
    underlying_qty: float      # e.g. 0.1 BTC
    underlying_cost: float     # cost basis in USD
    strike: float
    expiry_days: int
    premium_received: float
    option_id: Optional[str] = None
    opened_at: float = field(default_factory=time.time)

class CoveredCallAgent:
    """
    Agent that manages a covered call wheel strategy:
    1. Hold underlying
    2. Sell calls at target delta (0.25-0.30)
    3. Let expire worthless → collect premium
    4. Roll if needed (underlying threatens strike)
    5. Repeat monthly
    """

    def __init__(self, pf_client, target_delta: float = 0.28,
                 days_to_sell: int = 30, roll_threshold: float = 0.65):
        self.pf = pf_client
        self.target_delta = target_delta
        self.days_to_sell = days_to_sell
        self.roll_threshold = roll_threshold  # roll when delta exceeds this
        self.positions: List[CoveredCallPosition] = []
        self.bs = BlackScholes()
        self.total_premium_collected = 0.0

    def find_target_strike(self, spot: float, iv: float, days: int) -> float:
        """
        Find the strike price that gives our target delta via binary search.
        Returns strike price for a 30-delta OTM call.
        """
        lo, hi = spot, spot * 2.0
        T = days / 365
        for _ in range(50):
            mid = (lo + hi) / 2
            g = self.bs.greeks(spot, mid, T, 0.05, iv, 'call')
            if abs(g.delta - self.target_delta) < 0.001:
                break
            if g.delta > self.target_delta:
                lo = mid
            else:
                hi = mid
        return round(mid, -2)  # round to nearest $100

    def should_roll(self, position: CoveredCallPosition, current_spot: float,
                    current_iv: float) -> bool:
        """Roll the call if delta has risen too high (underlying ripping)."""
        days_remaining = position.expiry_days - (time.time() - position.opened_at) / 86400
        T = max(days_remaining, 0.01) / 365
        g = self.bs.greeks(current_spot, position.strike, T, 0.05, current_iv, 'call')
        return g.delta > self.roll_threshold

    def open_covered_call(self, symbol: str, qty: float, spot: float, iv: float) -> CoveredCallPosition:
        strike = self.find_target_strike(spot, iv, self.days_to_sell)
        T = self.days_to_sell / 365
        g = self.bs.greeks(spot, strike, T, 0.05, iv, 'call')
        premium = g.price * qty

        # Sell the call via Purple Flea options API
        order = self.pf.sell_option(
            symbol=symbol,
            strike=strike,
            expiry_days=self.days_to_sell,
            qty=qty,
            option_type='call'
        )

        pos = CoveredCallPosition(
            underlying_qty=qty,
            underlying_cost=spot,
            strike=strike,
            expiry_days=self.days_to_sell,
            premium_received=premium,
            option_id=order.get('id')
        )
        self.positions.append(pos)
        self.total_premium_collected += premium
        print(f"Sold {self.days_to_sell}d call: strike=${strike:,.0f} | delta={g.delta:.2f} | premium=${premium:.2f}")
        return pos

    def manage_positions(self, current_spot: float, current_iv: float):
        """Called periodically to manage open covered call positions."""
        for pos in list(self.positions):
            if self.should_roll(pos, current_spot, current_iv):
                print(f"Rolling call: spot ${current_spot:,.0f} has exceeded strike ${pos.strike:,.0f} threshold")
                # Close current short call
                self.pf.close_option(pos.option_id)
                self.positions.remove(pos)
                # Open new call at higher strike
                self.open_covered_call("BTC-USD", pos.underlying_qty, current_spot, current_iv)

    def monthly_yield(self) -> float:
        """Annualized yield from premium collection."""
        if not self.positions:
            return 0.0
        total_underlying_value = sum(p.underlying_qty * p.underlying_cost for p in self.positions)
        return (self.total_premium_collected / total_underlying_value) * 100

6. Put Protection Strategy

A protective put is portfolio insurance: you hold the underlying and buy put options below the current price. If the underlying crashes, the put gains value, limiting your downside. The cost is the put premium — your insurance cost.

class PutProtectionManager:
    """
    Manages protective puts as portfolio insurance.
    Combines with covered calls in a 'collar' strategy to finance the put.
    """

    def __init__(self, pf_client, protection_level: float = 0.90):
        """
        protection_level: e.g. 0.90 means put strike at 90% of spot (10% OTM)
        """
        self.pf = pf_client
        self.protection_level = protection_level
        self.bs = BlackScholes()
        self.puts: list = []

    def open_protective_put(self, symbol: str, qty: float,
                             spot: float, iv: float, days: int) -> dict:
        strike = round(spot * self.protection_level, -2)
        T = days / 365
        g = self.bs.greeks(spot, strike, T, 0.05, iv, 'put')
        total_premium = g.price * qty

        order = self.pf.buy_option(
            symbol=symbol,
            strike=strike,
            expiry_days=days,
            qty=qty,
            option_type='put'
        )

        put_rec = {
            'symbol': symbol,
            'strike': strike,
            'qty': qty,
            'premium_paid': total_premium,
            'delta': g.delta,
            'expiry_days': days,
            'id': order.get('id'),
            'opened_ts': time.time()
        }
        self.puts.append(put_rec)
        print(f"Opened protective put: strike=${strike:,.0f} | delta={g.delta:.3f} | cost=${total_premium:.2f}")
        return put_rec

    def collar_net_cost(self, spot: float, iv: float, days: int,
                        call_delta: float = 0.25,
                        put_delta: float = -0.20) -> dict:
        """
        Calculate net cost of a collar: short call + long put.
        If call premium > put premium, the collar generates net income (zero-cost collar).
        """
        bs = BlackScholes()
        T = days / 365

        # Find call strike for target delta
        call_strike = self._find_strike(spot, T, iv, call_delta, 'call')
        call_g = bs.greeks(spot, call_strike, T, 0.05, iv, 'call')

        # Find put strike for target delta
        put_strike = self._find_strike(spot, T, iv, abs(put_delta), 'put')
        put_g = bs.greeks(spot, put_strike, T, 0.05, iv, 'put')

        net_credit = call_g.price - put_g.price
        return {
            'call_strike': call_strike, 'call_premium': call_g.price,
            'put_strike': put_strike, 'put_premium': put_g.price,
            'net_credit': net_credit,
            'zero_cost_collar': net_credit >= 0
        }

    def _find_strike(self, S, T, sigma, target_delta, option_type) -> float:
        lo = S * 0.5 if option_type == 'put' else S
        hi = S if option_type == 'put' else S * 2.0
        for _ in range(50):
            mid = (lo + hi) / 2
            g = BlackScholes().greeks(S, mid, T, 0.05, sigma, option_type)
            delta_abs = abs(g.delta)
            if abs(delta_abs - target_delta) < 0.001:
                break
            if option_type == 'call':
                if delta_abs > target_delta: lo = mid
                else: hi = mid
            else:
                if delta_abs > target_delta: hi = mid
                else: lo = mid
        return round(mid, -2)

7. Iron Condor for Range-Bound Markets

An iron condor is the premium options strategy for range-bound, low-volatility environments. It sells an OTM call spread and an OTM put spread simultaneously, collecting premium from both sides. Maximum profit is the total premium received when the underlying expires between the two inner strikes.

from dataclasses import dataclass
from typing import Tuple

@dataclass
class IronCondorLeg:
    strike: float
    option_type: str      # 'call' or 'put'
    position: str         # 'long' or 'short'
    premium: float
    delta: float
    option_id: str = ""

class IronCondorAgent:
    """
    Manages iron condor positions on range-bound markets.
    Monitors delta exposure and closes on breach of inner strikes.
    """

    def __init__(self, pf_client, wing_width_pct: float = 0.035,
                 inner_strike_pct: float = 0.12):
        """
        wing_width_pct: width of each spread as % of spot (default 3.5%)
        inner_strike_pct: distance of short strikes from spot (default 12%)
        """
        self.pf = pf_client
        self.wing_width_pct = wing_width_pct
        self.inner_pct = inner_strike_pct
        self.bs = BlackScholes()
        self.condors: list = []

    def build_condor(self, spot: float, iv: float, days: int, qty: float) -> dict:
        """Build iron condor strike structure from spot price."""
        wing = spot * self.wing_width_pct

        # Call spread strikes
        short_call = round(spot * (1 + self.inner_pct), -2)
        long_call = round(short_call + wing, -2)

        # Put spread strikes
        short_put = round(spot * (1 - self.inner_pct), -2)
        long_put = round(short_put - wing, -2)

        T = days / 365

        # Price each leg
        sc_g = self.bs.greeks(spot, short_call, T, 0.05, iv, 'call')
        lc_g = self.bs.greeks(spot, long_call, T, 0.05, iv, 'call')
        sp_g = self.bs.greeks(spot, short_put, T, 0.05, iv, 'put')
        lp_g = self.bs.greeks(spot, long_put, T, 0.05, iv, 'put')

        net_credit = (sc_g.price - lc_g.price + sp_g.price - lp_g.price) * qty
        max_loss = (wing - net_credit / qty) * qty

        condor = {
            'spot_at_open': spot, 'iv_at_open': iv, 'days': days, 'qty': qty,
            'short_call': short_call, 'long_call': long_call,
            'short_put': short_put, 'long_put': long_put,
            'net_credit': net_credit, 'max_loss': max_loss,
            'max_profit': net_credit,
            'profit_zone': (short_put, short_call),
            'net_delta': (-sc_g.delta + lc_g.delta + sp_g.delta - lp_g.delta) * qty,
            'opened_ts': time.time()
        }
        self.condors.append(condor)

        print(f"Iron Condor: puts {short_put:.0f}/{long_put:.0f} | calls {short_call:.0f}/{long_call:.0f}")
        print(f"Net credit: ${net_credit:.2f} | Max loss: ${max_loss:.2f} | Profit zone: ${short_put:.0f}-${short_call:.0f}")
        return condor

    def should_close_condor(self, condor: dict, current_spot: float) -> Tuple[bool, str]:
        """Check if condor needs to be closed based on price breaching profit zone."""
        low, high = condor['profit_zone']
        buffer = (high - low) * 0.1   # close when 10% into profit zone

        if current_spot < low + buffer:
            return True, f"Spot ${current_spot:.0f} near put strike ${low:.0f}"
        if current_spot > high - buffer:
            return True, f"Spot ${current_spot:.0f} near call strike ${high:.0f}"
        return False, ""

    def monitor_and_manage(self, current_spot: float):
        """Periodic monitoring — close condors that breach profit zone."""
        for condor in list(self.condors):
            should_close, reason = self.should_close_condor(condor, current_spot)
            if should_close:
                print(f"Closing condor: {reason}")
                # Close all four legs via Purple Flea API
                self.pf.close_iron_condor(condor['id'])
                self.condors.remove(condor)

8. Delta Hedging with Perpetual Futures

When you're running options positions, delta risk accumulates as the underlying moves. Delta hedging means maintaining a delta-neutral book by offsetting options delta with futures/perp positions. This isolates the other Greeks (particularly theta and vega) as pure profit sources.

Purple Flea perpetual futures are ideal for delta hedging because they have no expiry date, low fees, and can be sized precisely. Here's how to implement a delta-neutral options book:

class DeltaHedger:
    """
    Maintains delta-neutral options book using Purple Flea perpetual futures.
    Recalculates portfolio delta every minute and rebalances when delta
    drifts beyond threshold.
    """

    def __init__(self, pf_client, delta_threshold: float = 0.05):
        self.pf = pf_client
        self.delta_threshold = delta_threshold  # rehedge when delta > ±0.05
        self.bs = BlackScholes()
        self.hedge_position_size = 0.0  # current perp hedge size (negative = short)

    def calculate_portfolio_delta(self, options_book: list, spot: float, iv: float) -> float:
        """
        Sum delta across all option positions.
        options_book: list of dicts with keys: strike, expiry_days, qty, type, position
        """
        total_delta = 0.0
        for opt in options_book:
            days_remaining = opt.get('days_remaining', opt['expiry_days'])
            T = max(days_remaining, 0.01) / 365
            g = self.bs.greeks(spot, opt['strike'], T, 0.05, iv, opt['type'])
            sign = 1 if opt['position'] == 'long' else -1
            total_delta += g.delta * opt['qty'] * sign
        return total_delta

    def rebalance_hedge(self, portfolio_delta: float, spot: float):
        """
        Adjust perpetual futures position to offset portfolio delta.
        target_hedge = -portfolio_delta (opposite of options delta)
        """
        target_hedge = -portfolio_delta  # desired perp size in BTC units
        delta_needed = target_hedge - self.hedge_position_size

        if abs(delta_needed) < self.delta_threshold:
            return  # within tolerance, no action needed

        # Convert BTC delta to USD position size
        usd_size = abs(delta_needed) * spot

        if delta_needed > 0:
            self.pf.open_position("BTC-USD", "long", usd_size, leverage=1)
            print(f"Hedge: Buy {delta_needed:.4f} BTC (${usd_size:.0f}) to offset options delta")
        else:
            self.pf.open_position("BTC-USD", "short", usd_size, leverage=1)
            print(f"Hedge: Short {abs(delta_needed):.4f} BTC (${usd_size:.0f}) to offset options delta")

        self.hedge_position_size = target_hedge
        print(f"Portfolio delta now ~0 (hedge: {target_hedge:.4f} BTC)")

9. Purple Flea Perps as Options-Like Instruments

Traditional options require an options exchange — a market structure that's more complex and less liquid than perpetual futures. Purple Flea Trading offers perpetual futures which, when combined with stop-losses and take-profits, can replicate option-like payoff profiles at lower cost.

Synthetic Long Call via Perp + Stop

Instead of buying a call option, you can open a long perp position with a hard stop-loss. Your maximum loss is capped (like a call's premium cost), but you participate in unlimited upside above the stop. This "synthetic option" avoids the IV premium embedded in listed options:

The perp-based approach works best in normal volatility environments. When IV is elevated (crypto bear markets, major news events), listed options become overpriced relative to realized volatility, making the synthetic perp approach superior. Conversely, when IV is depressed, buying listed options can be cheaper than the funding cost of holding perps.

10. Risk Management: Position Sizing and Stop-Loss Triggers

Options portfolios can generate extreme losses if risk isn't actively managed. The following rules should be hard-coded into any agent operating options strategies:

class OptionsRiskManager:
    """
    Portfolio-level risk management for options books.
    Hard stops on Greeks, portfolio loss, and concentration.
    """

    def __init__(self, max_portfolio_delta: float = 0.10,
                 max_portfolio_gamma_usd: float = 500,
                 max_vega_usd: float = 1000,
                 max_daily_loss_pct: float = 0.03,
                 max_position_pct: float = 0.20):
        """
        max_portfolio_delta: max absolute delta (e.g. 0.10 = 10% net directional exposure)
        max_portfolio_gamma_usd: max USD P&L from a 1% move (gamma risk)
        max_vega_usd: max USD loss from 1% IV increase
        max_daily_loss_pct: halt trading if daily loss exceeds this % of equity
        max_position_pct: max single position as % of portfolio
        """
        self.max_delta = max_portfolio_delta
        self.max_gamma_usd = max_portfolio_gamma_usd
        self.max_vega_usd = max_vega_usd
        self.max_daily_loss_pct = max_daily_loss_pct
        self.max_position_pct = max_position_pct
        self.starting_equity = None
        self.daily_pnl = 0.0
        self.halt_flag = False

    def check_risk_limits(self, portfolio_greeks: dict, current_equity: float) -> list:
        """
        Returns list of risk violations. Empty list means all clear.
        portfolio_greeks: {delta, gamma, theta, vega, rho, spot}
        """
        violations = []
        spot = portfolio_greeks.get('spot', 1)

        # Delta check
        if abs(portfolio_greeks['delta']) > self.max_delta:
            violations.append(
                f"DELTA BREACH: {portfolio_greeks['delta']:.3f} > {self.max_delta}"
            )

        # Gamma check (USD impact of 1% move)
        gamma_usd = 0.5 * portfolio_greeks['gamma'] * (spot * 0.01)**2
        if abs(gamma_usd) > self.max_gamma_usd:
            violations.append(
                f"GAMMA BREACH: ${gamma_usd:.0f} at-risk per 1% move > ${self.max_gamma_usd}"
            )

        # Vega check
        if abs(portfolio_greeks['vega']) > self.max_vega_usd / 100:
            violations.append(
                f"VEGA BREACH: ${portfolio_greeks['vega'] * 100:.0f} per 1% IV move > ${self.max_vega_usd}"
            )

        # Daily loss check
        if self.starting_equity and current_equity < self.starting_equity:
            daily_loss_pct = (self.starting_equity - current_equity) / self.starting_equity
            if daily_loss_pct > self.max_daily_loss_pct:
                violations.append(
                    f"DAILY LOSS HALT: {daily_loss_pct:.1%} loss > {self.max_daily_loss_pct:.1%} threshold"
                )
                self.halt_flag = True

        return violations

    def max_condor_size(self, equity: float, max_loss_per_condor: float) -> float:
        """Max number of condor contracts given portfolio constraints."""
        risk_budget = equity * 0.05  # never risk more than 5% on one condor structure
        return int(risk_budget / max_loss_per_condor)

11. Backtesting Results

The following results come from backtesting the covered call wheel strategy on BTC-USD using historical data from 2024–2025. All results assume monthly 30-delta OTM calls, 30-day expiry, and automatic rolling when delta exceeds 0.65.

12. Complete OptionsAgent Class

Putting it all together: a single OptionsAgent class that manages the full strategy stack — covered calls, iron condors, and delta hedging — with integrated risk management:

class OptionsAgent:
    """
    Full options strategy agent for Purple Flea Trading.
    Manages covered calls, iron condors, and delta hedging automatically.
    Integrates with LLM for regime detection and strategy selection.
    """

    def __init__(self, pf_api_key: str, equity: float):
        self.pf = PurpleFleatradingClient(pf_api_key)
        self.equity = equity
        self.covered_calls = CoveredCallAgent(self.pf)
        self.condors = IronCondorAgent(self.pf)
        self.hedger = DeltaHedger(self.pf)
        self.risk = OptionsRiskManager()
        self.risk.starting_equity = equity

    def detect_regime(self, spot: float, iv: float, iv_history: list) -> str:
        """
        Classify market regime based on IV percentile and trend.
        Returns: 'trending' | 'ranging' | 'high_iv' | 'low_iv'
        """
        iv_pct = sum(1 for v in iv_history if v < iv) / len(iv_history)
        if iv_pct > 0.75:
            return 'high_iv'   # sell volatility (condors, covered calls)
        elif iv_pct < 0.25:
            return 'low_iv'    # buy volatility or use perp synthetics
        return 'ranging'     # normal regime, run covered calls

    def run_cycle(self):
        """Main loop: called every 5 minutes."""
        if self.risk.halt_flag:
            print("HALTED: Daily loss limit reached. Manual review required.")
            return

        market = self.pf.get_market_data("BTC-USD")
        spot = market['price']
        iv = market['iv']
        iv_history = market['iv_30d_history']
        current_equity = self.pf.get_portfolio()['equity']
        regime = self.detect_regime(spot, iv, iv_history)

        # Build portfolio Greeks for risk check
        options_book = self.pf.get_options_positions()
        portfolio_greeks = self._aggregate_greeks(options_book, spot, iv)
        violations = self.risk.check_risk_limits(portfolio_greeks, current_equity)

        if violations:
            print(f"RISK ALERTS: {violations}")
            # Auto-hedge delta breaches
            if any('DELTA' in v for v in violations):
                self.hedger.rebalance_hedge(portfolio_greeks['delta'], spot)

        # Strategy selection based on regime
        if regime == 'high_iv':
            # High IV: sell condors for maximum premium
            qty = self.risk.max_condor_size(current_equity, max_loss_per_condor=300)
            if qty > 0 and not self.condors.condors:
                self.condors.build_condor(spot, iv, 30, qty)

        elif regime == 'ranging':
            # Normal: manage covered calls
            self.covered_calls.manage_positions(spot, iv)

        # Manage condors
        self.condors.monitor_and_manage(spot)

        print(f"Cycle: spot=${spot:,.0f} iv={iv:.0%} regime={regime} equity=${current_equity:,.0f}")

    def _aggregate_greeks(self, options_book, spot, iv) -> dict:
        total = {'delta': 0.0, 'gamma': 0.0, 'theta': 0.0, 'vega': 0.0, 'spot': spot}
        for opt in options_book:
            T = max(opt['days_remaining'], 0.01) / 365
            g = BlackScholes().greeks(spot, opt['strike'], T, 0.05, iv, opt['type'])
            sign = 1 if opt['position'] == 'long' else -1
            for k in ['delta', 'gamma', 'theta', 'vega']:
                total[k] += getattr(g, k) * opt['qty'] * sign
        return total