Perpetual Options: The Next Frontier for AI Agent Trading

What Are Perpetual Options?

A standard option has a fixed expiry date. Its time value decays (theta) as expiry approaches, and at settlement, the option either pays out or expires worthless. This creates discontinuity: traders must manage rolls, and liquidity fragments across dozens of expiry dates.

Perpetual options solve this by removing the expiry date entirely. Instead of theta decay resolving at a fixed date, the option seller receives (or pays) a continuous funding rate — analogous to the funding rate in perpetual futures — that compensates for the time value of the option. This rate is recalculated periodically (often hourly) based on the option's current fair value versus its market price.

The payoff profile at any point in time is identical to a vanilla option with a specific synthetic maturity determined by the funding rate level. When implied volatility is high, the funding rate is high, making it expensive to hold long option positions — the same dynamic that makes long gamma expensive in trending markets.

Greeks for Perpetual Options

The standard Black-Scholes Greeks apply to perpetual options with one important addition: funding rate sensitivity, which measures how the position's daily carry cost changes as implied volatility (IV) moves.

Strategy 1 — Volatility Harvesting

Crypto implied volatility consistently trades above realised volatility on a rolling 30-day basis — the "volatility risk premium." An agent that sells perpetual options captures this premium as continuous funding income.

The trade: sell a delta-hedged strangle (short call + short put) on ETH perpetual options. Hedge delta by holding -delta units of the underlying in the spot or perp market. As the underlying moves, rebalance the hedge. The net P&L is realised volatility minus implied volatility, scaled by gamma.

import math

def bs_delta(spot: float, strike: float, iv: float,
             synthetic_maturity_days: float, is_call: bool) -> float:
    """
    Black-Scholes delta for perpetual option given synthetic maturity.
    Synthetic maturity is derived from funding rate: T = 1 / (daily_funding_rate * 365)
    """
    T = synthetic_maturity_days / 365
    d1 = (math.log(spot / strike) + 0.5 * iv**2 * T) / (iv * math.sqrt(T))
    from scipy.stats import norm
    if is_call:
        return norm.cdf(d1)
    else:
        return norm.cdf(d1) - 1


def vega_neutral_hedge_ratio(long_positions: list[dict],
                              short_positions: list[dict]) -> float:
    """
    Net vega across portfolio. Positive = long vol, negative = short vol.
    Target: vega close to zero for vol-neutral book.
    """
    net_vega = sum(p["vega"] * p["size"] for p in long_positions) \
             - sum(p["vega"] * p["size"] for p in short_positions)
    return net_vega

When to switch sides

The volatility risk premium reverses during crisis events. An agent should monitor the IV/RV ratio: when it drops below 1.0 (realised vol exceeds implied), the short-vol trade loses money and should be closed or flipped to long vol.

Strategy 2 — Gamma Scalping

Long gamma positions benefit from large moves in either direction. In perpetual options, you hold long straddles (long call + long put at the same strike) and continuously delta-hedge. Every time the underlying moves a significant amount, rebalancing the delta hedge locks in a profit equal to 0.5 × gamma × (price move)².

The challenge: the position pays funding every hour. Gamma scalping is profitable only when realised volatility exceeds the implied volatility embedded in the funding rate. The breakeven formula is:

# Breakeven realised volatility for gamma scalping
# Must exceed this to profit from long gamma position

def breakeven_rv(funding_rate_daily: float, gamma: float,
                 spot: float, rebalance_freq_hours: float = 1.0) -> float:
    """
    Returns annualised breakeven RV for a long gamma position.

    funding_rate_daily: daily funding as decimal (e.g., 0.001 = 0.1%/day)
    gamma: option gamma (dDelta/dSpot)
    spot: current underlying price
    """
    # Funding cost per rebalance period
    period_days = rebalance_freq_hours / 24
    period_funding_cost = funding_rate_daily * period_days

    # Gamma P&L per unit vol per rebalance period
    gamma_pnl_per_vol_unit = 0.5 * gamma * spot**2

    # Breakeven: period funding = 0.5 * gamma * S^2 * (RV * sqrt(T))^2
    breakeven_period_rv = math.sqrt(2 * period_funding_cost / (gamma * spot**2))
    breakeven_annual_rv = breakeven_period_rv * math.sqrt(365 / period_days)

    return breakeven_annual_rv

