← Back to blog
Engineering#ai-infrastructure

What Revolut's 90% Coding-Cost Cut Does and Doesn't Tell Us

Revolut says its self-hosted GLM invoice on 56 NVIDIA B200 GPUs is a tenth of what it paid Anthropic and OpenAI for AI coding. What the 90% actually compares, what FP4, prefill/decode disaggregation, context caps and model routing contribute, and how to test the economics for your own team.

14 min readby the editors
What Revolut's 90% Coding-Cost Cut Does and Doesn't Tell Us cover illustration

Did Revolut cut the cost of AI coding by 90%? It cut its invoice by about that much. In a talk at AI Engineer NYC on 13 October 2026, David Abitbol, who leads AI operations at Revolut, said the company's self-hosted GLM invoice is one tenth of what it was spending on Anthropic and OpenAI. The setup is about 56 NVIDIA B200 GPUs serving roughly 2,000 engineers at a blended cost near $0.30 per million tokens. The Register's report on 3 November turned that into a headline. The result is real and worth studying, but it is a bill-to-bill comparison reported by the company. It is not an audited total cost of ownership, and it is not a per-token price comparison. This analysis explains what Revolut changed, what each technique does (FP4 quantization, splitting prefill from decode, capping context, routing to other models), which claims the sources support and where they disagree, and how to run the same economics test on your own workload.

Before you start

System requirements

Who it is for

AI engineers, infrastructure teams, CTOs and engineering leaders

Anyone deciding whether to keep paying per token for coding agents or to serve an open-weight model themselves. No prior inference-serving experience is assumed; each technique is explained before it is judged.

What you need first

One month of your own token usage

Input, output and cached tokens per user, plus the invoice. Without these you cannot compare anything to Revolut's numbers. Step 8 lists what to collect.

Scale in the case study

About 56 B200 GPUs for about 2,000 engineers

Equivalent in GPU count to seven eight-GPU DGX B200 systems. Revolut reports serving GLM-5.1 from about April 2026 and later GLM-5.3, text only, with vision requests going to other models.

Evidence level

Company-reported, observational

The figures come from a conference talk and a news report. Neither publishes the full hardware cost, the baseline token volumes, or a controlled quality comparison between GLM and the models it replaced.

Facts checked

6 November 2026

Against the AI Engineer NYC talk page and transcript, the AI Engineer talk write-up, The Register's report, the GLM-5.1 model card, NVIDIA's NVFP4 technical blog, and an independent cost analysis by senn-tech.

01

What problem was Revolut solving?

Per-token bills that grew with usage, and budgets that capped the usage the company actually wanted.

Revolut first brought AI into engineering with Gemini in January 2025 and later rolled out Claude Code at scale. In the talk, Abitbol describes engineers spending "a thousand a month, 10,000 a month with not so much ROI", and the company responded with strict budget limits.

That is the trap most teams with coding agents hit. An agent does not make one call per task. It reads files, plans, runs tools, reads the errors, and tries again, and each turn resends a large prompt of instructions, source code and history. Spend scales with how much agentic work engineers do, which is the thing you want more of.

Budgets control the bill but also cap adoption. Revolut's stated goal for self-hosting was to remove that tension: make the marginal request close to free so engineers can use AI for debugging, tickets and documentation without rationing tokens.

Tip
Before looking at any infrastructure, find out whether your problem is the total bill or the per-user caps you put in place to control it. They lead to different fixes.

02

What did Revolut actually deploy?

An open-weight GLM model from Z.ai on roughly 56 B200 GPUs, hosted outside China, as the default for coding.

Revolut started self-hosting GLM-5.1 around April 2026 and later moved to GLM-5.3. GLM models are published by Z.ai as open weights; the GLM-5.1 model card lists 754B parameters and an MIT license. The Register adds that 40B parameters are active per token, a mixture-of-experts design.

The Register reports roughly 380 GB of GPU memory just for GLM-5.1's weights at the deployed precision, plus 6 to 26 GB per user for context depending on precision. That memory math is why a model of this size needs a cluster rather than a server.

In the talk, Abitbol stresses that running downloaded weights on a provider in a country you already trust with your data is different from calling a China-hosted endpoint. He names the US, EU, UK and Israel as acceptable locations and says GPU providers retain no data by default.

Neither the talk nor The Register names the serving engine. The GLM-5.1 model card lists vLLM and SGLang as supported options, but that is not a statement about Revolut's stack.

Tip
Do not carry GLM-5.1 numbers over to GLM-5.3. The sources disagree on GLM-5.3's size (the transcript is garbled, the talk write-up says about 800B), so check its model card yourself.

