Open Weight Takes 71.5% of Tokens and 23% of Spend: Reading the AI Gateway Production Index

Two shares, one gap

The 71.5% and 23% figures are not a contradiction and they are not a trick. They are two different shares of the same traffic: how many tokens a class of model processed, and how many dollars that class absorbed. Cheap models do volume, expensive models do the work that cannot be downgraded. Any functioning architecture produces a gap between those numbers.

The direction of travel is what matters. Open-weight spend share went from one in twenty gateway dollars in June to nearly one in four in September. Over the same window, spend on frontier models grew tenfold while open-weight spend grew more than seventyfold. Growth rates that differ by that much mean the mix changed, not just the budget.

The temptation is to read this as a verdict on quality. It is not. It is a statement about where the marginal token went: volume work moved down-market first, because that is where quality tolerance is widest and the savings are largest per unit of risk taken.

# Before you have an opinion about the index, compute your own version of it.
# Two numbers per model: share of tokens, share of spend. They almost never match,
# and the gap is the whole story.

import json
from collections import defaultdict

rows = [json.loads(line) for line in open("gateway-usage.jsonl")]

tok = defaultdict(int)
spend = defaultdict(float)
for r in rows:
    m = r["model"]
    tok[m] += r["input_tokens"] + r["output_tokens"] + r.get("reasoning_tokens", 0)
    spend[m] += r["cost_usd"]

T, S = sum(tok.values()), sum(spend.values())
print(f"{'model':38} {'tok%':>7} {'spend%':>8} {'ratio':>7}")
for m in sorted(tok, key=lambda k: -tok[k]):
    t, s = 100 * tok[m] / T, 100 * spend[m] / S
    print(f"{m:38} {t:7.1f} {s:8.1f} {s / max(t, 1e-9):7.2f}")

# A ratio well above 1 means the model is expensive relative to how much you use it.
# A ratio near 0 means it is doing volume work and should never be your cost problem.

The price per token fell 47%, and your bill went up

Spend up 13 times against December while price per token fell 47% is the least surprising sentence in the report and the one most often misread. Usage grew faster than price fell. That is what adoption looks like, and it is why cost governance that only negotiates unit price tends to lose.

Published rates also lie about your bill in specific ways: cache hits that were not counted, reasoning tokens that were not in the output estimate, retries that doubled the request, and failed calls that still consumed input. Effective price per million tokens, computed from your own logs, is the only unit that survives contact with an invoice.

The report is careful about this and says spending is estimated at published list prices, that actual bills may differ, and that token volume includes input, output, reasoning, cached-input and cache-creation tokens. Read that footnote before quoting any percentage in a budget meeting.

# Effective price per million tokens is the only comparable unit across models.
# Published rates lie about your bill in three ways: cache hits, reasoning tokens,
# and retries. Fold all of them into the same denominator.

def effective_price(calls):
    billable_in = sum(c.input_tokens for c in calls) - sum(c.cached_tokens for c in calls)
    billable_out = sum(c.output_tokens + c.reasoning_tokens for c in calls)
    cost = sum(c.cost_usd for c in calls)
    total = billable_in + billable_out
    return {
        "cost": round(cost, 2),
        "m_tokens": round(total / 1e6, 2),
        "usd_per_mtok": round(cost / max(total / 1e6, 1e-9), 3),
        "cache_hit_rate": round(sum(c.cached_tokens for c in calls) / max(billable_in, 1), 3),
    }

# Run this per model, per week. A model whose usd_per_mtok falls while its token
# share rises is being absorbed into the cheap tier of your architecture, which is
# exactly what the index describes happening across the whole gateway.

Almost one in three teams changed their most-used lab

That is the number I would put in front of a procurement team. A third of paying teams switching their most-used lab in one month is not brand churn, it is evidence that switching cost has collapsed. The report also notes that teams with at least 10 million tokens used an average of 15 different models over the period, rising to 26 above 100 million and 42 above a billion.

Read that as a scaling law for architecture rather than a shopping habit. The more traffic you have, the more slices of it you can afford to route separately, because each slice can be measured. Diversification is a by-product of having enough data to evaluate a second option.

The practical consequence is that routing policy deserves to be a versioned artifact. If it lives in one engineer's head, a model deprecation becomes an incident instead of a diff. The policy below is deliberately boring: tiers, rules, and an escalation path, all as data.

# Routing is a portfolio decision, not a favourite-model decision. Write the policy
# down as data so it can be reviewed, diffed, and rolled back like code.