# Example
be = breakeven_rv(funding_rate_daily=0.0008, gamma=0.0023, spot=3200)
print(f"Breakeven RV: {be*100:.1f}%")
# → Breakeven RV: 54.2% (annualised)
# If ETH RV > 54.2%, long gamma trade is profitable

Strategy 3 — Funding Rate Arbitrage

When implied volatility diverges across perpetual option platforms, or between perp options and the standard options market (Deribit, CME), a spread trade captures the differential.

For example: if Panoptic is pricing a 30-delta ETH put at 85% IV while Deribit's nearest equivalent strike/expiry trades at 72% IV, an agent can:

1. Sell the Panoptic perp put (receive high funding)
2. Buy the equivalent Deribit option (pay lower premium)
3. Delta-hedge the net position to isolate the volatility spread
4. Close when IV converges (typically 1–5 days)

Strategy 4 — Tail Hedging

Long far-out-of-the-money put options are cheap on a dollar basis but expensive in funding terms relative to at-the-money options (the "volatility smile"). In perpetual option markets, the smile is often less pronounced than on Deribit because of liquidity constraints — creating an opportunity to buy cheap tail protection.

A portfolio running leveraged long positions in Purple Flea perp futures can use tail hedges to limit catastrophic drawdown:

# Tail hedge sizing rule
# Spend 1-2% of portfolio per month on OTM puts

def tail_hedge_size(portfolio_value: float, monthly_budget_pct: float,
                    put_price_usdc: float) -> int:
    """
    Returns number of put contracts to buy for tail protection.
    """
    monthly_budget = portfolio_value * monthly_budget_pct
    contracts = int(monthly_budget / put_price_usdc)
    return contracts

# Example: $10K portfolio, 1.5% monthly budget, OTM put at $18 each
contracts = tail_hedge_size(10000, 0.015, 18)
print(f"Buy {contracts} OTM put contracts")
# → Buy 8 OTM put contracts

Purple Flea Derivatives API Integration

Purple Flea's Derivatives API provides a unified interface to perpetual options data and execution. Key endpoints:

# Get IV surface for ETH
GET https://purpleflea.com/api/v1/derivatives/iv-surface?asset=ETH

Response:
{
  "asset": "ETH",
  "spot": 3204.50,
  "timestamp": "2026-03-06T12:00:00Z",
  "surface": [
    {
      "delta": 0.25,
      "strike": 2800,
      "iv": 0.84,
      "funding_rate_daily": 0.00082,
      "synthetic_maturity_days": 30.2
    },
    {
      "delta": 0.50,
      "strike": 3200,
      "iv": 0.76,
      "funding_rate_daily": 0.00074,
      "synthetic_maturity_days": 30.2
    },
    ...
  ]
}

# Get Greeks for a specific position
GET https://purpleflea.com/api/v1/derivatives/greeks?asset=ETH&strike=3200&type=call

Response:
{
  "delta": 0.512,
  "gamma": 0.00231,
  "vega": 8.42,       // USD change per 1% IV move, per contract
  "funding_daily": 0.00074,
  "breakeven_rv": 0.681
}

# Open a perpetual option position
POST https://purpleflea.com/api/v1/derivatives/positions
{
  "asset": "ETH",
  "strike": 3200,
  "type": "call",
  "side": "short",   // sell the option, receive funding
  "size": 0.5,       // ETH contracts
  "platform": "panoptic"
}

Vega-Neutral Portfolio Implementation

A full Python class implementing a vega-neutral perpetual options book using Purple Flea's Derivatives API:

import requests, math, time
from dataclasses import dataclass, field
from typing import Literal

BASE = "https://purpleflea.com/api/v1"

@dataclass
class PerpOption:
    asset: str
    strike: float
    option_type: Literal["call", "put"]
    side: Literal["long", "short"]
    size: float
    delta: float = 0.0
    vega: float = 0.0
    funding_daily: float = 0.0
    position_id: str = ""


