400, 12,365 or 274 dollars: what a month of coding agent costs, and when your own DeepInfer pays off

One of our developers paid 400 dollars for his coding agent last month. The same work at Claude's API list price comes to 12,365 dollars. On DeepSeek's API it would have been 274.

All three numbers come from his own machine. We took his Claude Code logs from 21 September to 20 October and counted every call the agent made to the model: 129,407 calls and 26.2 billion tokens (a token is a piece of a word). Then we priced that same month three ways.

This month DeepSeek open-sourced DeepInfer, the engine it serves its own model with. That raises the question any CTO would ask: if my whole company worked like this, how many people would it take before running that engine on our own machines beats paying DeepSeek per token?

The answer depends less on the machines than it seems. A coding agent spends its day re-reading the same material, and whoever has a place to keep what was already read pays far less. That piece is exactly the one DeepInfer does not ship.

What he paid (two Claude Max 20x subscriptions)	400 USD
The same tokens at Claude API list price	12,365 USD
The same tokens on DeepSeek's API	274 USD
Tokens the agent reads for each one it writes	about 303
A rented 8-GPU server beats the API from	about 262 people like him, and only if it runs as fast as at DeepSeek
Your own 72-GPU rack beats the API from	about 465 people like him
At 1,000 people, cost per person per month	138 USD on your own rack, 274 on the API

A coding agent mostly reads

Every time the agent takes a step (opening a file, running a test, changing a line), it sends the model the whole conversation again: the instructions, the files it has opened and everything said so far. A typical call carried about 138,000 tokens, roughly a 400-page book. The model writes a few hundred tokens and it starts over. Over a month, that is about 190,000 books read.

Of the month's 26.2 billion tokens, 25,253 million were the same context read again. New material (files, tool results and the developer's own messages) was 822 million. What the model actually wrote, the code and the answers, was 86 million. For every token written, the agent read about 303.

Providers know this and keep recent context around so re-reading is cheap. Imagine a shelf next to the model: what it has already read stays there, and next time it picks it up ready. On Claude, re-reading from the shelf costs a twentieth of reading something new, and 96.8% of what this agent read came from there. Without the shelf, the same month on Claude's API would have cost more than 100,000 dollars, about nine times as much.

Three bills for the same work

Against Claude's list price, the subscription is by far the cheapest, but it has a ceiling. A Max 20x plan is 200 dollars a month according to Claude's pricing page, with a usage limit in every five-hour window, and he pays for two. For one person it works. It is not a plan built for a whole company.

The list price is what those tokens cost through Claude's API, which is how a company usually pays once per-person plans stop being enough. It is 31 times what he paid, and almost none of it is for writing. Of the 10,348 dollars that went to Opus 5.5, the code and the answers cost about 1,600. About 4,500 went on re-reading the shelf and about 4,250 on putting new material on it the first time.

DeepSeek's API, with the same tokens and at its published prices, comes to 274 dollars, 45 times less than Claude's API. Nearly all of the gap is in re-reading: a million re-read tokens costs a third of a cent on DeepSeek off-peak and 20 cents on Claude Opus 5.5.

This is a price comparison and nothing more. DeepSeek-V4.1-Flash is not Opus, it splits text into tokens differently (we did not measure by how much), and we did not rerun the month on it. A different model may need more or fewer turns to finish the same task.

Is the cheap model any good at code?

On the test closest to this kind of work, yes. LiveBench is an independent leaderboard that changes its questions often so models cannot learn them. In its agentic coding category, where the model has to get a real coding task done step by step, DeepSeek-V4.1-Flash came first of 69 models when we looked on 10 October.

It is the same table we used when we ran this model on two graphics cards. On a broader score, the Intelligence Index from Artificial Analysis, which mixes many kinds of tests, Opus 5.5 is clearly ahead: 58 against 39 on 16 October. Flash codes very well for a fraction of the price, and Opus is stronger overall. Which one suits you depends on what your agents spend their day on.

How DeepSeek serves DeepSeek

DeepSeek explained how its service works in a long post on Zhihu, a Chinese question-and-answer site. It is easiest to picture as a building with a front door, two rooms and the shelf from before.

