Options trading strategy analysis and simulation tool. Provides theoretical pricing using Black-Scholes model, Greeks calculation, strategy P/L simulation, and risk management guidance. Use when user
Real data. Real impact.
Emerging
Developers
Per week
Open source
Skills give you superpowers. Install in 30 seconds.
This skill provides comprehensive options strategy analysis and education using theoretical pricing models. It helps traders understand, analyze, and simulate options strategies without requiring real-time market data subscriptions.
Core Capabilities:
Data Sources:
Use this skill when:
Example requests:
Required from User:
Optional from User:
Fetched from FMP API:
Example User Input:
Ticker: AAPL Strategy: Bull Call Spread Long Strike: $180 Short Strike: $185 Expiration: 30 days Contracts: 10 IV: 25% (or use HV if not provided)
Objective: Estimate volatility from historical price movements.
Method:
# Fetch 90 days of price data prices = get_historical_prices("AAPL", days=90)Calculate daily returns
returns = np.log(prices / prices.shift(1))
Annualized volatility
HV = returns.std() * np.sqrt(252) # 252 trading days
Output:
User Can Override:
--iv 28.0Black-Scholes Model:
For European-style options:
Call Price = S * N(d1) - K * e^(-r*T) * N(d2) Put Price = K * e^(-r*T) * N(-d2) - S * N(-d1)Where: d1 = [ln(S/K) + (r + σ²/2) * T] / (σ * √T) d2 = d1 - σ * √T
S = Current stock price K = Strike price r = Risk-free rate T = Time to expiration (years) σ = Volatility (IV or HV) N() = Cumulative standard normal distribution
Adjustments:
Python Implementation:
from scipy.stats import norm import numpy as npdef black_scholes_call(S, K, T, r, sigma, q=0): """ S: Stock price K: Strike price T: Time to expiration (years) r: Risk-free rate sigma: Volatility q: Dividend yield """ d1 = (np.log(S/K) + (r - q + 0.5sigma**2)T) / (sigmanp.sqrt(T)) d2 = d1 - sigmanp.sqrt(T)
call_price = S*np.exp(-q*T)*norm.cdf(d1) - K*np.exp(-r*T)*norm.cdf(d2) return call_pricedef black_scholes_put(S, K, T, r, sigma, q=0): d1 = (np.log(S/K) + (r - q + 0.5sigma**2)T) / (sigmanp.sqrt(T)) d2 = d1 - sigmanp.sqrt(T)
put_price = K*np.exp(-r*T)*norm.cdf(-d2) - S*np.exp(-q*T)*norm.cdf(-d1) return put_price
Output for Each Option Leg:
The Greeks measure option price sensitivity to various factors:
Delta (Δ): Change in option price per $1 change in stock price
def delta_call(S, K, T, r, sigma, q=0): d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T)) return np.exp(-q*T) * norm.cdf(d1)def delta_put(S, K, T, r, sigma, q=0): d1 = (np.log(S/K) + (r - q + 0.5sigma**2)T) / (sigmanp.sqrt(T)) return np.exp(-qT) * (norm.cdf(d1) - 1)
Gamma (Γ): Change in delta per $1 change in stock price
def gamma(S, K, T, r, sigma, q=0): d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T)) return np.exp(-q*T) * norm.pdf(d1) / (S * sigma * np.sqrt(T))
Theta (Θ): Change in option price per day (time decay)
def theta_call(S, K, T, r, sigma, q=0): d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T)) d2 = d1 - sigma*np.sqrt(T)theta = (-S*norm.pdf(d1)*sigma*np.exp(-q*T)/(2*np.sqrt(T)) - r*K*np.exp(-r*T)*norm.cdf(d2) + q*S*norm.cdf(d1)*np.exp(-q*T)) return theta / 365 # Per day
Vega (ν): Change in option price per 1% change in volatility
def vega(S, K, T, r, sigma, q=0): d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T)) return S * np.exp(-q*T) * norm.pdf(d1) * np.sqrt(T) / 100 # Per 1%
Rho (ρ): Change in option price per 1% change in interest rate
def rho_call(S, K, T, r, sigma, q=0): d2 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T)) - sigma*np.sqrt(T) return K * T * np.exp(-r*T) * norm.cdf(d2) / 100 # Per 1%
Position Greeks:
For a strategy with multiple legs, sum Greeks across all legs:
# Example: Bull Call Spread # Long 1x $180 call # Short 1x $185 calldelta_position = (1 * delta_long) + (-1 * delta_short) gamma_position = (1 * gamma_long) + (-1 * gamma_short) theta_position = (1 * theta_long) + (-1 * theta_short) vega_position = (1 * vega_long) + (-1 * vega_short)
Greeks Interpretation:
| Greek | Meaning | Example |
|---|---|---|
| Delta | Directional exposure | Δ = 0.50 → $50 profit if stock +$1 |
| Gamma | Delta acceleration | Γ = 0.05 → Delta increases by 0.05 if stock +$1 |
| Theta | Daily time decay | Θ = -$5 → Lose $5/day from time passing |
| Vega | Volatility sensitivity | ν = $10 → Gain $10 if IV increases 1% |
| Rho | Interest rate sensitivity | ρ = $2 → Gain $2 if rates increase 1% |
Objective: Calculate profit/loss at various stock prices at expiration.
Method:
Generate stock price range (e.g., ±30% from current price):
current_price = 180 price_range = np.linspace(current_price * 0.7, current_price * 1.3, 100)
For each price point, calculate P/L:
def calculate_pnl(strategy, stock_price_at_expiration): pnl = 0for leg in strategy.legs: if leg.type == 'call': intrinsic_value = max(0, stock_price_at_expiration - leg.strike) else: # put intrinsic_value = max(0, leg.strike - stock_price_at_expiration) if leg.position == 'long': pnl += (intrinsic_value - leg.premium_paid) * 100 # Per contract else: # short pnl += (leg.premium_received - intrinsic_value) * 100 return pnl * num_contracts
Key Metrics:
Example Output:
Bull Call Spread: $180/$185 on AAPL (30 DTE, 10 contracts)Current Price: $180.00 Net Debit: $2.50 per spread ($2,500 total)
Max Profit: $2,500 (at $185+) Max Loss: -$2,500 (at $180-) Breakeven: $182.50 Risk/Reward: 1:1
Probability Profit: ~55% (if stock stays above $182.50)
Visual representation of P/L across stock prices:
def generate_pnl_diagram(price_range, pnl_values, current_price, width=60, height=15): """Generate ASCII P/L diagram"""# Normalize to chart dimensions max_pnl = max(pnl_values) min_pnl = min(pnl_values) lines = [] lines.append(f"\nP/L Diagram: {strategy_name}") lines.append("-" * width) # Y-axis levels levels = np.linspace(max_pnl, min_pnl, height) for level in levels: if abs(level) < (max_pnl - min_pnl) * 0.05: label = f" 0 |" # Zero line else: label = f"{level:6.0f} |" row = label for i in range(width - len(label)): idx = int(i / (width - len(label)) * len(price_range)) pnl = pnl_values[idx] price = price_range[idx] # Determine character if abs(pnl - level) < (max_pnl - min_pnl) / height: if pnl > 0: char = '█' # Profit elif pnl < 0: char = '░' # Loss else: char = '─' # Breakeven elif abs(level) < (max_pnl - min_pnl) * 0.05: char = '─' # Zero line elif abs(price - current_price) < (price_range[-1] - price_range[0]) * 0.02: char = '│' # Current price line else: char = ' ' row += char lines.append(row) lines.append(" " * 6 + "|" + "-" * (width - 6)) lines.append(" " * 6 + f"${price_range[0]:.0f}" + " " * (width - 20) + f"${price_range[-1]:.0f}") lines.append(" " * (width // 2 - 5) + "Stock Price") return "\n".join(lines)
Example Output:
P/L Diagram: Bull Call Spread $180/$185 ------------------------------------------------------------ +2500 | ████████████████████ | ██████ | ██████ | ██████ 0 | ────── | ░░░░░░ |░░░░░░ -2500 |░░░░░ |____________________________________________________________ $126 $180 $234 Stock PriceLegend: █ Profit ░ Loss ── Breakeven │ Current Price
Provide tailored guidance based on strategy type:
Covered Call:
Income Strategy: Generate premium while capping upsideSetup:
- Own 100 shares of AAPL @ $180
- Sell 1x $185 call (30 DTE) for $3.50
Max Profit: $850 (Stock at $185+ = $5 stock gain + $3.50 premium) Max Loss: Unlimited downside (stock ownership) Breakeven: $176.50 (Cost basis - premium received)
Greeks:
- Delta: -0.30 (reduces stock delta from 1.00 to 0.70)
- Theta: +$8/day (time decay benefit)
Assignment Risk: If AAPL > $185 at expiration, shares called away
When to Use:
- Neutral to slightly bullish
- Want income in sideways market
- Willing to sell stock at $185
Exit Plan:
Buy back call if stock rallies strongly (preserve upside)
Let expire if stock stays below $185
Roll to next month if want to keep shares
Protective Put:
Insurance Strategy: Limit downside while keeping upsideSetup:
- Own 100 shares of AAPL @ $180
- Buy 1x $175 put (30 DTE) for $2.00
Max Profit: Unlimited (stock can rise infinitely) Max Loss: -$7 per share = ($5 stock loss + $2 premium) Breakeven: $182 (Cost basis + premium paid)
Greeks:
- Delta: +0.80 (stock delta 1.00 - put delta 0.20)
- Theta: -$6/day (time decay cost)
Protection: Guaranteed to sell at $175, no matter how far stock falls
When to Use:
- Own stock, worried about short-term drop
- Earnings coming up, want protection
- Alternative to stop-loss (can't be stopped out)
Cost: "Insurance premium" - typically 1-3% of stock value
Exit Plan:
Let expire worthless if stock rises (cost of insurance)
Exercise put if stock falls below $175
Sell put if stock drops but want to keep shares
Iron Condor:
Range-Bound Strategy: Profit from low volatilitySetup (example on AAPL @ $180):
- Sell $175 put for $1.50
- Buy $170 put for $0.50
- Sell $185 call for $1.50
- Buy $190 call for $0.50
Net Credit: $2.00 ($200 per iron condor)
Max Profit: $200 (if stock stays between $175-$185) Max Loss: $300 (if stock moves outside $170-$190) Breakevens: $173 and $187 Profit Range: $175 to $185 (58% probability)
Greeks:
- Delta: ~0 (market neutral)
- Theta: +$15/day (time decay benefit)
- Vega: -$25 (short volatility)
When to Use:
- Expect low volatility, range-bound movement
- After big move, think consolidation
- High IV environment (sell expensive options)
Risk: Unlimited if one side tested
- Use stop loss at 2x credit received (exit at -$400)
Adjustments:
If tested on one side, roll that side out in time
Close early at 50% max profit to reduce tail risk
Integration with Earnings Calendar:
When user asks about earnings strategies, fetch earnings date:
from earnings_calendar import get_next_earnings_dateearnings_date = get_next_earnings_date("AAPL") days_to_earnings = (earnings_date - today).days
Pre-Earnings Strategies:
Long Straddle/Strangle:
Setup (AAPL @ $180, earnings in 7 days): - Buy $180 call for $5.00 - Buy $180 put for $4.50 - Total Cost: $9.50Thesis: Expect big move (>5%) but unsure of direction
Breakevens: $170.50 and $189.50 Profit if: Stock moves >$9.50 in either direction
Greeks:
- Delta: ~0 (neutral)
- Vega: +$50 (long volatility)
- Theta: -$25/day (time decay hurts)
IV Crush Risk: ⚠️ CRITICAL
- Pre-earnings IV: 40% (elevated)
- Post-earnings IV: 25% (typical)
- IV drop: -15 points = -$750 loss even if stock doesn't move!
Analysis:
- Implied Move: √(DTE/365) × IV × Stock Price = √(7/365) × 0.40 × 180 = ±$10.50
- Breakeven Move Needed: ±$9.50
- Probability Profit: ~30-40% (implied move > breakeven move)
Recommendation: ✅ Consider if you expect >10% move (larger than implied) ❌ Avoid if expect normal ~5% earnings move (IV crush will hurt)
Alternative: Buy further OTM strikes to reduce cost
$175/$185 strangle cost $4.00 (need >$8 move, but cheaper)
Short Iron Condor:
Setup (AAPL @ $180, earnings in 7 days): - Sell $170/$175 put spread for $2.00 - Sell $185/$190 call spread for $2.00 - Net Credit: $4.00Thesis: Expect stock to stay range-bound ($175-$185)
Profit Zone: $175 to $185 Max Profit: $400 Max Loss: $100
IV Crush Benefit: ✅
- Short high IV before earnings
- IV drops after earnings → profit on vega
- Even if stock moves slightly, IV drop helps
Greeks:
- Delta: ~0 (market neutral)
- Vega: -$40 (short volatility - good here!)
- Theta: +$20/day
Recommendation: ✅ Good if expect normal earnings reaction (<8% move) ✅ Benefit from IV crush regardless of direction ⚠️ Risk if stock gaps outside range (>10% move)
Exit Plan:
Close next day if IV crushed (capture profit early)
Use stop loss if one side tested (-2x credit)
Position Sizing:
Account Size: $50,000 Risk Tolerance: 2% per trade = $1,000 max riskIron Condor Example:
- Max loss per spread: $300
- Max contracts: $1,000 / $300 = 3 contracts
- Actual position: 3 iron condors
Bull Call Spread Example:
Debit paid: $2.50 per spread
Max contracts: $1,000 / $250 = 4 contracts
Actual position: 4 spreads
Portfolio Greeks Management:
Portfolio Guidelines: - Delta: -10 to +10 (mostly neutral) - Theta: Positive preferred (seller advantage) - Vega: Monitor if >$500 (IV risk)Current Portfolio:
- Delta: +5 (slightly bullish)
- Theta: +$150/day (collecting $150 daily)
- Vega: -$300 (short volatility)
Interpretation: ✅ Neutral delta (safe) ✅ Positive theta (time working for you) ⚠️ Short vega: If IV spikes, lose $300 per 1% IV increase → Reduce short premium positions if VIX rising
Adjustments and Exits:
Exit Rules by Strategy:Covered Call:
- Profit: 50-75% of max profit
- Loss: Stock drops >5%, buy back call to preserve upside
- Time: 7-10 DTE, roll to avoid assignment
Spreads:
- Profit: 50% of max profit (close early, reduce tail risk)
- Loss: 2x debit paid (cut losses early)
- Time: 21 DTE, close or roll (avoid gamma risk)
Iron Condor:
- Profit: 50% of credit (close early common)
- Loss: One side tested, 2x credit lost
- Adjustment: Roll tested side out in time
Straddle/Strangle:
Profit: Stock moved >breakeven, close immediately
Loss: Theta eating position, stock not moving
Time: Day after earnings (if earnings play)
Strategy Analysis Report Template:
# Options Strategy Analysis: [Strategy Name]Symbol: [TICKER] Strategy: [Strategy Type] Expiration: [Date] ([DTE] days) Contracts: [Number]
Strategy Setup
Leg Details
Leg Type Strike Price Position Quantity 1 Call $180 $5.00 Long 1 2 Call $185 $2.50 Short 1 Net Debit/Credit: $2.50 debit ($250 total for 1 spread)
Profit/Loss Analysis
Max Profit: $250 (at $185+) Max Loss: -$250 (at $180-) Breakeven: $182.50 Risk/Reward Ratio: 1:1
Probability Analysis:
- Probability of Profit: ~55% (stock above $182.50)
- Expected Value: $25 (simplified)
P/L Diagram
[ASCII art diagram here]
Greeks Analysis
Position Greeks (1 spread)
- Delta: +0.20 (gains $20 if stock +$1)
- Gamma: +0.03 (delta increases by 0.03 if stock +$1)
- Theta: -$5/day (loses $5 per day from time decay)
- Vega: +$8 (gains $8 if IV increases 1%)
Interpretation
- Directional Bias: Slightly bullish (positive delta)
- Time Decay: Working against you (negative theta)
- Volatility: Benefits from IV increase (positive vega)
Risk Assessment
Maximum Risk
Scenario: Stock falls below $180 Max Loss: -$250 (100% of premium paid) % of Account: 0.5% (if $50k account)
Assignment Risk
Early Assignment: Low (calls have time value) At Expiration: Manage positions if in-the-money
Trade Management
Entry
✅ Enter if: [Conditions]
- Stock price $178-$182
- IV below 30%
- >21 DTE
Profit Taking
- Target 1: 50% profit ($125) - Close half
- Target 2: 75% profit ($187.50) - Close all
Stop Loss
- Trigger: Stock falls below $177 (-$150 loss)
- Action: Close position immediately
Adjustments
- If stock rallies to $184, consider rolling short call higher
- If stock drops to $179, add second spread at $175/$180
Suitability
When to Use This Strategy
✅ Moderately bullish on AAPL ✅ Expect upside to $185-$190 ✅ Want defined risk ✅ 21-45 DTE timeframe
When to Avoid
❌ Very bullish (buy stock or long call instead) ❌ High IV environment (wait for IV to drop) ❌ Earnings in <7 days (IV crush risk)
Alternatives Comparison
Strategy Max Profit Max Loss Complexity When Better Bull Call Spread $250 -$250 Medium Moderately bullish Long Call Unlimited -$500 Low Very bullish Covered Call $850 Unlimited Medium Own stock already Bull Put Spread $300 -$200 Medium Want credit spread Recommendation: Bull call spread is good balance of risk/reward for moderate bullish thesis.
Disclaimer: This is theoretical analysis using Black-Scholes pricing. Actual market prices may differ. Trade at your own risk. Options are complex instruments with significant loss potential.
File Naming Convention:
options_analysis_[TICKER]_[STRATEGY]_[DATE].md
Example:
options_analysis_AAPL_BullCallSpread_2025-11-08.mdWhat Users Should Know:
Black-Scholes Assumptions:
Real vs Theoretical:
Best Practices:
Historical vs Implied Volatility:
Historical Volatility (HV): What happened - Calculated from past price movements - Objective, based on data - Available for free (FMP API)Implied Volatility (IV): What market expects
- Derived from option prices
- Subjective, based on supply/demand
- Requires live options data (user provides)
Comparison:
IV > HV: Options expensive (consider selling)
IV < HV: Options cheap (consider buying)
IV = HV: Fairly priced
IV Percentile:
User provides current IV, we calculate percentile:
# Fetch 1-year HV data historical_hvs = calculate_hv_series(prices_1yr, window=30)Calculate IV percentile
iv_percentile = percentileofscore(historical_hvs, current_iv)
if iv_percentile > 75: guidance = "High IV - consider selling premium (credit spreads, iron condors)" elif iv_percentile < 25: guidance = "Low IV - consider buying options (long calls/puts, debit spreads)" else: guidance = "Normal IV - any strategy appropriate"
Earnings Calendar:
Technical Analyst:
US Stock Analysis:
Bubble Detector:
Portfolio Manager:
Use Case 1: Learn Strategy
User: "Explain a covered call"Workflow:
- Load strategy reference (references/strategies_guide.md)
- Explain concept, risk/reward, when to use
- Simulate example on AAPL
- Show P/L diagram
Compare to alternatives
Use Case 2: Analyze Specific Trade
User: "Analyze $180/$185 bull call spread on AAPL, 30 days"Workflow:
- Fetch AAPL price from FMP
- Calculate HV or ask user for IV
- Price both options (Black-Scholes)
- Calculate Greeks
- Simulate P/L
Generate analysis report
Use Case 3: Earnings Strategy
User: "Should I trade options before NVDA earnings?"Workflow:
- Fetch NVDA earnings date (Earnings Calendar)
- Calculate days to earnings
- Estimate IV percentile (if user provides IV)
- Suggest straddle/strangle vs iron condor
- Warn about IV crush
Simulate both strategies
Use Case 4: Portfolio Greeks Check
User: "What are my total portfolio Greeks?"Workflow:
- User provides current positions
- Calculate Greeks for each position
- Sum Greeks across portfolio
- Assess overall exposure
Suggest adjustments if needed
Problem: IV not available
Problem: Negative option price
Problem: Greeks seem wrong
Problem: Strategy too complex
References:
references/strategies_guide.mdreferences/greeks_explained.mdreferences/volatility_guide.mdScripts:
scripts/black_scholes.pyscripts/strategy_analyzer.pyscripts/earnings_strategy.pyExternal Resources:
Version: 1.0 Last Updated: 2025-11-08 Dependencies: Python 3.8+, numpy, scipy, pandas, requests API: FMP API (Free tier sufficient)
No automatic installation available. Please visit the source repository for installation instructions.
View Installation Instructions
1,500+ AI skills, agents & workflows. Install in 30 seconds. Part of the Torly.ai family.
© 2026 Torly.ai. All rights reserved.