Arbiter: The World's First Futures Exchange For GPU Compute

Starbucks hedges coffee beans. Tesla hedges battery metals. The AI economy spends billions on GPUs with zero way to manage risk. Arbiter fixes that. GPU futures, a new asset class.

Comment

Inspiration

We kept hearing the same story: AI startups burning through runway not because their models failed, but because GPU costs spiked unexpectedly. A company budgets \$50K/month for H100s, then spot prices swing 40% and suddenly they're bleeding cash.

Starbucks hedges coffee. Tesla hedges lithium. Airlines hedge jet fuel. But the AI economy, spending over \$200B annually on compute, has zero financial instruments to manage price risk.

We thought: why doesn't a GPU futures market exist? So we built one.

What it does

Arbiter is a derivatives exchange for GPU compute. We aggregate real-time spot prices from 5 cloud providers (AWS, Azure, GCP, RunPod, Vast.ai), fit quantitative models to predict price movements, and let users trade forward contracts on future GPU spot prices.

Users can:

  • Analyze pricing across 18 GPU types (H100 SXM, H200, B200, A100, L40S, and more) with live and historical data spanning 82,000+ data points over 90 days
  • Model volatility using Ornstein-Uhlenbeck mean-reversion fitting with Monte Carlo forward curves and confidence intervals
  • Trade forwards on a peer-to-peer order book with real-time WebSocket streaming of bids, asks, and fills
  • Hedge risk by comparing cost-at-risk under spot, forward, and option strategies via 20,000-path Monte Carlo simulation
  • Mint contracts on Solana as transferable SPL token NFTs encoding GPU type, price, delivery window, and settlement terms
  • Optimize for sustainability with carbon intensity tracking across 19 cloud regions, where the same workload can produce 226x more emissions depending on region choice
  • Get AI-powered recommendations from a Claude-powered agent that analyzes natural-language workload descriptions and returns optimal GPU/region/strategy combinations across three dimensions: FASTEST, CHEAPEST, and GREENEST

How we built it

Rails Backend (Ruby on Rails 8.1): The heart of Arbiter. Rails handles the REST API layer, order matching engine (price-time priority), carbon calculator, hedging strategy service, and real-time order book streaming via Action Cable WebSockets. We use Rails 8's Solid trifecta (Solid Cache, Solid Queue, and Solid Cable) for caching, background jobs (price ingestion, model fitting), and WebSocket pub/sub. Active Record manages 6 models (Gpu, SpotPrice, Order, Trade, CarbonRegion, ModelResult) backed by SQLite.

Python Compute Service (FastAPI): A microservice called by Rails for numerically intensive work. Implements the Ornstein-Uhlenbeck model fitting via maximum likelihood estimation, Monte Carlo simulation for forward curves and hedging analysis, and options pricing. Uses NumPy and SciPy for scientific computation.

AI Agent (Claude Sonnet 4.6 via AWS Bedrock): Our agent receives a natural-language workload description (e.g., "I need 1000 GPU hours for language model training"), gets injected with live market context (current spot prices, carbon intensities, forward curves), and returns structured JSON recommendations for three options (FASTEST, CHEAPEST, GREENEST), each with GPU type, region, strategy, total cost, and CO2 estimate. Temperature is set to 0.1 for deterministic, reliable outputs.

Frontend (Next.js 16 + React 19): Interactive dashboards built with Recharts for price charts, forward curves, seasonality patterns, and hedging comparisons. Tailwind CSS for styling. Connects to Rails via REST and Action Cable WebSocket for real-time order book updates.

Blockchain (Solana + Anchor): Each forward contract is minted as an SPL token (supply=1, decimals=0) on Solana devnet. The on-chain program stores contract metadata in a PDA: contract ID, GPU key, quantity hours, price per GPU-hour (in lamports), delivery window, buyer/seller pubkeys, and status (Active/Settled/Cancelled). Tokens are transferable for secondary trading and burn on settlement.

The Quant Model: GPU spot prices exhibit mean-reversion, similar to commodities. We model this using the Ornstein-Uhlenbeck process:

$$dP_t = \theta(\mu - P_t)dt + \sigma dW_t$$

Where \( \theta \) captures how fast prices revert to the long-term mean \( \mu \), and \( \sigma \) measures volatility. We fit parameters using maximum likelihood estimation on the discretized process across 82,000+ historical price points, then generate forward curves across 11 time horizons (1 to 90 days) with 95% confidence intervals.

Challenges we faced

Data sparsity and normalization: Unlike equities with millisecond-resolution data, GPU prices update every few hours. We built custom ingestion pipelines pulling from SkyPilot catalogs and the AWS EC2 Spot Price API, accumulating 82,000+ price points across 10 providers, 19 regions, and 18 GPU types. Every provider names GPUs differently: AWS calls it p5.48xlarge, Azure calls it Standard_ND96isr_H100_v5, Vast.ai just says H100 SXM. We built a resolution layer mapping 66 provider-specific variant names to 18 canonical GPU keys.

Microservice orchestration: We needed Rails for its strengths (real-time WebSockets, API design, ORM, background jobs) and Python for its strengths (NumPy, SciPy, scientific computing). Getting the two to communicate reliably (Rails calling FastAPI via HTTParty with proper error handling and timeouts) required careful API contract design and fallback behavior.

Settlement mechanics: How do you settle a GPU futures contract? Traditional futures use physical delivery or cash settlement. We chose to mint each trade as an SPL token on Solana. The NFT encodes full contract terms in a PDA, is freely transferable for secondary trading, and burns on settlement, giving us verifiable, composable financial instruments.

Making carbon actionable, not decorative: It's easy to slap a carbon badge on a dashboard. We wanted carbon to be a first-class input to every decision. That meant integrating intensity data into the AI agent's recommendations, the hedging calculator, and the region comparison tool, so users see the environmental cost alongside the dollar cost at every step.

What we learned

  • GPU prices are surprisingly volatile and exhibit clear mean-reversion patterns, making them mathematically well-suited for derivatives pricing using OU processes
  • The cloud compute market is incredibly fragmented: price discrepancies of 15-20% exist between providers at any given moment, creating natural arbitrage opportunities
  • Carbon emissions for the same workload can vary by 226x depending on region (Stockholm at 3 gCO2eq/kWh vs. Mumbai at 679 gCO2eq/kWh), yet almost no one optimizes for this when choosing where to run GPU workloads
  • Rails 8's Solid stack (Cache, Queue, Cable) makes it remarkably productive for building real-time financial applications. Action Cable handled our live order book with zero custom JavaScript
  • Solana's Anchor framework and PDA pattern make on-chain structured data storage surprisingly accessible
Share this project:

Updates