A request comes in through the front door, which turns it into tokens and sends it to a free machine. In the reading room, 8-GPU servers read only the new part of the prompt, because the rest is already on the shelf. In the writing room, 64 to 128 GPUs wired together as if they were one machine write the answer token by token and leave the conversation on the shelf for the next turn.

DeepSeek's shelf is about 100 petabytes of separate storage, and it keeps each conversation for 72 hours after it goes quiet. It works like the shared backline at a festival: the amps stay on stage and every band plugs into them. Any reading machine can pick up any conversation. On average 96% of each prompt comes off it, almost the same as our developer's 96.8% on Claude.

With that shelf, one reading GPU at DeepSeek's pace keeps up with about 150 developers like him, and one writing GPU with about 420. His prompts are longer than DeepSeek's average (138,000 tokens against 77,000), so the real load from someone like him is probably somewhat higher.

What DeepSeek opened is the engine for the two rooms, plus the piece that turns requests into tokens the way its API does. The project's own page says three things "required for a complete inference service" are missing: the shelf, the split between reading and writing machines (the engine already does most of the work for it) and the code that spreads the traffic. According to the Zhihu post, that code is tied to its internal infrastructure, though the post explains in detail how each part works. A company that wants this setup has a building job ahead. In our numbers, two full-time engineers.

The credit goes to DeepSeek's team, which wrote DeepInfer, published it under a licence that allows commercial use and wrote up its production design with real numbers. DeepInfer started on top of vLLM and borrows ideas from SGLang and TensorRT-LLM, so those teams are in here too. Ours is the other half: measuring one real heavy user and working out what those figures mean for a company.

The first step: renting a server

You do not have to buy anything to start. DeepInfer's examples run the model on one 8-GPU server, and that can be rented by the hour. RunPod lists the B200, the chip DeepInfer is written for, at 7.99 dollars per GPU per hour. Eight come to 46,662 dollars a month, power included.

At DeepSeek's production speed, that server holds about 293 people like our developer, with room for the busiest hour. Add the two engineers and it beats the API from about 262. At 293 people it costs 245 dollars per person against 274, 11% less. That is a thin margin for everything that has to be built.

With 4 GPUs the model still fits with room to work (it weighs about 510 GB, and on 2 B200 it does not even load). They cost 23,331 dollars a month and hold about 146 people. Counting only the rent, they beat the API from about 85. With the engineers they never get there: it would take 176 people, and they do not fit.

Rented on RunPod (B200, on demand)	Per month	People it holds at DeepSeek's speed	Beats the API from (rent only)	Beats the API from (with two engineers)
4 GPUs	23,331 USD	146	85	never
8 GPUs	46,662 USD	293	170	262

All of this hangs on two assumptions nobody has checked yet.

The first is the speed of each GPU. DeepSeek's figures come from writing rooms of 64 GPUs or more, where each one holds a small slice of the model and serves many people at once. In an 8-GPU server each GPU carries more of the model and has less memory left for people, so it will be slower. If each rented GPU does not reach 58% of what one does in DeepSeek's production, renting does not beat the API at any number of people.

The second is the shelf. Without it every re-read is a full read again, and an 8-GPU server holds about 15 people like him instead of 293.

Our own one-GPU engine, deepseek-one-gpu, does not fit this profile either. It keeps about 70,000 tokens per person when it serves several at once, and 84% of this developer's calls were bigger than that. It is built for small teams and lighter use.

The big step: your own rack

The biggest setup DeepSeek publishes full numbers for is a writing room of 64 GPUs. The closest thing you can buy is an NVIDIA rack with 72 GPUs (a cabinet with the GPUs wired together as one machine), and we priced it at about 3.5 million dollars. That is our assumption: we found no published price we could check.

Your own rack beats DeepSeek's API from about 465 people who use agents like him. Counting only the hardware and the electricity, from 337.

