Working with Options Trading Models

Introduction

You're building or evaluating an options model and need something practical, auditable, and repeatable - not a black box. The direct takeaway: a useful options trading model must tie together options pricing, Greeks (risk sensitivities), risk controls, execution mechanics, and validation checks so you can price, hedge, size, and monitor positions consistently. This piece is written for traders, portfolio managers, and quants who want immediate, operational value - faster hedges, clearer P&L attribution, and tighter slippage control. Short: models make prices and risks measurable. Expect focused coverage on these 5 scope areas and practical examples you can test in your desk or strategy; what this intro omits it will defintely not bury in theory.

Key Takeaways

• Integrate pricing, Greeks, risk controls, execution mechanics, and validation so prices and risks are measurable, auditable, and repeatable.
• Match model choice to asset and operational constraints - favor simpler Black/Black‑Scholes for speed and Heston/SABR for richer dynamics when data/support justify it.
• Prioritize market‑data quality and calibration discipline: reliable feeds, robust vol‑surface interpolation, daily calibration, and regularization to avoid overfitting.
• Enforce active risk management: monitor intraday Greeks, set position/vega/VAR limits, and automate alerts for model drift or stale quotes.
• Validate continuously with backtests, finite‑difference Greek checks, walk‑forward tests, and clear ownership (quants build, trading ops monitor, risk verifies).

Choosing the right model

You're choosing a pricing model and that choice will shape pricing accuracy, hedging costs, and execution speed - pick the simplest model that meets your risk and latency requirements. Here's the short takeaway: match model family to the instrument and liquidity, start simple, and escalate complexity only when measurable gaps remain.

Compare Black‑Scholes, Black model, Heston, SABR

Start by understanding each model's core assumption and failure modes. Black‑Scholes (BS) assumes constant volatility and lognormal returns; it gives closed‑form prices and fast Greeks, so use it for liquid, short‑dated equity options where the implied volatility surface is relatively flat.

Black (Black 1976) prices options on forwards/futures and is the market standard for interest‑rate caps/floors and many commodities; it simply substitutes forward prices for spot, so it's the right baseline for exchange‑traded futures options and OTC options settled on forwards.

Heston models stochastic volatility (volatility itself is random) with parameters: mean reversion (kappa), long‑run variance (theta), vol‑of‑vol (sigma), and correlation (rho). Heston captures skew and term‑structure of implied vols better than BS but needs numerical methods (Fourier inversion, characteristic functions) and robust calibration.

SABR (stochastic alpha, beta, rho) models forward price dynamics with a stochastic volatility driver and a local elasticity parameter (beta). It excels at fitting skew across strikes, and its closed‑form implied vol approximations make it popular in rates and FX markets where smiles are pronounced.

• Use BS: liquid equity options, quick prototyping
• Use Black: options on forwards/futures (rates, commodities)
• Use Heston: when you need a realistic vega/gamma term structure
• Use SABR: when skew across strikes is dominant (FX, rates)

Practical steps: (1) price with BS/Black as a benchmark, (2) test Heston/SABR only if benchmark errors exceed your tolerance, (3) quantify calibration error vs. operational cost. One‑liner: prefer the model that reduces P&L drift, not the fanciest one.

Match model to asset: equities, indices, FX, commodities

Match by the asset's return drivers and market conventions. Equities: earnings, dividends, and jumps matter - add jump diffusion or local volatility if you see event-driven fat tails; for large-cap liquid names, BS plus dividend adjustments often suffices.

Indices: they embed basket effects and volatility clustering; Heston or a local‑stochastic hybrid works better, and remember index options link to VIX futures - calibrate to both option and variance swap markets when available.

FX: dealers use SABR and stochastic‑vol models because FX smiles persist and behave asymmetrically across maturities; also respect market quoting conventions (delta vs. strike) and smile interpolation rules used by brokers.

Commodities: model mean reversion and seasonality - Schwartz two‑factor or jump‑diffusion variants are common. For commodity options on futures, price with Black on the futures curve, and add mean‑reversion adjustments for longer maturities.

• Check liquidity: thin markets favor simpler models
• Test for jumps: if tail events explain >5% of realized variance, add jumps
• Respect market conventions: forward vs spot quoting, delta conventions