03

What does the 90% actually compare?

Two invoices. Not two prices per token, and not two total costs of ownership.

In the talk the claim is: "our invoice is one-tenth of what we were spending on Anthropic and OpenAI." The AI Engineer write-up says it plainly: the 90% figure compares bills. The Register's version, that self-hosting cost "about a tenth" of Codex or Claude Code, reads like a per-token comparison, which the talk does not make.

The $0.30 per million tokens is a blended figure with cached tokens counted as free. It is a unit cost, not a price you can buy: total spend divided by tokens served. If the same GPUs serve half as many tokens next month, the unit cost doubles.

senn-tech's independent analysis makes that concrete. Assuming a rental of $10,000 per B200 per month (its assumption, not a disclosed number), 56 GPUs reach $0.30 per million only at about 1.87 trillion tokens a month, roughly 930 million tokens per engineer.

The total cost of ownership is not disclosed. Platform engineers, on-call, evaluation, security reviews, networking and the effort of migrating harnesses are not on a GPU invoice. A bill can fall 90% while the all-in cost falls much less.

Three different numbers get called the cost. Unit cost: about 0.30 dollars per million tokens, blended, cached tokens free; total cost divided by tokens served, so it moves with utilization. Invoice: about one tenth of the prior Anthropic and OpenAI invoice; this is the reported 90 percent. Total cost of ownership: not disclosed. A hypothetical month: a 100,000 dollar API bill becomes a 10,000 dollar GPU invoice, a 90 percent cut, but adding 25,000 dollars of platform engineers and 5,000 dollars of tooling gives 40,000 dollars, a 60 percent cut.
The hypothetical month uses round numbers, not Revolut's. It shows why an invoice cut and a total cut can differ.Open full size →
Unit cost depends on utilization (Python sketch, illustrative inputs)
def cost_per_million(monthly_infra_usd, tokens_per_month):
    return monthly_infra_usd / (tokens_per_month / 1_000_000)

def tokens_needed(monthly_infra_usd, target_per_million):
    return monthly_infra_usd / target_per_million * 1_000_000

fleet = 56 * 10_000   # senn-tech's assumed $10,000 per B200 per month

print(f"{tokens_needed(fleet, 0.30):.3g} tokens/month")         # 1.87e+12
print(f"{tokens_needed(fleet, 0.30) / 2_000:.3g} per engineer")  # 9.33e+08
print(cost_per_million(fleet, 0.5e12))                           # 1.12 at 0.5T tokens

Tip
When anyone quotes a percentage saving, ask three questions: compared with what bill, over what token volume, and which costs sit outside the invoice.

04

What does FP4 quantization change?

It shrinks the weights so more GPU memory is left for requests. It is not free, and the talk's description of it is muddled.

Quantization stores model numbers in fewer bits. BF16 uses 16 bits per value, FP8 uses 8, and FP4 uses 4. Fewer bits means less memory and less data moved per token, which is the bottleneck when generating text.

NVFP4 is NVIDIA's 4-bit format for Blackwell GPUs such as the B200. Each block of 16 values shares one FP8 (E4M3) scale, and each tensor has one FP32 scale, so it costs about 4.5 bits per value. NVIDIA reports roughly 1.8 times less memory than FP8 and, on DeepSeek-R1-0528, accuracy within about 1% of FP8.

For a 754B-parameter model, the arithmetic is about 1,508 GB in BF16, 754 GB in FP8 and about 424 GB in NVFP4. The Register's figure of roughly 380 GB for GLM-5.1's weights is consistent with a 4-bit deployment.

The memory saved is what pays. It goes to KV cache and batching, which means more concurrent engineers per GPU and a lower unit cost.

Treat the talk's numbers with care. Abitbol says going "from FP4 to FP8 is a 40% saving in GPU footprint for zero loss in precision". The direction is reversed (the saving comes from going FP8 to FP4), and NVIDIA's own results show small accuracy differences, not zero. The Register says NVFP4; the talk says FP4.

Weight memory for a 754 billion parameter model by number format. BF16 at 16 bits per value: about 1,508 gigabytes. FP8 at 8 bits: about 754 gigabytes. NVFP4 at about 4.5 bits per value including scales: about 424 gigabytes; The Register reports roughly 380 gigabytes as deployed. NVFP4 stores 16 four-bit values with one shared FP8 E4M3 scale, plus one FP32 scale per tensor. Arithmetic only, not a benchmark.
Arithmetic for weights only. Real checkpoints keep some layers at higher precision.Open full size →