The rack, written off over four years, is about 73,000 dollars a month. Electricity adds about 19,000 and the two engineers 25,000. That is about 117,000 dollars a month before the first user. From there each extra person costs about 26 dollars a month, which is why the gap with the API grows fast: at 1,000 people it is 138,000 dollars a month against 274,000, half. The rack price is what moves the result most: at 3 million the crossing drops to about 390 people, at 4 million it rises to about 507.

With this traffic, most of the rack waits. At 465 people, about three of the 64 writing GPUs are working, and those 64 are most of the price. What fills up is the reading side: the rack's 8 reading GPUs cover about 397 people, so you add another 8.

Everything is sized for the busiest hour, which for this developer reads three times as much new material as his average hour. A team that works the same hours peaks together.

Some costs are not in these numbers, and they all push the crossing up. The biggest is the shelf itself: for 465 people like him it would take, roughly, 300 terabytes of fast storage and the machines around it. Also left out are a datacenter able to liquid-cool a 135 kW rack, the network, spares and support. Read 465 as a floor, and keep in mind that it means 465 people at 26 billion tokens a month each. With people who use agents half as much, you need roughly twice as many.

Why the API can be this cheap

A 72-GPU rack serving DeepSeek's API brings in about 2 million dollars a month at off-peak prices, going by DeepSeek's own figure of about 38 dollars per GPU per hour. Owning it costs about 92,000 a month in hardware and power in our model. That gap is not profit: it leaves out storage, network, staff and training the model, and it assumes a rack kept full. But it explains the price. For DeepSeek, the minimum size (a rack, a shelf and a team) is already paid for. For every other company it is the barrier to entry.

What to do at your team's size

With users like this developer, and with DeepSeek's production figures as the ceiling:

People using agents this hard	Cheapest option
Fewer than about 260	DeepSeek's API
About 260 to 290	One rented 8-GPU server, by 11% and only if it runs as fast as at DeepSeek
About 430 to 590	Two rented servers, below both the API and the rack
More than about 590	Your own rack

Between about 290 and 430 people the API wins again, because you need a second server that is not yet full. If your team uses agents half as much as he does, double every figure.

The number that is missing

This whole article depends on a number that does not exist yet: how fast DeepInfer runs on an 8-GPU server compared with DeepSeek's 64. The project page has two charts, reading measured on 4 GPUs and writing on 64, and the one that would be needed is not there.

You can get it by renting that server for a few hours and running the benchmark that ships with DeepInfer, for about 200 to 270 dollars. If it comes out above 58%, renting starts to make sense. If it comes out below, DeepSeek's API wins at any number of people. We have not done it yet.

For engineers

Every figure, formula and assumption behind the narrative.

Data and tokens

• Data. One developer's Claude Code transcripts (~/.claude/projects/**/*.jsonl), window 2026-09-21 00:00 UTC to 2026-10-20 11:08 UTC, duplicates removed by (message id, request id). 129,407 calls. Models: mostly Opus 5.5, plus Opus 4.8, Sonnet 5.5 and Opus 5 (73 calls to local or synthetic models are counted in tokens but not priced).
• Counting output. Claude Code writes several transcript lines per call while it streams. The first line carries a partial output_tokens count (its stop_reason is still null). Take usage from the final line of each (message id, request id). Our first pass used the first line and undercounted output by 2.4x (36.4M instead of 86.0M). Every figure here uses the final line. If you rerun this on your own logs, check this first.
• Tokens. Cache reads 25,253M. Cache writes 822M (612M with 5-minute TTL, 209M with 1-hour TTL). Uncached input 0.3M. Output 86.0M. Total 26,161M. Cache reads are 96.8% of input tokens (the figure in the second image) and 96.5% of all tokens. About 303 tokens read per token written. Context per call: median 138K, mean 201K, p90 438K. 26,161M / 138K = about 190,000 typical contexts. Busiest day 2026-10-01 at 4,894M tokens, quietest 2026-10-18 at 63M. Busiest hour of the week (hour-of-week profile): 3.05x the average hour on new input tokens, 3.6x on all tokens.

Prices