class VegaNeutralBook:
    """
    Maintains a vega-neutral perpetual options portfolio.
    Rebalances delta and vega exposures on each tick.
    """

    def __init__(self, api_key: str, target_vega: float = 0.0,
                 max_delta: float = 0.05):
        self.api_key     = api_key
        self.target_vega = target_vega   # 0 = flat vol exposure
        self.max_delta   = max_delta     # max portfolio delta (fraction of notional)
        self.positions: list[PerpOption] = []
        self.headers = {"Authorization": f"Bearer {api_key}",
                        "Content-Type": "application/json"}

    def fetch_greeks(self, asset: str, strike: float,
                     option_type: str) -> dict:
        resp = requests.get(
            f"{BASE}/derivatives/greeks",
            params={"asset": asset, "strike": strike, "type": option_type},
            headers=self.headers
        )
        return resp.json()

    def net_vega(self) -> float:
        total = 0.0
        for pos in self.positions:
            sign = 1 if pos.side == "long" else -1
            total += sign * pos.vega * pos.size
        return total

    def net_delta(self) -> float:
        total = 0.0
        for pos in self.positions:
            sign = 1 if pos.side == "long" else -1
            total += sign * pos.delta * pos.size
        return total

    def rebalance(self, spot: float):
        """Refresh Greeks and check if rebalancing is needed."""
        for pos in self.positions:
            g = self.fetch_greeks(pos.asset, pos.strike, pos.option_type)
            pos.delta          = g["delta"]
            pos.vega           = g["vega"]
            pos.funding_daily  = g["funding_daily"]

        net_d = self.net_delta()
        net_v = self.net_vega()

        print(f"Portfolio | delta={net_d:+.4f} | vega={net_v:+.2f}")

        # Delta hedge via Purple Flea perp futures
        if abs(net_d) > self.max_delta:
            hedge_side = "sell" if net_d > 0 else "buy"
            hedge_size = abs(net_d)
            print(f"  → Delta hedge: {hedge_side} {hedge_size:.4f} perp")
            self._place_perp_hedge(hedge_side, hedge_size)

        # Vega adjustment: if too long vol, sell more options; too short, buy
        vega_gap = net_v - self.target_vega
        if abs(vega_gap) > 5.0:
            print(f"  → Vega imbalance: {vega_gap:+.2f}. Adjusting.")
            # Logic to open/close option positions to reduce gap

    def _place_perp_hedge(self, side: str, size: float):
        requests.post(
            f"{BASE}/orders",
            json={"market": "ETH-USDC-PERP", "side": side,
                  "size": round(size, 4), "type": "market"},
            headers=self.headers
        )

    def daily_funding_pnl(self) -> float:
        """Net daily funding received/paid across all positions."""
        total = 0.0
        for pos in self.positions:
            notional = pos.size * pos.strike  # approximate in USDC
            funding  = notional * pos.funding_daily
            # Short positions receive funding; long positions pay
            total += funding if pos.side == "short" else -funding
        return total


# Usage
book = VegaNeutralBook(api_key="pf_live_...", target_vega=0.0)
# Add positions...
book.positions.append(PerpOption(
    asset="ETH", strike=3200, option_type="call",
    side="short", size=1.0
))
book.positions.append(PerpOption(
    asset="ETH", strike=3000, option_type="put",
    side="short", size=1.2
))

# Rebalance loop
while True:
    spot = 3204.50  # fetch from Purple Flea /markets
    book.rebalance(spot)
    funding = book.daily_funding_pnl()
    print(f"Daily funding income: ${funding:.2f}")
    time.sleep(3600)  # hourly rebalance

Risk Factors

Next Steps

Perpetual options are technically demanding but represent one of the highest-alpha opportunities for agents with fast execution and quantitative pricing models. A few practical starting points:

• Build a calibration layer that fits the Heston stochastic volatility model to Deribit's options surface daily, then compare implied parameters to Panoptic's market prices to identify mispricings.
• Start with Squeeth (oSQTH) on Ethereum — it is the simplest perpetual option, providing pure ETH-squared exposure. Model the funding rate dynamics for 30 days before deploying capital.
• Use Purple Flea's MCP endpoint to give your agent access to the full derivatives API surface alongside the casino, wallet, and trading tools — enabling cross-product hedging strategies that are impossible on single-product platforms.
• Claim free USDC from the faucet to fund a paper-trading account for derivatives strategy validation before going live.

The derivatives infrastructure at Purple Flea is continuously expanding — follow our blog and roadmap for updates on new perp option market integrations, additional Greeks endpoints, and vega-hedging tools.