Actionable checklist: gather 90‑day option surface, forward curve, and corporate event calendar; run benchmark BS/Black fits, then add Heston or SABR only if residuals exceed your risk budget. One‑liner: match the model to what actually moves the asset, not to elegant math.

Consider complexity vs. data availability and speed

Complex models buy fit at the cost of data needs, compute, and fragility. If you have sparse strike/maturity data or short latency needs, a heavy model will overfit and slow trading. Put another way: complexity must pay for itself in reduced hedging losses or lower capital charges.

Quantify your limits: for market‑making, aim for repricing latency under 200 milliseconds per option; for intraday hedging, require intraday recalibration under 5 minutes; for overnight risk reporting, a calibration window under 30 minutes is acceptable. If your infra can't meet those targets, pick a simpler model.

Best practices:

• Start with a benchmark and measure residuals
• Use regularization to avoid overfitting
• Hold out maturities to test out‑of‑sample fit
• Track parameter drift and flag >20% day‑to‑day moves
• Profile compute: GPU for Monte Carlo, FFT for characteristic‑function methods

Steps to implement: (1) define latency and calibration SLAs, (2) prototype models on a 30‑day tick sample, (3) measure P&L impact of model switch on a defined strategy, (4) move to production if benefits exceed operational costs. One‑liner: tradeoff = accuracy versus speed and data - be practical, not purist.

Next step - Quant: prototype a Heston calibrator on your 90‑day surface by Thursday; Trading ops: deliver fills and mid/ask data for the same period.

Inputs and market data

You're building or running an options model and you need clean, timely market inputs so pricing, Greeks, and risk aren't garbage-in/garbage-out. Here's the short take: prioritize timestamped top‑of‑book and trade ticks, an arbitrage‑checked vol surface, and correct discount/dividend curves.

Price feeds: underlying, option mid/ask-bid, volumes

If your model uses stale or ill‑formed quotes, your P&L and hedges will drift fast - so treat price feeds as the foundation. Start by demanding these fields on every update: source, server timestamp (UTC), exchange timestamp, bid, ask, bid size, ask size, last trade price, last trade size, and sequence number.

Practical steps:

• Store raw ticks with millisecond timestamps for at least the previous 90 days.
• Compute mid = (bid + ask)/2; mark quotes older than 500 ms for HFT desks, 5 s for systematic options desks.
• Flag spreads where (ask-bid)/mid > 10% as illiquid and route to fallback logic.
• Record exchange-level volumes and trade prints; compute 1‑minute VWAP for execution simulation.
• Keep an L1 (top‑of‑book) and L2 (order book depth) pipeline; L2 useful when implied vols inferred from deep strikes.

Best practices:

• Synchronize clocks with NTP+PPS; require ±1 ms precision where you hedge intraday.
• Maintain a failover feed and a reconstituted mid from consolidated prints if the primary feed gaps for > 2 s.
• Log feed outages and set automated alerts at 30 s of no ticks for active symbols.