Tip
Run your own coding evaluation before and after quantizing: real tickets, real repositories, pass rates and review outcomes. A general benchmark score will not tell you whether your refactors still compile.

05

What does separating prefill from decode do?

It stops long prompts from stalling everyone else's answers. Whether Revolut runs it is less clear than the headline suggests.

Every request has two stages. Prefill reads the whole prompt at once: instructions, files, history, tool output. It is compute-heavy and decides how long you wait for the first token. Decode then writes the answer one token at a time. It is limited by memory bandwidth and decides how fast the text streams.

On shared GPUs, a 200K-token prompt arriving mid-stream competes with requests that are already generating. Their output stutters while the big prefill runs. Coding agents send exactly those large prompts.

Disaggregation runs the two stages on separate pools of GPUs. Prefill workers compute the KV cache and hand it to decode workers, so each pool can be sized and scheduled for its own bottleneck. The cost is moving the KV cache between pools, which needs a fast interconnect.

On sourcing: The Register lists disaggregated prefill and decode among the changes Revolut made. In the talk transcript it appears in a list of techniques to look into, next to speculative decoding. Treat it as a reasonable technique for this workload, not a confirmed part of Revolut's 90%.

Disaggregated prefill and decode. A request with code, repository context and history goes to the prefill pool, which reads the whole prompt at once, is compute-bound and sets time to first token. The KV cache moves to the decode pool, which writes one token at a time, is memory-bandwidth-bound and sets tokens per second. The reply streams to the developer. The talk lists this as a technique to look into; The Register lists it as a change Revolut made.
Prefill sets how long you wait. Decode sets how fast it streams.Open full size →

Tip
Measure first. If time to first token is fine and only throughput suffers, disaggregation may add complexity without fixing your actual problem.

06

Why cap context at 256K when the model can do 1M?

Context costs KV-cache memory per session. A smaller cap leaves room for more engineers on the same GPUs.

The KV cache holds the attention keys and values for every token a session has seen, so the model does not recompute them for each new token. It lives in GPU memory, and it grows with context length.

Abitbol's line is the useful one: "even though you can serve one million token, 256 is really what you need." Planning every session for a million tokens when most coding work fits in far less leaves capacity unused and limits how many sessions fit in the remaining memory.

The talk also sets a cache-hit target above 90%. Coding agents resend the same system prompt and much of the same repository context on every turn, so prefix caching avoids recomputing it. It is also why cached tokens can be counted as nearly free in the blended $0.30.

Capping context has a safety side. Our analysis of Cloudflare's GLM-5.3 incident showed what happens when the KV-cache pool and the advertised context window disagree: requests from different customers ended up sharing cache pages. If you lower the cap, lower it everywhere the engine enforces it, and test isolation along with speed.