• Claude (claude.com/pricing). Subscriptions paid: 2 x Max 20x at 200 USD = 400 USD. API list rates per MTok: Opus 5.5 input 4, output 20, cache read 0.20, cache write 5 (5 min) or 8 (1 h). Opus 5 and 4.8: 5 / 25 / 0.50 / 6.25 / 10. Sonnet 5.5: 2 / 10 / 0.10 / 2.5 / 4. Total 12,365 USD (Opus 5.5 10,348, Opus 4.8 1,930, Sonnet 5.5 63, Opus 5 24). Of Opus 5.5: cache reads 4,488, cache writes 4,249, output 1,609, uncached input 1.
• No-cache counterfactual on Claude. Cache reads billed at each model's input price instead of its cache-read price (writes and output unchanged): about 109,900 USD, 8.9x the 12,365.
• DeepSeek (deepseek-flash, DeepSeek-V4.1-Flash-1017, api-docs.deepseek.com/quick_start/pricing, 2026-10-20), USD per MTok off-peak / peak: cache hit 0.003 / 0.006, cache miss 0.15 / 0.30, output 0.60 / 1.20. Peak is 01:00-04:00 and 06:00-10:00 UTC, Monday to Friday, except Chinese public holidays. We treated 1-7 October (National Day week) as off-peak. Also counting 25 September (Mid-Autumn) changes the total by under a dollar. Cache writes billed as cache misses, cache reads as hits. All off-peak 251 USD, all peak 501 USD, with the developer's real hours 274 USD: 9.4% of his usage falls in peak hours, and 17.2% of the bill is paid at peak rates. Without the holiday rule it would be 289 USD.
• Ratios. Claude API = 31x the subscriptions and 45x DeepSeek API. Subscriptions = 1.46x DeepSeek API. Re-read price, Claude Opus 5.5 against DeepSeek off-peak: 0.20 / 0.003 = 67x.
• Coding quality. LiveBench agentic coding, max effort, full models served by their own providers, as recorded in our 2026-10-10 post: DeepSeek-V4.1-Flash 77.3 (first of 69), Claude Opus 5.5 71.7, Claude Fable 5.1 66.1, Claude Opus 5 65.2. Artificial Analysis Intelligence Index, 2026-10-16: Claude Opus 5.5 58, DeepSeek V4.1 Flash 39.

DeepInfer and DeepSeek's production

• DeepInfer (github.com/deepseek-ai/DeepInfer). Apache 2.0. This release provides offline inference. Originally built primarily on vLLM, inspired by SGLang and TensorRT-LLM. Supports DeepSeek-V4.1-Flash only, on NVIDIA SM100 GPUs and Huawei Ascend 950 NPUs. Kernels FlashMLA, DeepGEMM, DeepEP, TileKernels, DeepSelect, TileLang. Attention DP / balanced CP, MoE EP + EPLB, DSpark speculative decoding (DEEPINFER_ENABLE_MTP_VARLEN=1, DEEPINFER_USE_NEXTN_DECODE default 5), SWA bounded replay (DEEPINFER_YOCO_PREFILL_TRUNCATION_MODE=compact, DEEPINFER_YOCO_PREFILL_KEEP_TOKENS=140), async scheduling on by default, batch-invariant inference (DEEPINFER_BATCH_INVARIANT=1, NVIDIA only). Build with export DEEPINFER_ACCELERATOR=nvidia; ./build.sh, run python examples/offline_inference.py. examples/README.md runs one 8-GPU node with --ep 8, --ep 2 --dp 8 or --ep 2 --cp 8, and benchmarks with examples/sweep/run_sweep.sh. Not included: KV cache system, VE/prefill/decode disaggregation, load balancing across DP replicas, and no documented HTTP server. DeepSeek also released deepseek-recipe (API protocol to token encode/decode, Rust with Python bindings).
• Checkpoint. deepseek-ai/DeepSeek-V4.1-Flash-1017: 763B parameters, about 510 GB (mostly 4-bit packed experts and FP8).
• README benchmark. 4 SM100 GPUs for prefill and 64 for decode, each in one scale-up domain. Prefill chart on the 4 prefill GPUs (EP4DP4, context 131,072): about 60K tok/s/GPU at a 4,096-token batch up to about 89.5K at 65,536. Decode chart on the 64 decode GPUs (EP64DP64, nextn=3, 75% acceptance): about 26.3K tok/s/GPU at about 103 tok/s/user, down to about 2.6K at about 325.
• DeepSeek production (Zhihu post, table with redundancy for traffic swings; the hardware behind these rates is not stated). Prefill 60K tok/s/GPU uncached, 1.5M with cache hits, 96% average cache hit, 77K average input, TTFT 400 ms average and 1,000 ms P99. Decode 14K tok/s/GPU, 230 tok/s per user (300 for code). P:D close to 1:1. 155 trillion tokens a day on one cluster. 38 USD per GPU-hour revenue at off-peak prices. Prefill on 8-GPU machines (EP2-8), decode on 64-128 GPU supernodes (EP64-128). KV cache on a separate 3FS cluster, about 100 PiB SSD, 128-token pages, TTL 3 days for agent traffic and 7 for chat, peak read 10 TiB/s. Any prefill machine can hit any prefix.
• Per-user load (30-day average over 2,592,000 s): 33.2 tok/s written, 317 tok/s new input, 9,743 tok/s cached input, 10,060 tok/s all input. GPU share at DeepSeek's production rates: prefill 10,060 / 1.5M = 0.0067 GPU (about 150 users per GPU), decode 33.2 / 14K = 0.0024 GPU (about 420 users per GPU). With 3x headroom for the busiest hour: 0.0273 GPU per user.
• No cache. Prefill per user 10,060 / 60K = 0.168 GPU, 25x more.

