Your AI bill is a commodity position.

Compute is a commodity. Your budget treats it like a subscription.

Companies shipping AI have taken on a commodity position nobody priced. Four things are true at the same time, and they push the same direction.

GPU-hours have a spot price

Rented accelerator capacity reprices week to week and public indices already quote it. If you buy on demand, you hold that price risk with no cap and no forward.

Token prices are a floating rate

Providers cut list prices, raise them, deprecate models, and move your mix underneath you. A rate card is the price you pay this quarter, not a fixed cost.

Usage grows with the product

Every agent you ship raises consumption. Volume growth and price moves compound, and the usual remedy is to make the product worse.

Nobody holds the position in dollars

Finance sees one invoice a month. Engineering sees tokens per request. Neither is an exposure, and you cannot bound what nobody has written down as a dollar position.

The first deliverable is the position, not a trade. Most teams cannot answer how many dollars of next quarter’s AI spend are price and how many are volume. That number is computable from telemetry they are already emitting.

From gateway telemetry to a bounded cost line

Hedgerouter is not a model router. Keep whatever gateway chooses and serves your models; Hedgerouter reads its output and prices the exposure underneath it.

1. Ingest

   NDJSON exports, JSON access logs, OTLP spans, Claude Code transcripts. Nothing new to instrument, and replaying the same export twice is idempotent.

2. Normalize

   Model, provider, token counts, realized cost, latency, status, failover. The boundary is an allowlist, so prompts, paths, tool arguments and identities are never read in.

3. Position

   A daily ledger in dollars and tokens by model, provider and route, with the price component separated from the volume component.

4. Price

   Public compute indices and listed contracts, quoted at prices you could have transacted at, with fees included. No midpoints nobody could have traded.

5. Size

   A hedge is sized against a stated budget with a per-event cap, and never larger than the exposure it covers. Sizing runs before anything is placed, not after.

6. Report basis

   What fraction of your actual cost line an instrument tracks. Until a real ledger has been compared against a contract, every sizing says basis is not measured, and it never assumes zero.

Where this risk is becoming tradeable

A hedge is only as good as the instrument under it, so the question is never “is there a contract” but “what does it settle on”.

Compute-price indices are the arm we instrument first, because for a team renting capacity they are the exposure itself rather than a proxy for it. A hedge on the wrong variable costs premium and leaves the risk in place, so every sizing states basis, as “not measured” until a real ledger has been compared, rather than assuming it away.

Token prices as a macro position

Take volume out and an AI bill is a position on the level of list prices: one number per model per direction, set by the provider and repriced in steps. Kalshi lists that level as a ladder of yes/no contracts, so what the market charges for protection can be read straight off its books. Below are the live quotes on 19 October 2026 for every open per-token list-price ladder. Each contract pays $1 if the provider’s published price is at or below the strike in 2026.

Locked rate: a price cut strands you

If you committed to a rate and the provider cuts list, you keep paying the old price. The cover is YES on every rung below your rate, sized so the payout at each strike equals the loss there. On a $30 output rate the $25 rung asks 11¢ for $1 of cover.

Floating rate: a rise has no listed cover

If you pay list and fear a rise, the planner buys NO on rungs above your price. Every listed rung for the GPT 5.5 example sits below its rates, so hedge-plan --posture floating returns zero legs. The market protects against cuts today and not against rises.

The whole market is small

About 50,000 contracts of open interest across all three models, which is at most $50,000 of payout. At the planner’s 25% cap per rung that is about $12,500 of cover, for every company at once. Depth, not price, is what limits a macro hedge here.

This is a level, not a forecast

Hedgerouter does not predict where prices go. It sizes cover against the price you are exposed to and states what it costs. Our own demand-based forecast failed its test, and the record says so.

Quotes are a snapshot from the public order books and move. A dash means no bid. Re-run them with hedge discover.

A worked example, and what the order book says

A synthetic company, not a customer: $15,445 a month on one model at a committed rate of $5 per million input tokens and $30 per million output. The plan below was sized against the live order books of the per-token list-price contracts on 18 October 2026.

