Aura: Institutional Variance Engine

An institutional volatility engine that leverages zero-shot foundation models to identify and capture variance mispricing via delta-neutral straddles.

Comment

Inspiration

Most retail-facing fintech tools focus on directional price prediction (e.g., "Will Apple go up?"). However, in the institutional world, directional prediction is often a fool's errand due to market efficiency and exogenous shocks. We were inspired by the Variance Risk Premium (VRP)—the idea that the market often misprices the magnitude of future volatility rather than its direction. We wanted to build a tool that shifts the focus from "where" the price is going to "how much" it will move, enabling traders to capture alpha through delta-neutral volatility arbitrage.

What it does

AURA is an institutional-grade variance mispricing engine. It scans a universe of high-liquidity equities (S&P 100), calculates a probabilistic forecast of future volatility using a zero-shot foundation model, and compares it to live options market data.

  • Macro Screener: Batches the entire S&P 100 into a single GPU pass to identify the largest spreads between predicted volatility and Implied Volatility (IV).
  • Risk Engine: Calculates Black-Scholes Greeks (, ) to ensure trades are market-neutral and sized by their true payout potential.
  • Agentic Execution: Routes the highest-conviction signals through a deterministic Gemini 3.1 Pro router to generate machine-readable JSON trade tickets.
  • Model Calibration: Provides a walk-forward backtest to visually validate the model’s predictive accuracy against realized price action.

How we built it

AURA is powered by a high-performance quantitative pipeline:

  1. Inference Engine: We utilized Amazon’s Chronos-Bolt (Base) foundation model. We optimized this for an NVIDIA H200 by stacking the price history of 100 assets into a single 2D PyTorch tensor, allowing for simultaneous parallel forecasting.

  2. Mathematics: We extract annualized volatility () from the model's 10th and 90th percentile quantiles using a log-return standard deviation proxy:

  3. Options Layer: We integrated yfinance to pull live options chains, dynamically aligning the 15-day forecast horizon with the closest tradable expiry (21 calendar days) and averaging the IV of ATM Calls and Puts to determine the Straddle Mid-IV.

  4. UI: Built a multi-tab Gradio dashboard mimicking a Bloomberg terminal for Macro Screening, Micro Deep Dives, and Out-of-Sample Calibration.

Challenges we ran into

  • Horizon Mismatch: Initial iterations compared 15-day forecasts to random option expiries. We had to build a dynamic "Expiry Alignment" logic to ensure our predictions matched the market's term structure.
  • Market Microstructure: We realized that a raw volatility spread isn't "arbitrage." We had to account for liquidity (Open Interest filters) and the costs of maintaining delta-neutrality (Gamma Scalping), which we modeled as a dynamic transaction cost penalty based on bid-ask spreads.
  • Hardware Efficiency: Early versions used Python loops to scan tickers, which was too slow. Moving to batched tensor operations on the H200 was a massive engineering hurdle that ultimately allowed the system to scale to the S&P 100 in seconds.

Accomplishments that we're proud of

  • Institutional DNA: We moved beyond "LSTMs for price prediction" and built a system that uses the same Greeks and variance strategies used by professional market makers.
  • Zero-Shot Reliability: Proved that a general-purpose foundation model (Chronos) can be calibrated for finance-specific volatility extraction without any fine-tuning.
  • Hardware Flex: Successfully utilized the H200’s massive VRAM to run a full-market quantitative scan in a single forward pass.

What we learned

We gained deep insights into Volatility Clustering and the Term Structure of Volatility. We learned that in quantitative finance, the "Edge" is often found in the spreads between models, and that risk management (liquidity gating and Greeks) is just as important as the signal itself.

What's next for Aura

  • Fat-Tail Integration: While Chronos is excellent for baseline variance, equity markets exhibit Leptokurtosis (fat tails). We plan to ensemble Chronos with a GARCH(1,1) model to better capture event-driven jumps (like earnings).
  • Live OMS Integration: Connecting the agentic JSON tickets to a live broker API (e.g., Alpaca or Interactive Brokers) for automated execution.
  • Path-Dependent Backtesting: Developing a tick-level simulation engine to track the cumulative P&L and Sharpe ratio of our delta-neutral straddle strategies over a multi-year horizon.

Built With

  • chronos-bolt
  • gemini-3.1-pro-api
  • gradio
  • matplotlib
  • numpy
  • nvidia-h200
  • python:
  • pytorch
  • scipy
  • yfinance
Share this project:

Updates