Rented servers

• Prices (runpod.io/pricing, 2026-10-20, on demand, no reserved price published). B200 7.99 USD/GPU-hour Secure Cloud, 5.98 Community; B300 8.99 / 6.94. 8 x 7.99 x 730 h = 46,662 USD a month, 4 GPUs 23,331, power included. 2 B200 (about 360 GB) cannot load the checkpoint; 4 (about 720 GB) leave about 200 GB for KV cache.
• Capacity. 8 GPUs / 0.0273 = 293 users, 4 GPUs 146, at DeepSeek's rates (220 and 110 at 75%, 147 and 73 at 50%). Without a cache, 8 GPUs hold 8 / ((0.168 + 0.0024) x 3) = about 15 users.
• Break-even vs 274 USD. 8 GPUs: 46,662 / 274 = 170 users rent only, (46,662 + 25,000) / 274 = 262 with engineers. 4 GPUs: 85 rent only; with engineers it would take 176 and only 146 fit, so there is no break-even. Community price, 8 GPUs: 127 and 219.
• Speed threshold. Rental cost per user at full capacity 46,662 / 293 = 159 USD, so per-GPU speed must reach 159 / 274 = 58% of DeepSeek's production rates for renting to beat the API at any size, before engineers (43% at the Community price).
• Several nodes (Secure, 100%, engineers included): 1 node 71,662 USD up to 293 users; 2 nodes 118,324 up to 586 (beats the API from 432 and the own rack, 127,374, across that whole range); 3 nodes 164,986; 4 nodes 211,648 at 1,000 users, against 137,614 for the rack and 274,000 for the API.
• Proposed test. About 2 h on 4 GPUs to install and download the weights, plus 2 to 3 h on 8 for run_sweep.sh prefill and decode sweeps at 128K context: roughly 200 to 270 USD. Not run.
• deepseek-one-gpu. DeepSeek-V4.1-Flash Q2_K on one 96 GB RTX PRO 6000 plus host RAM. 8 batch slots of 69,632 positions, up to 262,144 for a request alone. 84.1% of the developer's calls exceed 69,632, 23.5% exceed 262,144. A multi-GPU server was not tested.

Your own rack

