methodology

How Pulse Bot makes decisions

An AI options-selling agent that selects which trades to take based on real market data, vol-aware Black-Scholes premium pricing, and walk-forward edge metrics. No magic — just disciplined math.

Return

—

Trades

—

Win rate

—

Max DD

—

Calmar

—

Numbers above are pulled live from the bot's current state. See the full track record →

Data pipeline

Daily OHLCV bars pulled from Alpaca's free IEX feed for 5 high-volatility equities (AMD, NVDA, TSLA, META, AAPL) over the last 365 days. Cached in historical_bars table.
Synthetic option pulses generated from those bars — one pulse per (ticker, strategy, entry date) using Black-Scholes pricing with rolling 30-day realized vol.
Walk-forward edge metrics computed per (ticker, strategy, time window). Win rate, expectancy, edge score — all derived from outcomes already resolved at each decision point. No lookahead bias.
Bot policy evaluates each pulse: passes risk gates (drawdown halt, position dedup, edge threshold), sizes via half-Kelly capped at max_position_pct, opens via simulated paper-trade.
Lifecycle exits: bot terminates as succeeded at profit_target_pct or stopped_out at max_drawdown_pct. Open positions force-closed at cost basis on terminal status.

Strategies modelled

Four classic options-selling structures, all priced with Black-Scholes from realized volatility:

Covered call — sell ATM call, capped upside, eats stock downside minus premium. Wins in flat/up markets.
Cash-secured put — sell 5%-OTM put, full premium kept if stock stays above strike, assigned if it falls below.
Bull put spread — sell short put + buy long put at lower strike, defined-risk version of CSP. Max loss capped at wing width minus credit.
Iron condor — sell OTM call + OTM put with long-strike wings on each side. Wins when stock stays in a range, capped loss on either tail.

The Black-Scholes pricer

Every option leg is priced at entry time using:

European call (Black-Scholes)

d₁ = (ln(S/K) + (r + σ²/2)·T) / (σ·√T)
d₂ = d₁ − σ·√T
Call = S·N(d₁) − K·e^−r·T·N(d₂)

Where S = spot, K = strike, T = time to expiry (years), σ = realized vol from the prior 30 trading-day window, r = 4% risk-free rate, N(·) = standard normal CDF.

This means a 21-DTE ATM call on SPY at ~12% vol pays ≈1.5% premium; the same call on NVDA at ~50% vol pays ≈5%. Strategy edges *vary by ticker and date* — the bot's per-(ticker, strategy) edge lookup captures this.

Decision logic

For every new pulse, the bot evaluates these gates in order:

Strategy class — is this strategy enabled in the bot's risk profile?
Edge gate — is the (ticker, strategy)'s recent edge_score ≥ min_algo_edge_score?
Drawdown halt — is current drawdown above max_drawdown_pct?
Position dedup — already holding this (ticker, strategy) pair?
Concurrency cap — at max_concurrent_positions?
Sizing — half-Kelly fraction of equity, capped at max_position_pct.
Cash check — does the bot have liquid cash to deploy?

Edge score formula:

Edge score [0, 1]

expectancy_pct = win_rate × avg_win_pct + (1 − win_rate) × avg_loss_pct
confidence = min(1, trades / 30)
edge_raw = max(0, expectancy_pct / 0.05)
edge_score = clamp(0, 1, edge_raw × confidence)

Strategies with negative expectancy clamp to 0 and are filtered. The bot dynamically avoids strategies that have stopped working — this is what "agentic AI trading" means in practice.

Risk controls

Hard stops: bot terminates at profit_target_pct (default +20%) or max_drawdown_pct (default −10%). Both close all positions at cost basis.
Half-Kelly sizing: sized at edge × 0.5, ensuring positions are proportional to confidence but never aggressive.
Position cap: default 5% of equity per position; max 20 concurrent. Single-trade loss exposure is bounded.
Per-(ticker, strategy) dedup: no doubling up on the same exposure. Multiple strategies on the same ticker are different exposures and *do* compose.
Walk-forward metrics: at decision time t, edges are computed using only pulses resolved before t. No lookahead, no overfit to future data.

Limitations & honest caveats

This is a simulated paper-trading model. Things it doesn't capture (yet):

Overnight gap risk — model treats hold periods as continuous. Real overnight gaps can deepen drawdowns.
Liquidity / slippage — simulated fills assume mid-price execution. Real fills at IV spikes are worse.
Implied vs realized vol — we use realized vol as an IV proxy. Real IV usually runs slightly higher (vol risk premium); this means our premiums may be slightly under-credited.
Dividend & assignment mechanics — simplified. ATM covered calls assume premium-only on assignment; real assignment has timing nuances.
Past performance is not a forecast. 2025-2026 was apparently a benign year for high-vol mega-caps; a 2008-style regime would widen drawdowns significantly.

What's next on the roadmap

Gap/overnight risk modelling — add stochastic 1-3% overnight gaps to a fraction of trades
Implied-vol feed from Alpaca options endpoint (replaces realized-vol proxy)
Per-user bot provisioning (already shipped — see "Create your bot" CTA)
Walk-forward bandit policy (Thompson sampling over edges) — already shipped for backfill A/B
Real-money path via Alpaca paper broker integration (see dashboard for current state)