One-liner: keep every tick, timestamp it tightly, and kill trades on stale quotes - easy to say, hard to regret. (Yes, you'll defintely thank yourself.)

Vol surface: implied vols by strike/maturity, interpolation

You need an arbitrage‑free implied volatility (IV) surface sampled across strikes and expiries the desk actually trades. Use IVs, not raw prices, for interpolation and for Greeks that scale sensibly across maturities.

Concrete steps to build and maintain the surface:

• Collect market IVs for each traded option; if only prices available, invert using the pricing model you standardize on (Black‑Scholes for equities, Black76 for futures/indices).
• Define a grid: near‑ATM strikes every 1% moneyness up to ±10%, then every 2.5-5% out to your limit; expiries weekly up to 3 months, monthly to 2 years, then quarterly.
• Interpolate in total variance (variance = IV^2 T) rather than IV directly; use monotone cubic splines or SVI/parametric fits to avoid butterfly/calendar arbitrage.
• Regularize fits: add a smoothness penalty to prevent overfitting to noisy quotes; reserve a set of expiries as holdouts to detect overfit.
• Impose bounds: cap extrapolated IV at sensible extremes (e.g., 500% for single names only) and force non‑negative calendar spreads.

Operational checks:

• Run daily arbitrage checks: calendar (shorter expiry variance ≤ longer expiry variance), strike convexity (call price convex in strike), and forward monotonicity.
• Rebuild the surface at least once per trading day; for active desks, re‑fit every 15-60 minutes or on material market moves > 1% underlying move.
• Store both raw market IVs and fitted IVs so you can reproduce P&L and debug mis‑pricings.

One-liner: fit on variance, enforce arbitrage rules, and keep the raw quotes - your calibration should be explainable in 10 lines of code.

Interest rates, dividends, and corporate events

Discounting and expected cash flows change option values materially; get the right curves and event data and wire them into pricing and Greeks.

Key inputs and how to use them:

• Build currency-specific discount curves. For collateralized instruments use the OIS curve for discounting in that currency; for uncollateralized trades use the appropriate Libor/term curve if required by contract conventions.
• Use zero rates or discount factors; interpolate on log(discount factor) or piecewise linear zero rates to avoid arbitrage in short maturities.
• For equities, model dividends as either continuous yield or discrete cash flows. For single-stock options with known upcoming payouts, use discrete dividends with ex‑date and amount; for unknowns use forward dividend yields estimated from futures or consensus.
• Ingest corporate event feeds (earnings, mergers, special dividends, spin‑offs) with event timestamps and cash amounts; automatically mark options crossing ex‑dividend dates for forward price adjustments.

Checks and operational rules:

• Reconcile dividend forecasts daily against exchange notices; if a dividend amount changes, reprice affected expiries and re‑compute Greeks immediately.
• For FX options, build two curves (domestic and foreign) and use the interest rate differential to compute forward rates; refresh curves at market open and on central-bank announcements.
• Flag instruments tied to corporate actions; require manual sign‑off for automated hedges across ex‑dates or when a special dividend > 1% of spot is announced.

One-liner: discount right, model dividends discretely when known, and treat corporate events as trading‑day shocks you must react to within minutes.

Calibration and parameter estimation

You need a daily, disciplined calibration process so model prices and Greeks match live markets and so you can measure parameter risk; do that before you trade or hedge. Here's the quick math: weight fit by vega, prefer priceRMSE or volRMSE as objective, and keep a fallback if calibration fails.

Calibrate the volatility surface daily and use robust optimizers

If you trade options, calibrate the volatility surface at least daily at your main mark (typically market close) and rerun intraday for material moves. Use price-weighted or vega-weighted objectives rather than plain vol differences so the fit reflects P&L impact.

Practical steps:

• Collect end-of-day mid prices for underlying and options, plus bid/ask spread and traded volumes.
• Choose objective: minimize weighted RMSE on implied vols or option prices; weight by vega or traded volume.
• Start with a local optimizer (Levenberg‑Marquardt) and fall back to global methods (differential evolution or CMA‑ES) for nonconvex models.
• Set convergence tolerances: objective change 1e-6, parameter change 1e-6, and max iterations 500.
• Implement parameter bounds and soft constraints to keep parameters in economically sensible ranges.
• Store calibration diagnostics: objective value, Jacobian condition number, runtime, and residuals per strike/maturity.

Fallback rule: if global optimizer fails or condition number > 1e8, revert to a simpler benchmark surface (SABR to local vol smoothing) and flag trading ops. One-liner: calibrate daily, fail safe, and log everything.

Avoid overfitting using holdout maturities and regularization

Overfitting eats hedges and creates hidden risk. Use holdout maturities and regularization to ensure the surface generalizes to strikes and tenors you will actually trade.

Concrete tactics:

• Hold out between 1 and 3 maturities (short, mid, long) from the calibration set and use them for validation each run.
• Apply penalized objective: objective + lambda roughness, where roughness can be the squared second derivative of the vol surface.
• Start lambda near 1e-3 (tune between 1e-4 and 1e-2) and pick via cross-validation minimizing out-of-sample volRMSE.
• Limit free parameters: keep pars under about 10 for daily calibration on sparse data to avoid instability.
• Use information criteria (AIC/BIC) or K-fold time-series cross-validation across rolling windows to compare model complexity.
• Compare to a simple baseline (flat/local vol interpolation) and require that your complex model reduces out-of-sample RMSE by a material margin, e.g., > 10%.

Quick math: objective_with_reg = data_loss + lambda integral((d^2 vol / dK^2)^2 dK dT). What this estimate hides: lambda choice depends on liquidity and strike granularity, so tune per asset and tenor. One-liner: validate on held-out maturities and penalize wiggles.

Track parameter stability and quantify parameter risk

Parameters are not immutable. Track them, quantify how parameter moves change prices and Greeks, and turn instability into actionable limits and hedges.

Operational checklist:

• Persist parameters daily and compute rolling statistics over 30 and 90 day windows: mean, std, max drawdown, and autocorrelation.
• Alert when a parameter moves more than 3 sigma or changes by > 20% day-over-day.
• Estimate parameter covariance and run sensitivity bumps: price portfolio for a +1% shift in each parameter and calculate P&L per 1,000 contracts to scale risk.
• Run Monte Carlo draws from parameter covariance to produce a distribution of portfolio P&L; report 95th percentile loss as parameter-risk VaR.
• Perform stress tests using historical worst daily parameter moves (past year) and an extreme but plausible scenario (e.g., simultaneous +30% vol of vols shock).
• Define playbook: if parameter instability triggers, tighten new trade limits, increase hedging, and switch to benchmark model until stability returns.

Example: if a vol-of-vol parameter historically ranges ±0.05 and a sudden jump adds 0.12 to that parameter, repricing shows a potential P&L swing of > $250k on a mid-size inventory - act immediately. One-liner: log parameters, quantify how moves hit P&L, and automate the alerts.

Next step: Quant team to implement daily calibrator with vega-weighted objective, regularization lambda set to 1e-3, and parameter tracking dashboard by Friday; Trading ops to verify alerts and risk to sign off on trigger thresholds.

Backtesting and validation

Simulate P&L with historical fills and slippage

You're testing model P&L and need realistic trade reconstruction before you trust any signals.

Start by recreating fills from market data rather than assuming mid prices. Use real timestamps, trade sizes, and venue-level bids and asks to produce fills that reflect latency and partial fills.

• Replay market-by-order or top-of-book data to reconstruct fills
• Apply realized bid-ask spread from same-date quotes, not theoretical spreads
• Model slippage as two components: static spread and size-driven impact

Here's the quick math for a single option trade: assume mid price 2.00, half-spread 10 bps (0.0001 of underlying), and size-driven impact of 5 bps per 10% of ADV executed; a 20% ADV execution costs mid ± (10 bps + 2×5 bps) = ±20 bps.

Best practices:

• Use fill-level slippage calibrated from historical executions over the last 12 months
• Include commissions, exchange fees, and clearing fees in P&L
• Simulate partial fills and order re-pricing for limit orders
• Stress-test with +50% and -50% of observed slippage to see sensitivity

What this estimate hides: market impact is nonlinear on large flows and differs in stressed windows; simulate concentrated days separately to capture tail costs - defintely keep a conservative bias.

One-liner: Replay real fills with spread + size impact to get actionable P&L.

Validate Greeks via finite differences and scenario tests

You need to prove the model's sensitivities actually move like the market's during real moves.

Use finite-difference checks to compare analytic Greeks to numerical approximations. Prefer central differences for accuracy: bump underlying up and down, recompute prices, and compute delta = (P_up - P_down)/(2×ΔS). For gamma use second differences. For vega bump implied volatility by a small absolute amount and recompute price change.

• Recommended bump sizes: underlying 0.1% or $0.01 for low-price names
• Vega bump: 1 vol point (1 percentage point) for liquid options
• Theta check: advance valuation date by 1 day and compare price decay
• Use central differences where possible to cut truncation error

Run scenario tests in parallel: apply historical jumps (overnight gaps and intraday shocks) and multi-factor moves (rates and FX together) to verify cross-Greek behavior like vanna and charm. Compare realized P&L sensitivities from those scenarios to model-predicted P&L using Greeks.

Practical checks:

• Flag mismatches > 10% between analytic and numeric Greeks
• Log per-instrument and per-strike deviations and trace to interpolation or boundary issues
• Test Greeks at wings and near expiry separately - errors concentrate there

Limit: very small bumps amplify numerical noise; very large bumps break linearity - pick mid-sized bumps and report sensitivity to bump size.

One-liner: Verify Greeks by comparing analytic outputs to central finite differences and real shock scenarios.

Use walk‑forward tests and out-of-sample performance

You must prove the model works forward in time, not just on the days you used to fit it.

Design a rolling calibration / test split. Example: calibrate model on the past 90 days, test on the next 30 days, then roll forward by 30 days and repeat for the full historical horizon.

• Track metrics per test window: net P&L, Sharpe, hit rate, realized vs model vega, max drawdown
• Measure calibration error (RMSE of implied vol surface) in vol points; target <5 vol points for liquid indices
• Compare in-sample vs out-of-sample RMSE - if out-of-sample > in-sample × 1.5, suspect overfitting
• Include regime splits (high vol vs low vol) and test performance separately

Walk-forward steps:

• Define calibration window and test horizon
• Calibrate parameters on the window
• Simulate trades in the test horizon using only calibrated parameters
• Record metrics and roll forward

Validation gates:

• Reject parameter sets where out-of-sample P&L median is negative over > 6 rolling windows
• Require Greeks stability: parameter drift less than 30% over adjacent calibrations
• Automate monthly reports showing where out-of-sample errors cluster

What to watch: data snooping in regime changes and stale reference data; always hold a final unseen period (at least 6 months) as a last out-of-sample check before production.

One-liner: Run rolling calibrations and require stable out-of-sample metrics before you trade live.

Next step: Quant - schedule a 90/30 walk-forward run over the last 36 months and deliver the out-of-sample P&L and RMSE report by Friday; Ops - provide fills and venue fees for the same period.

Working with Options Trading Models - Risk management and live monitoring

You're running live options trading and need tight, actionable monitoring so small model or market moves don't become large losses. Short takeaway: watch Greeks in real time, set clear, scaled limits, and automate high-fidelity alerts tied to concrete thresholds.

Monitor Greeks: delta, gamma, vega, theta intraday

Keep a live Greek view at the instrument and aggregated desk level; update cadence depends on your activity: 1-minute for market-making, 5-minute for active trading desks, 15-minute for portfolio rebalancing. One-liner: keep Greeks visible and timestamped - stale risk kills P&L.

Practical steps:

• Stream market data into the risk engine and recalc Greeks on every fill and mid-price change.
• Maintain both analytic (closed-form) Greeks and finite-difference Greeks for cross-checks; reconcile hourly.
• Show per-spot, per-expiry, and per-strike views plus aggregated net exposure by underlying.

Quick math and examples: use the standard first- and second-order expansion: P&L ≈ delta·dS + 0.5·gamma·(dS)^2 + vega·dσ + theta·dt. So if your portfolio has net vega = 500 (dollar sensitivity per 1 vol point), a 1 percentage-point vol move implies ~$5,000 change in mark (500·0.01·100 where 100 is contract multiplier) - adjust numbers to your contract multipliers. What this hides: contract multipliers, option quoting convention, and correlation between delta and vega, so track cross-greek interactions.

Set limits: position, vega buckets, VaR, stress scenarios

Translate risk appetite into operational limits that scale by trader, strategy, and tenor. One-liner: limits must be numeric, tiered, and enforced automatically.

Concrete limit framework (example starting points you can tune):

• Position limits: per-underlying net delta cap $25,000,000 notional, trader-level cap $5,000,000.
• Vega buckets: bucket by tenor (0-30d, 31-90d, 91-365d, >365d) with bucket vega-dollar caps, e.g., $5,000,000, $7,500,000, $10,000,000, $3,000,000.
• VaR: set intraday stop triggers at Mk-to-Market VaR (95% 1-day) breaches; example: hard stop if daily VaR > $3,000,000, escalation if > $4,500,000.
• Stress tests: run scenario shocks on every pricing update - examples: 20% underlying shock + vols +100% ATM, or multi-factor shock (FX move + rate shock) and enforce tiered limits on resulting losses.

Best practices: tie limits to capital and funding - e.g., limit vega so a 1% vol jump would consume no more than 20% of risk budget. Recalibrate limits quarterly and after regime shifts; defintely lower caps during earnings or known liquidity windows.

Automate alerts for model drift, stale quotes, and P&L gaps

Alerts must be measurable, actionable, and routed to the right owner. One-liner: automate noise-free alerts so traders act before losses accumulate.

Key alert types and thresholds (examples):

• Model drift: flag if root-mean-square (RMS) repricing error across traded strikes > 0.5% over a 30-minute window.
• Stale quotes: flag market feed if mid not updated for > 5 seconds on liquid underlyings or > 30 seconds on OTC/illiquid markets.
• P&L gaps: alert if intraday mark-to-market change vs. expected P&L > $250,000 or > 20% of daily VaR.
• Parameter shifts: alert when calibrated param moves exceed historic volatility bands (e.g., implied vol sigma up > 30% vs 30-day median).

Implementation steps:

• Build a rules engine that consumes market, trade, and model outputs and emits graded alerts (info, investigate, stop).
• Attach automated remediation actions: soft alerts to traders, hard rules to kill new order entry when a stop-level breach occurs.
• Log every alert with full state (timestamp, market snapshot, model version) for post-mortem and regulatory audit.

Operational SLAs: triage critical alerts within 5 minutes, investigate within 30 minutes, and resolve or escalate within 4 hours. Keep an on-call rotation between quant, trading ops, and risk so alerts don't sit idle.

Next step: Trading ops - implement a 1-minute Greeks dashboard plus the three automated alerts above (model drift, stale quote, P&L gap) by Friday; Risk verifies rules and limits the following Monday.

Conclusion

Prioritize data quality, calibration discipline, and simplicity

You're running models that make live trades, so bad data or sloppy calibration will cost real money fast - fix the basics first.

Takeaway: make market data and calibration your first line of defense; everything else is secondary.

Steps to follow:

• Ingest: use exchange feeds for underlyings and a consolidated options tape for bids/asks.
• Sanity-check: drop ticks with implied vols outside historical bounds; flag spreads > 5%.
• Clean: apply microstructure filters (remove outliers, merge prints within 1 second).
• Fill gaps: backfill missing strikes with arbitrage-aware interpolation.
• Audit: run daily data-quality reports with counts of stale quotes and missing expiries.

Calibration discipline:

• Calibrate on a fixed schedule-ideally every trading day and after major events.
• Use robust optimizers (Huber, regularized least-squares) to avoid wild fits.
• Reject fits where weighted RMSE > 2% of mid-premium or IV surface residuals exceed thresholds.

Simplicity rules: prefer the simplest model that passes validation. Complexity only if it improves out-of-sample P&L.

One-liner: Small, clean data and daily calibration beat clever models with noisy inputs.

Start with a sound benchmark model and iterate with tests

You need a baseline so you know if fancy models actually add value; start simple, measure, then add complexity.

Takeaway: pick a benchmark, automate tests, then escalate complexity only when you prove gains.

Concrete steps:

• Choose benchmark: standard Black‑Scholes (or Black for futures) as the baseline.
• Document assumptions: input sources, interpolation method, time-count convention.
• Automate a battery of tests: unit pricing checks, Greek cross-checks, and P&L replay.
• Run walk-forward: roll calibrations daily and evaluate 30/60/90-day out-of-sample errors.
• Escalate methodically: only add stochastic vol (Heston/SABR) if benchmark residuals persist above 2% and out-of-sample P&L improves.

What to measure:

• Pricing error: weighted RMSE on mid prices.
• Greek accuracy: finite-difference checks with central step sizes (delta step = 0.1% underlying).
• Trading impact: simulated fills with realistic slippage and commissions.

One-liner: Benchmark, test, prove, then complicate-don't reverse the order.

Assign ownership: quant builds, trading ops monitors, risk verifies

You'll lose control without clear ownership; assign roles with specific deliverables and SLAs.

Takeaway: clear handoffs reduce blind spots-give each team measurable tasks and thresholds.

Recommended RACI-style assignments and tasks:

• Quant (responsible): build models, write calibration code, produce daily parameter reports, and version models in git.
• Trading ops (accountable): run production jobs, validate live feeds, and handle execution knobs (hedge engines, order params).
• Risk (consulted/verified): set position and Greek limits, run daily VaR and stress tests, and approve model changes.

Operational rules and SLAs:

• Deploy: any model change must pass unit tests and a 7-day parallel run before production.
• Monitoring: ops alerts when Greeks move > 3x intraday expectation or if quote staleness > 30 minutes for major expiries.
• Escalation: if model drift triggers, quants have 4 hours to submit a remediation plan; trading reduces flow exposure in the meantime.

Ownership example: quant owns calibration code; ops owns the job schedule; risk signs off on limits and post-trade reconciliations.

One-liner: Definite owners, clear SLAs, and automatic alerts keep models honest - and your P&L intact.

Next step: Quant: deliver the baseline Black‑Scholes benchmark, daily calibration script, and a 30-day walk-forward report by Friday, Dec 5, 2025.