$ hedge exposure
     gpt-5.5   input   49.6 MTok/day at $5.00
               output   9.0 MTok/day at $30.00

$ hedge hedge-plan --posture locked --horizon-days 90
     7 limit orders, 5,445 contracts, premium $606, fees at most $37
     every order limited by the 25% open-interest cap
     one rung skipped: no bid

The finding is the second column. The listed per-token contracts across all three models carry about 50,000 contracts of open interest in total, so a team spending $15,000 a month can already fill only a fraction of the cover it would want. The instruments are real and priced; the depth is not there yet. That is the reason to measure exposure before sizing anything, and it is the number to watch as these markets grow. Reproduce it.

What happens to an order

A plan becomes real limit orders, each built as the exact request the venue would receive, then passes caps and interlocks before anything can be sent. Everything below ran on 19 October 2026, on the synthetic ledger against live books. Unarmed, the code never opens a socket to a mutating endpoint, so no order reached a venue.

1. Quote

   One order per rung, joined one tick inside the best bid and never at or through the ask. A one-sided book is skipped: today the $10 GPT 5.5 output rung has no bid.

2. Cap

   The limits live inside the executor, not the CLI. Defaults: 10 contracts and $2 per order, 5 orders and $10 per run, a $25 minimum balance, nothing resting within 15 minutes of close.

3. Interlock

   Five must agree: a passing out-of-sample gate, an arming phrase, a trade-scoped key, no halt file, and an explicit --live. A missing one is named, not guessed.

4. Journal

   Every attempt, dry or live, is appended to a journal before it is sent. The client order id comes from market, side and observation time, so replaying a cycle after a timeout cannot double a position.

5. Send

   A signed request to the venue’s current create endpoint, post-only, cancelled if the venue pauses. Buying NO is an ask on the YES price, a detail that is easy to invert.

$ hedge hedge-open --posture locked --horizon-days 90
     mode dry-run, 0 orders built, 7 refused
     KXGPT55Y-27-NA-4   cap-contracts: 626 exceeds maxContractsPerOrder 10
     KXGBT55OY-27-NA-20 cap-contracts: 1528 exceeds maxContractsPerOrder 10
     ...
     blockers: gate-closed, not-confirmed, missing-credentials

$ hedge hedge-open --posture locked --horizon-days 90 \
    --max-contracts 2000 --max-orders 10 --max-notional 200 --max-notional-run 600
{
  "ticker": "KXGPT55Y-27-NA-4",
  "side": "bid",
  "count": "626",
  "price": 0.26,
  "time_in_force": "good_till_canceled",
  "self_trade_prevention_type": "taker_at_cross",
  "post_only": true,
  "cancel_order_on_pause": true,
  "client_order_id": "hedgerouter-d514db111edcb24da27dc8ec"
}

The finding is that the defaults refuse the whole hedge. They are sized so that the worst credible outcome of a first live run costs under ten dollars: that run tests the wire, not the thesis. With caps raised the same plan builds 7 post-only bids, 5,414 contracts and $463 of premium, and still sends nothing. Moving past ten contracts is a decision for after a real ledger gives a basis number. The executor has 18 tests; an armed send is exercised only against a recording transport, never the live venue.

The research record, including what failed

Most of the work so far was deciding what not to trade. These are the results, the negative ones included, and the order path stays shut because of them.

152 tests pass and the CLI has no runtime dependencies. Read the write-ups.

What runs today, and what doesn’t

Being specific here is cheaper than being caught out later. The measurement half is real and you can run it this afternoon. The order path is built and held shut: what authorises a live order is a research gate that has not opened, and on current data the demand signal is slightly worse than simply carrying the last index price forward.

The order path arms only when all five interlocks agree: a passing out-of-sample gate, an arming phrase in the environment, a trade-scoped venue key, no halt file, and an explicit flag. Anything missing is a dry run that prints the order it would have sent and names the interlock that stopped it. hedge live-status prints that list, and today it prints would_arm: false.

Your telemetry never has to leave your infrastructure

Normalization is an allowlist, not a log archive. The fields below are not filtered after the fact; they are never read into the ledger in the first place.

Read the boundary spec