POLICY = {
    "tiers": {
        "cheap":    {"max_in_per_mtok": 0.30, "models": ["open-weight-fast-a", "open-weight-fast-b"]},
        "balanced": {"max_in_per_mtok": 2.00, "models": ["mid-a", "mid-b"]},
        "frontier": {"max_in_per_mtok": 12.0, "models": ["flagship-a", "flagship-b"]},
    },
    "rules": [
        {"when": "task == 'classification'", "tier": "cheap"},
        {"when": "task == 'code_edit' and files_changed <= 2", "tier": "balanced"},
        {"when": "task == 'migration_plan'", "tier": "frontier"},
    ],
    "on_failure": {"retry_same_tier": 1, "then": "escalate_one_tier"},
}

def pick(task, files_changed=0):
    for r in POLICY["rules"]:
        if eval(r["when"], {"__builtins__": {}}, {"task": task, "files_changed": files_changed}):
            return POLICY["tiers"][r["tier"]]["models"]
    return POLICY["tiers"]["balanced"]["models"]

# Rule of thumb from the index: cost control comes from moving volume down a tier,
# never from switching the flagship. Switching the flagship moves 3% of your bill.
print(pick("classification"), pick("migration_plan"))

Spend at list prices is an estimate. Your invoice is the only number that counts.

Where the money actually moved

Some specifics from the report, because they are useful calibration. DeepSeek's models processed 58% of all gateway tokens for 6.6% of spend. DeepSeek-v4.1-Flash alone handled nearly half of September tokens for 2.6% of spend, at about a fifth of the open-weight average price per token. Kimi K3 accounted for nearly half the increase in open-weight spending while processing far fewer tokens.

On the closed side, Anthropic's share of gateway spend fell from 63.7% to 43.9%, the first time below half, with Opus accounting for 17 of the roughly 20 points lost. Jev reached 35% of paid teams in its first two weeks, the fastest adoption in the index's history, while accounting for 0.27% of gateway spend over that window. Opus 5.5 took more than one in ten gateway dollars in its own first two weeks.

The pattern to internalise: adoption share and spend share are different metrics and they point in opposite directions. A model can be everywhere and cost nothing, or be used by few teams and carry the bill. Judge a model launch by the metric that matches your workload, not by the one in the headline.

# Concentration check: how dependent are you on one lab? The index reports that
# teams above 10M tokens used an average of 15 models, 26 above 100M, and 42 above
# a billion. Volume forces diversification; policy should not lag behind volume.

from collections import Counter

def concentration(rows, by="lab"):
    spend = Counter()
    for r in rows:
        spend[r[by]] += r["cost_usd"]
    total = sum(spend.values()) or 1
    shares = [v / total for v in spend.values()]
    hhi = sum(s * s for s in shares)          # 1.0 = single vendor, lower = diversified
    return {
        "labs": len(spend),
        "top_share": round(max(shares), 3),
        "hhi": round(hhi, 3),
        "verdict": "fragile" if hhi > 0.5 else "concentrated" if hhi > 0.25 else "diversified",
    }

# A high HHI is not automatically bad. It is bad when you cannot name the second
# option, its measured quality delta, and the swap cost. If you cannot, you have a
# single point of failure with a monthly invoice attached.

Replaying your own traffic before you copy the market

This is where most teams get it wrong. They read that open weight is 71.5% of tokens, move a large slice of traffic to a cheaper model, and discover three weeks later that their tool-call accuracy dropped on the one workflow nobody wrote a test for. The report describes an aggregate; your task distribution is not the aggregate.

The defensible move is a replay: take last month's real traffic, compute what it would have cost under the proposed mix, and pair that with a measured quality delta on your own evaluation set. If you do not have an evaluation set, that is the actual blocker, and it is a bigger one than model choice.

One more thing the report makes plain without saying it: the labs are not competing on being irreplaceable any more, they are competing on being reselectable. Architect for that. Keep the provider boundary thin, keep prompts portable, and keep the routing table in version control so switching is an afternoon, not a quarter.

# Replay last month's traffic against a proposed mix. Estimates only: list prices,
# no cache effects you have not measured, and no retry amplification.

def replay(traffic, mix):
    # traffic: {"cheap": tokens, "balanced": tokens, "frontier": tokens}
    # mix: {"cheap": price_per_mtok, ...}
    return {tier: round(tokens / 1e6 * mix[tier], 2) for tier, tokens in traffic.items()}

current = {"cheap": 4.1e9, "balanced": 900e6, "frontier": 120e6}
old_mix = {"cheap": 0.06, "balanced": 0.90, "frontier": 5.00}
new_mix = {"cheap": 0.05, "balanced": 0.85, "frontier": 5.00}

print("current", replay(current, old_mix))
print("proposed", replay(current, new_mix))
# Move a slice of 'balanced' into 'cheap' only after you have measured the quality
# delta on your own eval set. The index says the market did this at scale; it does
# not say your task tolerates it.

Where a model is served matters for cost and latency, and increasingly for procurement.