• Hardware. One GB300 NVL72: 72 Blackwell Ultra GPUs and 36 Grace CPUs in one NVLink domain, 288 GB HBM3e per GPU. Split 64 decode + 8 prefill. Price 3.5M USD, our assumption (range 3-4M). Together AI and Clusterbid give no rack price. The GB200 NVL72 (compute capability 10.0, SM100, the target DeepInfer names) is the same 72-GPU NVLink rack. We did not model it separately, and its price is unchecked too. Extra prefill GPUs at the rack's per-GPU cost, 48.6K USD each, added in boxes of 8.
• Monthly cost. Write-off 3.5M / 48 months = 72,917 USD. Power 135 kW x PUE 1.3 x 730 h x 0.15 USD/kWh = 19,217 USD. Two engineers 25,000 USD (150K USD a year loaded, each). Base 117,134 USD. Hardware and power alone 92,134 USD. Each extra prefill GPU 1,280 USD a month (48.6K / 48 + 267 power). Marginal cost per user 1,280 x 0.0067 x 3 = about 26 USD.
• Headroom. 3x average load on prefill. The rack's 8 prefill GPUs serve about 397 users at 3x (about 1,190 at 1x). At 465 users: about 9.4 prefill GPUs and about 3.3 decode GPUs busy.
• Break-even (first user count where own cost is at or below 274 USD x users, prefill added in boxes of 8). Hardware + power: 92,134 / 274 = 337 users. With engineers: 117,134 / 274 = 428 is past the 397 the rack's own prefill covers, so one box of 8 is added: 127,371 / 274 = about 465. Rack at 3M: 299 and 390. Rack at 4M: 375 and 507. Break-even headcount scales roughly with 1 / usage per person.

Users	DeepSeek API (USD/month)	Your own rack (USD/month)	Your own rack per user
100	27,416	117,134	1,171
200	54,832	117,134	586
300	82,248	117,134	390
400	109,664	127,371	318
500	137,080	127,371	255
750	205,620	127,371	170
1,000	274,160	137,608	138
2,000	548,320	168,319	84
5,000	1,370,800	239,979	48

• Revenue check. Off-peak, one prefill GPU earns about 47.95 USD/h at DeepSeek's 96% hit mix and one decode GPU 30.24 USD/h, consistent with DeepSeek's 38. 72 GPUs x 38 USD x 730 h = about 2.0M USD a month. A rack balanced for this traffic (if decode ran on fewer GPUs) would hold about 7,900 users like this one, 7,900 x 251 USD (all off-peak) = about 2.0M USD a month.
• Shelf size, rough. 465 users x 872M tokens a day = 405B tokens a day, 0.26% of DeepSeek's 155T. The same share of about 100 PiB is roughly 300 TB. Scaling by tokens is crude. Not priced.

Limits

• The rack price is our assumption, not a quote, and no source we could open gives one. Rack power estimates also vary (about 120 to 140 kW across sources).
• The storage for the shelf is not in the cost model. Neither are datacenter space or colocation for a 135 kW liquid-cooled rack, networking, spares and support. All of them raise the break-even.
• DeepInfer's README names SM100 GPUs, and CUDA lists Blackwell Ultra (GB300, B300) as a separate compute capability (sm_103). Running DeepInfer on a GB300 at DeepSeek's production rates is our assumption, and DeepSeek does not say which hardware produced those rates.
• DeepSeek has not published DeepInfer numbers with a smaller writing room. The rack figures assume a writing room of 64 GPUs. The rented 4- and 8-GPU figures assume DeepSeek's per-GPU rates, or the fraction of them shown, and a working cache that DeepInfer does not ship. We have not measured either.
• The user model is one person, and a heavy one. A company has lighter users, other hours and other habits. His prompts are longer than DeepSeek's average (77K), so his reading load per token is likely higher than the production rates suggest.
• Claude and DeepSeek split text into tokens differently, by an amount we did not measure, so the DeepSeek repricing is approximate. The comparison is about price only. DeepSeek-V4.1-Flash is a different model from Opus 5.5, and the same work on it may take a different number of turns and tokens.
• The subscription is a flat fee with usage limits for individuals. It is not a company plan.
• DeepSeek's production rates come from its own service, with its own shelf, balancers and traffic mix. A first build will likely run below them.
• Privacy, control and model choice are left out of the cost comparison on purpose.