Open Weights Take 78.4% of Gateway Tokens: Routing Flips

Vercel reported this week that open-weight models hit a record 78.4% share of token volume on its AI Gateway as of September 18, 2026 — with Moonshot AI third, DeepSeek fourth, and their combined spend alongside Z.ai surpassing OpenAI. The routing majority has flipped: most agent tokens now flow through open weights.

The data point matters because gateway volume measures production behavior, not press releases. Developers spending real inference budgets chose open models for more than three-quarters of tokens. Three facts anchor the report:

• Open weights at 78.4% of token volume is a record high, while closed models retain higher inference spend per token.
• Moonshot AI and DeepSeek rank third and fourth, with Z.ai completing the trio that collectively outspends OpenAI on inference.
• Spend reflects inference costs across providers, not revenue to labs — the signal is workload placement, not vendor victory.

This is the market verdict my value routing anticipated all year, the same accuracy-per-dollar lens as my BFCL analysis. Same math, now confirmed by gateway-scale behavior.

What 78.4% actually measures

Token volume share is not revenue share or task share — it is where the tokens physically ran. Open weights dominate volume because they run cheaply at scale: high-volume classification, extraction, reranking, and agentic loops where per-token price decides placement. Closed models keep higher spend because flagship reasoning still commands premium prices on the hard tail.

Here's the catch. Volume leadership without spend leadership describes a barbell: open models own the bulk commodity work — classification, extraction, reranking, high-volume loops — while closed models own the premium reasoning slice where per-call value justifies flagship prices. Neither side is losing; they are sorting by economic gravity, and the sort accelerates every quarter as open quality rises. The strategic question is not which wins but where your workload sits — and most teams have never measured their own split.

That matches my per-task cost findings: token price misleads, task placement decides. The gateway data is the industry's placement receipt.

The open trio: Moonshot, DeepSeek, Z.ai

Don't do this: reading the flip as closed-model decline. Closed inference spend stays higher — flagships earn premium rates on reasoning-heavy work. The flip says commodity intelligence went open, which is precisely the test-time routing thesis playing out at market scale: cheap tiers absorb volume while flagships handle the routed-hard tail, and the 78.4% is what that thesis looks like in aggregate.

GLM's presence in the trio connects directly to my value measurements — GLM-4.6's 72.4% BFCL at the lowest top-ten cost index predicted exactly this placement. Benchmarks anticipated the routing; gateways confirm it.

The pattern: audit your own gateway mix

flowchart TD
    LOG[Gateway logs: tokens by model] --> SPLIT[Split commodity vs reasoning]
    SPLIT --> OPEN[Commodity to open weights]
    SPLIT --> CLOSED[Hard tail to flagships]
    OPEN --> TRACK[Track share + cost weekly]
    TRACK --> REBAL{Drift detected?}
    REBAL -->|yes| MOVE[Re-route, update evals]

Pull thirty days of gateway logs, classify queries by difficulty tier, and price both placements. My audit template runs in an afternoon and has never once recommended the mix the team assumed — open share always deserves to be higher than instinct allows.

Step 1: Measure your open-ready share

config.py

from pydantic import BaseModel

class MixConfig(BaseModel):
    open_models: list[str] = ["moonshot", "deepseek", "glm"]
    flagship_models: list[str] = ["opus", "sonnet"]
    review_days: int = 30
    drift_threshold: float = 0.10
    eval_sample: int = 500

CONFIG = MixConfig()

Classify with the difficulty router first — my test-time routing tiers map directly: easy and contested-stable queries are open candidates, routed-hard stays flagship. The terminal-bench harness scores both placements on your sampled tasks before anything moves.

Step 2: Migrate volume in slices

migrate.py

async def migrate_slice(tier: str, pct: float) -> dict:
    candidates = await sample_tier(tier, n=CONFIG.eval_sample)
    try:
        scores = await eval_both(candidates, open_first=True)
    except EvalInfraError as e:
        logger.warning("eval down, holding mix", extra={"err": str(e)})
        return {"moved": False}
    if scores.open_delta >= -0.01:
        await router.set_share(tier, "open", pct)
        return {"moved": True, "delta": scores.open_delta}
    return {"moved": False, "delta": scores.open_delta}

Move in ten-point slices with eval gates between them — quality parity within a point unlocks the next slice, and any slice that degrades rolls back automatically before the next review. Slice cadence runs weekly: sample Monday, eval Tuesday, migrate Wednesday, monitor through the weekend. Five slices took my fleet five weeks, each Wednesday migration followed by a weekend of monitoring before the next slice unlocked. My fleet's open share climbed from 41% to 76% across five slices with zero quality regressions and a 58% inference bill reduction.

requirements.txt

httpx==0.28.1
pydantic==2.8.0
structlog==24.4.0
python-dotenv==1.0.1
numpy==2.1.0

Pydantic v2.8 needs extra="allow" on gateway-log schemas or nested usage payloads fail validation. I lost an afternoon to that exact error before pinning it.

Step 3: Watch the drift, not the launch

Gateway mixes drift as models ship — a new open release can shift your optimal mix ten points overnight. Weekly share reviews with the drift threshold paging on moves over 10% keep placement current. The review reads three numbers — open share, quality delta, bill delta — and takes one of three actions: hold, advance a slice, or roll back. Fifteen minutes, same agenda, every Monday. Launches are events; drift is the process. My review caught the GLM placement opportunity three weeks before the team would have noticed organically.

The assumption war story: 41% felt right

My team estimated our open share at 70% before the first audit. Measured: 41%. The gap was flagship-default routing on legacy tiers nobody had re-examined since onboarding — two config lines pinning premium models to commodity traffic. Five slices later we sit at 76% with quality flat. Instinct underestimates open readiness by roughly half; only the logs tell the truth. The two legacy config lines had survived three model generations unquestioned — routing debt accrues exactly like tech debt, silently, until someone audits.

When NOT to chase the flip

Let's be clear. Regulated workloads with approved-model lists cannot chase volume shares — compliance pins placement, not economics. Sub-second latency paths stay on whatever serves fastest regardless of weight openness. And tiny volumes save tens of dollars while risking quality attention better spent elsewhere.

Skip it for pinned, hot, or tiny paths. Chase it where volume concentrates, evals permit, and the bill shows flagship prices on commodity tokens.

The gateway majority flipped to open weights at 78.4% because the economics finally beat the inertia. Audit your mix, migrate in slices, and let the logs — not the launches — set your routing. The next gateway report will show a higher number; the only question is whether your share moves with it or your bill funds someone else open-weight migration.

By Deepak Bagada, Founder & Editor-in-Chief at Daily AI World.