Context cap vs concurrent sessions (Python sketch, illustrative numbers, not GLM's)
# Measure these in your own engine. They vary with layers,
# attention type and KV-cache precision.
kv_bytes_per_token = 70_000   # per session, per token of context
free_hbm_gb = 600             # memory left for KV cache in one replica

def max_sessions(context_tokens):
    per_session_gb = kv_bytes_per_token * context_tokens / 1e9
    return int(free_hbm_gb // per_session_gb)

for ctx in (1_000_000, 256_000, 64_000):
    print(f"{ctx:>9,} tokens -> {max_sessions(ctx):>3} full-length sessions")
#  1,000,000 tokens ->   8 full-length sessions
#    256,000 tokens ->  33 full-length sessions
#     64,000 tokens -> 133 full-length sessions

Tip
Pull the real prompt-length distribution from your logs before choosing a cap. Pick the cap from the 99th percentile, not from the model card.

07

Why does Revolut still use Gemini and GPT?

GLM in this deployment is text only. Requests that need vision go to a model that has it.

Abitbol calls GLM "a text only model" and says image recognition goes to Gemini or another API model. The Register names Gemini or GPT. Screenshots of a broken UI, diagrams and visual diffs fall into that bucket.

This is model routing: the self-hosted model is the default for the bulk of the work, and a router sends requests that need other capabilities to a paid API. The cheap path carries the volume; the expensive path handles the exceptions.

Revolut's exact routing rules are not published. The config below is an illustration of the pattern, not their setup.

Capability-based model routing, illustrative. A coding agent sends requests to a router that checks for an image. Without an image, requests go to the default: self-hosted GLM on 56 B200 GPUs, text only, flat cost, for writing, debugging, refactoring, repository questions and docs. With an image, requests go to the exception: Gemini or an OpenAI model through an API, billed per token, for screenshots, UI bugs and diagrams. Revolut's exact rules are not published.
The default carries the volume. The paid API handles what the default cannot do.Open full size →
Capability-based routing (illustrative YAML)
default: glm-selfhosted            # flat infrastructure cost
routes:
  - when: { has_image: true }
    to: vision-api                  # Gemini or an OpenAI model, per token
  - when: { task: ["code", "debug", "refactor", "repo_qa", "docs"] }
    to: glm-selfhosted
fallback:
  when: { glm_ttft_seconds_gt: 5 }  # Abitbol: above 5 s, complaints start
  to: frontier-api
budget:
  frontier-api: { monthly_usd: 5000, alert_at: 0.8 }

Tip
Log the route each request takes and its cost. If the exception path grows past a small share of traffic, your default model is not covering the work.

08

How would you test this for your own team?

Measure your own workload, pilot on rented GPUs, and compare total cost at equal quality.

Collect a month of data first: invoices, input, output and cached tokens per user, request counts by hour, and prompt-length distribution. senn-tech concludes that teams under 100 developers cannot derive a break-even point from Revolut's numbers; your own volume decides it.

Pick an open-weight model and evaluate it on your real tasks before thinking about GPUs. Revolut's 60% and 70% productivity gains (see below) do not tell you whether GLM will work on your codebase.

Pilot on rented capacity with one team. Track time to first token, tokens per second, cache-hit rate and GPU utilization next to task success. Revolut's targets were under 3 seconds to first token and about 200 tokens per second interactive.

Tune before you scale: quantization, batching, context cap, caching, and only then serving topology. Revolut reports its biggest latency gain on a fixed GPU count.

Finish with a total-cost comparison at equal quality, including the people who will run it. If the self-hosted path is cheaper only at volumes you do not have, the API is the cheaper choice.

Pilot scorecard (illustrative YAML)
baseline_month:
  api_invoice_usd: 0
  tokens: { input: 0, output: 0, cached: 0 }
  active_engineers: 0
pilot:
  gpus: { type: B200, count: 8, monthly_usd: 0 }
  slo: { ttft_p95_s: 3, tokens_per_s: 200 }
  measured: { ttft_p95_s: 0, tokens_per_s: 0, cache_hit: 0, gpu_util: 0 }
  quality: { task_pass_rate_api: 0, task_pass_rate_selfhosted: 0 }
all_in_monthly_usd:
  gpus: 0
  platform_engineers: 0
  evals_security_oncall: 0
  residual_api_spend: 0   # vision and fallback routes

Tip
Fill every field with zeros first and replace them with measured numbers only. A scorecard with estimates in it will tell you what you hoped to hear.

What tuning did on the same GPUs

Tuning results Revolut reported on a fixed GPU fleet. Time to first token fell from 14.26 seconds during migration to 1.68 seconds in the stable setup, an 88 percent reduction, against a 3 second target. Requests per second rose 76 percent. Also reported: about 200 tokens per second interactive, 256 thousand tokens of context instead of 1 million, and a cache-hit target above 90 percent. The baseline window is not published, and the transcript's own requests per second figures, about 3 to over 7, imply more than 76 percent.
Slide figures from the talk. Useful as direction, not as a benchmark.Open full size →

The strongest engineering lesson in the case is that the biggest latency gain came without new hardware. The talk page reports time to first token falling from 14.26 seconds during migration to 1.68 seconds in the stable setup, with 76% more requests per second, while the GPU count stayed the same.

The numbers need a light touch. The baseline window is not published, and the transcript describes requests per second going from about 3 in April to over 7 in August, which is more than a 76% rise. Abitbol also notes that after 5 p.m., when load drops, engineers see around 800 tokens per second; above 5 seconds to first token, his Slack inbox "starts to blow up".

Where the sources disagree

ClaimWhat we found
Self-hosting costs a tenth of Codex or Claude Code (The Register).The talk compares invoices, not per-token prices. Use "invoice" when you quote it.
Revolut used NVFP4 and disaggregated prefill/decode (The Register).The talk says FP4, and lists PD disaggregation among techniques to look into, next to speculative decoding.
Lead time improved 70%.The transcript, talk page and The Register say 70%. The AI Engineer write-up says the slide shows 60%. Unresolved.
FP4 vs FP8 is a 40% footprint saving at zero precision loss (talk).Direction reversed in the transcript. NVIDIA reports about 1.8x less memory than FP8 and small, not zero, accuracy differences.
GLM-5.3 size.Transcript garbled; the write-up says about 800B. Do not reuse GLM-5.1's 754B and 40B active.
Claude Code arrived in early 2026 (The Register).The transcript's own timeline is ambiguous about the year. We do not date it.

Security moves in-house too

Self-hosting changes who is responsible for security, not whether security is needed. The talk's most practical point is about what the coding agent may do: enforce approval through the operations the agent can run, not through instructions in its prompt. Abitbol's example is to allow grep but not gradle, so reading code proceeds and running a build needs a human.

  • Command allowlists in the sandbox, with read-only tools open and build, deploy and network tools gated.
  • Secrets kept out of the agent's environment, and network egress restricted from the sandbox.
  • KV-cache and prefix-cache isolation tested between users and sessions, not just measured for hit rate.
  • Hosting location and data retention written into the provider contract, not assumed.
  • Audit logs of every tool call, and an owner for incidents in your inference stack.

What the case does not prove

Tempting conclusionWhat the evidence supports
Any company can cut AI costs 90%.Revolut reported a 90% invoice reduction for its own workload, at the scale of about 2,000 engineers.
Open-weight models match frontier models for coding.No controlled quality comparison on Revolut's tasks has been published.
GLM made engineers 60-70% faster.Observational trends that do not isolate the model change from other changes at the company.
More GPUs means better performance.The reported latency gain came from tuning on a fixed fleet.
4-bit quantization is lossless.It is close on published benchmarks. It must be checked on your own tasks.
GLM replaced GPT and Gemini.Revolut kept API models for vision.
Total cost fell 90%.Hardware, people and operating costs are not disclosed.

The trade-offs worth knowing

  • Utilization risk: an API bill shrinks when usage drops; a GPU fleet does not. The $0.30 holds only while the fleet stays busy.
  • People cost: someone has to run inference at 2 a.m. That line is invisible on a GPU invoice and real on a payroll.
  • Model churn: Revolut moved from GLM-5.1 to GLM-5.3 within months. Each upgrade repeats quantization, evaluation and tuning.
  • Capability gaps: a text-only default needs an API path for vision, and may need a frontier fallback for the hardest tasks.
  • Latency is a product feature: engineers notice the first token. Revolut treats anything over about 5 seconds as broken.
Personal verdict

Revolut's case is the most detailed public example so far of a large company moving its coding agents onto self-hosted open weights, and the engineering lessons hold up: tune before you buy, size context to the workload, cache aggressively, route by capability, and gate what the agent can run. The 90% needs its qualifier every time you repeat it. It is a reduction in Revolut's invoice, reported by Revolut, at a volume of about 2,000 engineers. It is not a price you can buy, and it is not an audited total cost. If your team is much smaller, start with the cheap part: measure your token mix and cache-hit rate, and test an open-weight model on your real tasks through a hosted provider. Rent GPUs only when your own numbers say the fleet will stay busy.

Frequently asked questions

Did Revolut cut its AI coding costs by 90%?+

It reports that its self-hosted GLM invoice is about one tenth of its previous Anthropic and OpenAI invoice. That is a comparison of bills reported by the company. The full total cost of ownership, including hardware terms, staff and operations, has not been published.

Is $0.30 per million tokens a price I can get?+

No. It is Revolut's blended unit cost: total spend divided by tokens served, with cached tokens counted as free. It depends on keeping 56 GPUs busy. senn-tech estimates it needs about 1.87 trillion tokens a month at an assumed $10,000 per B200 per month.

Which models did Revolut self-host?+

GLM-5.1 from about April 2026, then GLM-5.3, both open-weight models from Z.ai. The GLM-5.1 model card lists 754B parameters and an MIT license. Vision requests go to Gemini or an OpenAI model.

What is NVFP4?+

NVIDIA's 4-bit floating-point format for Blackwell GPUs. Each block of 16 values shares an FP8 scale, and each tensor has an FP32 scale, for about 4.5 bits per value. It cuts memory roughly 1.8 times versus FP8, with small accuracy differences that you should measure on your own tasks.

Did disaggregated prefill and decode produce the savings?+

The public sources do not show that. The Register lists it among Revolut's changes; the talk transcript lists it as a technique to look into. The documented gains come from a combination of quantization, context tuning and caching on the same GPU fleet.

Should a small team self-host a coding model?+

Usually not first. Self-hosting pays only when GPUs stay busy, which takes a large, steady token volume. A smaller team can test an open-weight model through a hosted provider, measure quality and token mix, and revisit self-hosting when its own numbers justify it.

Sources & further reading

Sources and further reading

More practical field notes from Agent Builders HQ are on the way.

Stay tuned →