Revolut's 90% Has a Router

Revolut says it cut AI coding inference costs about 90% by making self-hosted GLM-5.3 the default, with a router sending vision work to other models. We modeled the same move for a team without 56 B200 GPUs. A hosted open-weight API halves a 200-engineer Sonnet 5.5 bill with no hardware, self-hosting only wins at very high volume with busy GPUs, and the share of tokens a router escalates to a frontier model sets the ceiling on the saving. Includes a Python cost model, three charts, and a five-step playbook.

Published 2026-11-05 by Dor Amir on the Nadir blog.

Filed under Routing & Cascades.

TL;DR.

Revolut says it cut AI coding inference costs by about 90% in under a year, for about 2,000 engineers, by making a self-hosted open-weight model (Z.ai's GLM-5.3, on 56 Nvidia B200 GPUs) the default. The headline reads like a hardware story. It is mostly a default-model story, and it has a router in it: GLM handles text only, so vision work goes to Gemini or GPT Luna.

We modeled what the same move costs a team that does not have 56 B200s. Three findings:

  1. The model choice does most of the work. In our model, moving a 200-engineer team from Sonnet 5.5 to a hosted open-weight API cuts the monthly bill from about $31,000 to about $15,000. No GPUs needed.
  2. Self-hosting pays only at Revolut-like volume, with busy GPUs. One 8-GPU node beats Sonnet 5.5 from about 48B tokens a month. It beats a hosted open-weight API only from roughly 160B to 300B tokens a month if the nodes stay 85% busy, and almost never at 60%.
  3. The router sets the ceiling. Sending 15% of tokens to a frontier model keeps the bill 44% below all-Sonnet. Escalate more than about a third of tokens to Opus and you pay more than running everything on Sonnet.

The Revolut figures are the company's own, as reported in the press. Every other number here comes from our illustrative cost model. GPU rental and open-weight API rates are assumptions, and nothing comes from Nadir customer data.

What Revolut reported.

David Abitbol, who leads operations and infrastructure at Revolut, presented the numbers at the AI Engineer conference in New York in October 2026. The Register covered the talk on November 3, and several outlets followed. Here is what was reported, and nothing more:

Reported factValue
Engineers using AI coding toolsabout 2,000
Inference cost reductionabout 90%, in under a year
Blended costabout $0.30 per million tokens
BeforeGemini, then Claude Code, under hard budgets. Staff spending "$1,000 a month, $10,000 a month with not so much ROI"
ModelGLM-5.1 from April 2026, now GLM-5.3
Hardware56 Nvidia B200 GPUs, on US infrastructure
Throughputabove 7 requests per second after tuning, time to first token about 1.6 seconds
RoutingGLM is text only. A router sends vision work to Gemini or GPT Luna
Reported gains60% better coding time, 70% better lead time (metrics not defined in coverage)

Two quotes matter more than the 90%. The biggest gains came from handing debugging and ticket admin to the models, because "you no longer have to save your tokens." And tuning and quantization mattered more than adding GPUs.

What the coverage does not give: the baseline spend, GPU utilization, staff cost, or the share of traffic that goes to the vision models. Resultsense rightly notes that cloud, staff and observability costs sit outside the $0.30 figure. Treat the 90% as an inference-line number, not total cost of ownership.

Three things inside the 90%.

1. A cheaper default model. Most of the drop is the price gap between a frontier coding model and an open-weight one. That gap exists whether you host the weights or rent them by the token. We covered how fast open weights took over token volume in The 71/23 Split.

2. Utilization. 56 GPUs are a fixed cost. They are cheap per token only when 2,000 engineers keep them busy. This is the utilization tax in its best case.

3. A router. "GLM handles text, a router sends vision elsewhere" is a capability route. It is the same pattern as Route Like a Bank: one default for the bulk of the work, and a named exit for requests the default cannot serve.

The first and third need no hardware. The second is the one most teams cannot copy.

Method.

We priced coding-agent traffic four ways. The Python is at the end, and every input is a named constant you can change.

AssumptionValue
Traffic shape95% of billed tokens are input, 5% output
Cache80% of input tokens read from cache
Opus 5.5$4 in, $20 out, cache reads at 0.1x
Sonnet 5.5$2 in, $10 out, cache reads at 0.1x
Hosted open-weight coding modelassumed $1.00 in, $3.20 out, cache reads at 0.2x
B200 rentalassumed $5.00 per GPU-hour, all in
Served throughputassumed 5,000 blended tokens per GPU-second at full load
Node8 GPUs, always on
Ops staffassumed $20,000 a month for the first node, $2,000 per extra node

That gives blended rates of $2.06 per million tokens on Opus 5.5, $1.03 on Sonnet 5.5, and $0.50 on the hosted open-weight model. We picked the throughput so that a busy cluster lands close to Revolut's reported $0.30, then checked the result. At our rates, 56 GPUs cost about $204,000 a month, and $0.30 per million would mean about 680B tokens a month. That is roughly 11M tokens per engineer per day, plausible for agents that re-read cached context on every turn. It is our estimate, not a reported figure.

Results.

1. Self-hosting wins only when the GPUs stay busy.

Log-log chart of blended dollars per million tokens against monthly token volume. Flat lines for Opus 5.5 at $2.06, Sonnet 5.5 at $1.03, a routed 85/15 mix at $0.58 and a hosted open-weight API at $0.50. Two saw-tooth self-hosting curves fall with volume. The 85% busy curve drops under the open-weight line between about 160B and 300B tokens a month. A dot marks Revolut's reported $0.30.
Log-log chart of blended dollars per million tokens against monthly token volume. Flat lines for Opus 5.5 at $2.06, Sonnet 5.5 at $1.03, a routed 85/15 mix at $0.58 and a hosted open-weight API at $0.50. Two saw-tooth self-hosting curves fall with volume. The 85% busy curve drops under the open-weight line between about 160B and 300B tokens a month. A dot marks Revolut's reported $0.30.

The self-hosted curve is a saw. Each new node is a step up in fixed cost, and the per-token price falls until the node fills. Where it crosses the API lines:

Self-hosting beatsFrom aboutCondition
Opus 5.5 API24B tokens a monthone node
Sonnet 5.5 API48B tokens a monthone node, nearly full
Hosted open-weight API160B to 300B tokens a monthnodes 85% busy
Hosted open-weight APInot in rangenodes 60% busy

At 680B tokens a month and 85% busy, our model needs 64 GPUs and lands at $0.39 per million with ops included, in the same range as Revolut's figure. At 60% busy it needs 88 GPUs and costs $0.53, worse than renting the same open weights by the token.

2. A 200-engineer team does not need the GPUs.

Horizontal bars of the monthly bill for 200 engineers at 30B tokens a month: Opus 5.5 API $61,920, one self-hosted 8x B200 node $49,200, Sonnet 5.5 API $30,960, routed 85/15 open weights and Sonnet $17,445, hosted open-weight API $15,060.
Horizontal bars of the monthly bill for 200 engineers at 30B tokens a month: Opus 5.5 API $61,920, one self-hosted 8x B200 node $49,200, Sonnet 5.5 API $30,960, routed 85/15 open weights and Sonnet $17,445, hosted open-weight API $15,060.
Strategy, 30B tokens a monthMonthly billvs Sonnet 5.5
Opus 5.5 API$61,920+100%
Self-host, one 8x B200 node$49,200+59%
Sonnet 5.5 API$30,960baseline
Routed: 85% open weights, 15% Sonnet 5.5$17,445-44%
Hosted open-weight API only$15,060-51%

At this scale one node is about 30B tokens of work on hardware that could serve about 63B at 60% busy. You pay for the empty half. Renting the same model class by the token gets the price drop without the idle capacity.

The open-weight-only bar is the cheapest and it is not the recommendation. It assumes the open model clears your quality bar on every request, including the multi-file refactor at 4 p.m. on release day. The routed bar is the one that keeps the hard turns on a frontier model.

3. The escalation share sets the ceiling.

Line chart of blended dollars per million tokens against the share of tokens escalated to a frontier model, from 0 to 50%. Escalating to Sonnet 5.5 rises from $0.50 to $0.77. Escalating to Opus 5.5 rises from $0.50 to $1.28 and crosses the all-Sonnet line at about 34%.
Line chart of blended dollars per million tokens against the share of tokens escalated to a frontier model, from 0 to 50%. Escalating to Sonnet 5.5 rises from $0.50 to $0.77. Escalating to Opus 5.5 rises from $0.50 to $1.28 and crosses the all-Sonnet line at about 34%.
Share of tokens escalatedTo Sonnet 5.5To Opus 5.5
5%$0.53 per M$0.58 per M
15%$0.58 per M$0.74 per M
25%$0.63 per M$0.89 per M
34%$0.68 per M$1.03 per M, equal to all-Sonnet

A router that escalates the right 10% to 15% of tokens keeps most of the saving. A router that escalates a third of tokens to Opus erases it. That is why the share is worth measuring before you pick a default, and why it should be a dial per workload, not a constant.

The real lesson: stop rationing.

Before the switch, Revolut ran commercial tools under hard budgets. That is what most companies are doing now. Uber spent its annual AI budget by April (Four Months of Budget) and, according to PYMNTS, now caps each AI coding tool at $1,500 per engineer per month. Caps hold the bill flat by holding the work back, which is the argument of Spend Caps Are Not Cost Cuts.

Revolut's quote turns that around. Once the default token was cheap, engineers handed the models debugging and ticket admin, the low-glamour work nobody spends a capped budget on. Cheap tokens did not just lower the bill. They unlocked the work that caps had been blocking. A routed default does the same thing without a GPU purchase order: the bulk of the turns run at the open-weight price, and the cap stops binding.

A five-step playbook if you do not have 56 B200s.

  1. Measure your token volume per engineer per day. Under about 50B tokens a month in total, the GPU question is premature. In our model you are firmly in rent territory.
  2. Pick an open-weight default by eval, not by leaderboard. Run your own coding tasks through a hosted open-weight model and a frontier model. The shadow testing guide covers how to do this on live traffic without risk.
  3. Name the exits. Vision, very long context, and multi-file planning are the usual ones. Revolut's exit was vision. Write down which requests the default cannot serve, and route those by rule.
  4. Measure the escalation share. Track what fraction of tokens goes to the frontier tier, per workload. If it climbs past 25% to 30%, the default is too weak for that workload, or the router is too nervous.
  5. Buy GPUs last. Self-host when volume is high and steady enough to keep nodes 85% busy, or when residency rules require your own hardware. Size for the baseline and rent the peak, as in Own the Base, Rent the Peak.

The model, in Python.

import math

INPUT_SHARE, OUTPUT_SHARE = 0.95, 0.05   # share of billed tokens
CACHE_HIT = 0.80                          # share of input read from cache

def blended(inp, out, cache_read_mult):
    """Blended $ per 1M tokens for coding-agent traffic."""
    input_rate = CACHE_HIT * inp * cache_read_mult + (1 - CACHE_HIT) * inp
    return INPUT_SHARE * input_rate + OUTPUT_SHARE * out

OPUS   = blended(4.00, 20.00, 0.10)   # Opus 5.5 list
SONNET = blended(2.00, 10.00, 0.10)   # Sonnet 5.5 list
OPEN   = blended(1.00, 3.20, 0.20)    # assumed hosted open-weight model

GPU_HOUR, GPUS_PER_NODE, TOK_PER_GPU_SEC = 5.00, 8, 5_000   # assumptions
OPS_BASE, OPS_PER_NODE, HOURS = 20_000, 2_000, 730

def node_capacity(util):
    return TOK_PER_GPU_SEC * GPUS_PER_NODE * 3600 * HOURS * util

def self_host_monthly(tokens, util):
    nodes = max(1, math.ceil(tokens / node_capacity(util)))
    gpu = nodes * GPUS_PER_NODE * GPU_HOUR * HOURS
    return gpu + OPS_BASE + OPS_PER_NODE * (nodes - 1), nodes

def routed(escalate_share, frontier=SONNET, default=OPEN):
    return (1 - escalate_share) * default + escalate_share * frontier

team = 30e9   # 200 engineers x 5M tokens a day x 30 days
print(f"Sonnet   ${team / 1e6 * SONNET:,.0f}")
print(f"Routed   ${team / 1e6 * routed(0.15):,.0f}")
print(f"SelfHost ${self_host_monthly(team, 0.6)[0]:,.0f}")

Replace OPEN with your provider's real rate and TOK_PER_GPU_SEC with a load test on your own prompts. Those two constants move every crossover in this post.

Where Nadir fits.

Steps 2 to 4 are what Nadir does at the gateway. Point your OpenAI compatible base URL at Nadir and send model="auto". Each request goes to the cheapest model you've configured that clears the quality floor you set per API key, so routine turns run at the open-weight price and the hard ones go up a tier.

A self-hosted model is just another tier. Serve open weights behind an OpenAI compatible endpoint with vLLM, and register it next to your hosted providers, with an API model behind it in the failover chain. Each key has its own allowlist, so a regulated workload can stay on the in-region model while an internal tool uses the full pool. Every response reports which model answered and what it cost, so the escalation share in step 4 is a dashboard number, not a project.

To find your own share before you change anything, run a week in Observe mode. It serves exactly the model you asked for and records what routing would have chosen. With your own provider keys, the provider bills you directly, and Nadir charges a flat $0.002 per request, with the first 50 requests a month free. Savings depend on your workload, and nothing in this post forecasts yours.

Start with a free key, or estimate your savings from your current model spend.

Conclusion.

Revolut did not find a cheaper vendor. It changed the default and kept a router for what the default cannot do. The GPUs made the last step from about $0.50 to about $0.30 per million tokens possible at 2,000 engineers. The first step, from frontier prices to open-weight prices, is open to any team with an eval and a gateway. Take that step first, measure the escalation share, and let the volume tell you when to buy hardware.


Revolut facts: [Resultsense, "Revolut says self-hosting a Chinese model cut AI coding costs by 90%," November 4, 2026](https://www.resultsense.com/news/2026-11-04-revolut-self-hosted-glm-ai-coding-costs/), citing The Register, November 3, 2026. [Crypto Briefing, "Revolut cuts AI coding costs by about 90% with self-hosted models," November 3, 2026](https://cryptobriefing.com/revolut-cuts-ai-coding-costs-self-hosted/). [Startup Fortune coverage of the same talk](https://startupfortune.com/revolut-says-self-hosted-open-ai-models-cut-its-coding-costs-90/). All figures are Revolut's own statements from a conference talk and are not audited. Coverage differs on early model naming. Uber's per-tool cap from [PYMNTS](https://www.pymnts.com/?p=3799852). Anthropic list prices from [Anthropic, Pricing](https://claude.com/pricing), retrieved November 5, 2026. The open-weight API rate, B200 rental rate, throughput, ops cost, traffic shape, team size and every monthly figure are our assumptions and are illustrative.

More on routing & cascades

Pages on this site

Machine-readable summaries of this site: llms.txt and llms-full.txt.