With two agents per power user, one 4x B200 machine takes the Claude Code load of about 200 subscriptions for about 30% less

Can one machine do the Claude Code work of 200 subscriptions? We measured 100 agents. The 200 is modelled from those runs. One server with four NVIDIA B200 graphics cards in the inferencekey cloud ran DeepSeek V4.1 Flash on DeepInfer, the engine DeepSeek open-sourced in October. We added the piece the engine ships without, a cache. A hundred synthetic agents, sized like real Claude Code sessions, worked at once, each carrying almost half a million tokens of conversation. Half their answers started within about 2.5 seconds, and not one request failed. A simulator calibrated on those runs puts the machine at about 400 agents at once. If your power users run two agents each, that is the load of about 200 subscriptions, for about 30% less.

200 subscriptions assumes 2 agents at once per power user (400 agents, modelled). If every user were as intensive as our reference user, the simulator gives about 80.

A coding agent mostly re-reads, and the cache makes re-reading nearly free

Every time Claude Code takes a step (opening a file, running a test, editing a line), it sends the model the entire conversation again. In our tests that conversation was about 450,000 tokens, roughly a 1,300-page book. The model writes a few hundred tokens of answer, and on the next step the agent sends the whole book again, plus one new page.

In our last research post we measured one heavy developer for a month and found the same thing: 96.8% of what his agent read was material it had already read. Think of a shelf next to the model. What it read once stays on the shelf, and next time it picks it up ready instead of reading it again.

DeepInfer ships without that shelf. DeepSeek's own page for the project lists the cache as one of the pieces you have to build yourself. Without it, our machine read under half a book a second, every conversation from scratch. With the inferencekey cache, it read four books a second. The bill for coding agents is mostly a bill for re-reading, and whoever keeps the shelf sets the price.

Same machine, same model: the cache turns about 200 K tokens read per second into about 1.8 M.

Claude Code needs only a few environment variables, and finished a real task in 39 seconds

A few environment variables tell Claude Code where to send its requests, which key to use and which model to ask for. Point them at your inferencekey endpoint and it talks to DeepSeek V4.1 Flash instead of Anthropic, with the same commands and the same tools.

Environment variables point Claude Code at your endpoint. The inferencekey cache keeps every conversation in GPU memory and RAM.

The shelf has two levels. The fast one lives in the graphics cards' own memory and holds about 57 million tokens, roughly 120 conversations of our size. Behind it sits a second level in the server's ordinary memory, about ten times bigger at 617 million tokens, for conversations that have gone quiet for a moment.

On 24 October, Claude Code 2.1.310 set up this way finished a small real task in 39 seconds. The task was to implement a function called parse_duration so that a file of 15 tests passes. The agent made 14 tool calls (reading files, running the tests, editing the code) and all 15 tests passed.

Claude Code 2.1.310, unchanged, on our endpoint: a real task done in 39 s with 14 tool calls and 15 of 15 tests passing. One small task, not a benchmark.

The scene in the video above is the real app doing that task again, playing back the model answers recorded that day while the tools really run.

The credit is shared. DeepSeek's team trained DeepSeek V4.1 Flash, wrote DeepInfer and released it under the Apache 2.0 licence. NVIDIA's aiperf tool load-tested our simulator. Anthropic's Claude Code ran on top. Our part is the cache, the adapter that lets inferencekey run DeepInfer, the API that speaks Claude Code's language with your own keys, and the measurements.

100 agents at half a million tokens each: half the answers start in 2.5 seconds, zero errors

With 100 agents at once, each with about 450,000 tokens already on the shelf, half the answers started within 2.55 seconds and none failed. That is the size of a long Claude Code session late in the day. We ran it on 25 October, and over a one-minute window the machine took 237 agent turns. Each agent's answer streamed at about 135 tokens a second, a page in a few seconds.

100 agents, caches warm: 0 errors and answers starting in about 2.5 s. The slowest 5% wait behind new 450K conversations and miss the 15 s target.

Now the part that did not pass. Our bar is strict: 95% of turns must start answering within 15 seconds. Only 2 of our 8 test runs cleared it. All 8 had zero errors. In this run, 83% of the turns whose conversation was already on the shelf started within 15 seconds. The slowest 5% waited 37 seconds or more, so the run failed. Seven brand-new conversations arrived in that minute, each needing its full 450,000 tokens read from scratch. The waiting turns queued behind them, like a band waiting while the one before packs up all its gear. Giving priority to turns already on the shelf, or capping how many new conversations start at once, would likely help. We have not tested that.

Stress test from cold: 176 million tokens read from scratch in under 15 minutes, zero errors

With nothing on the shelf, the machine read conversations from scratch at a steady 200,000 tokens per second without a single error. On 24 October we fed it 399 new conversations of about 440,000 tokens each, 16 at a time, with an empty cache. That is harsher than any real morning, where sessions start small.

In 14.6 minutes, 397 of them were read in full and answering: 176 million tokens. Counted from when each one was let in, the first answer took about 14 seconds (median). Counted from the start of the test, half waited more than six minutes and the last nearly 15. The last two were still in line when our 15-minute test limit ran out. If a whole team arrived at once with giant conversations, the queue would be the problem, not errors.

Stress test with nothing cached: 397 conversations of 440K tokens, 176 M tokens read from scratch in under 15 minutes, 0 errors.

Day to day, about 400 agents fit, according to a simulator built on 7,879 real turns

Everything above is measured. This section is modelled, and the difference matters.

About 250 agents fit if 95% of answers must start within 15 seconds, about 400 if 30 seconds is fine. At 400, a typical answer takes about 21 seconds to start, and 1 in 20 waits about 30 seconds or more.

Modelled: a simulator calibrated on 7,879 real turns fits 250 agents if 95% of answers start within 15 s, 400 within 30 s.

Our measured tests were deliberately harsh: every agent paused only three seconds between steps. Real sessions are calmer, so we built a simulator of this machine. We calibrated it on every turn from both test campaigns until it reproduced what the real machine did, including its breaking point. Then we drove it with 30 days of Claude Code usage from our reference user: 140,300 model calls, with their real pauses.

The machine does not do more work at 400 than at 250. It answers about 450 model calls a minute either way. With more agents, each one simply waits longer and calls less often, every 52 seconds instead of every 34.

200 subscriptions if power users run two agents each, and below about 140 the machine costs more

The 200 in the title rests on one assumption: a power user runs two agents at once, all day. The simulator's 400 agents divided by two gives about 200 subscriptions.

The catch is speed. On Claude, our reference user's agents call the model every 27 seconds on average. At 400 agents on this machine, each one calls every 52 seconds. A task would take almost twice as long.

There is a stricter way to count. Our reference user is a very heavy user of ours. In an average peak hour he calls the model about every 11 seconds. At 450 calls a minute, the machine keeps about 80 people like him at full speed. The machine only costs less than Claude Max 20x subscriptions above about 140 subscriptions. At the stricter count of 80, it costs 27,900 USD a month against 16,000 in subscriptions, about 75% more.

Our reference user is not typical, though. Besides his own sessions he runs autonomous agents for workflows and business tasks, so an ordinary Claude Max user loads the machine less. Your own Claude Code logs can tell you where your team sits.

About 0.006 USD per million tokens, 80 times less than the Claude API

The other comparison is the API. Our reference user's real month of Claude Code, priced at Claude's API list rates, came to 12,365 USD for 26.2 billion tokens, or 0.47 USD per million. The machine works out about 80 times cheaper per token read. That rests on the 1.8 million tokens per second of one busy minute in our harshest test, stretched over all 730 hours of a month, so treat it as a best case.

27,900 USD a month at 1.8 M tokens per second is about 0.006 USD per million tokens. That is about 80 times less than a real heavy month on the Claude API.

The comparison is fair because both sides are mostly re-reading: 96% from the cache in our test, 96.8% in the real Claude month. A team that sleeps at night pays more per useful token. The 30% and the 80 times answer different questions, so do not multiply them.

Quality: first on LiveBench agentic coding, and cached answers match fresh ones

On an outside coding benchmark, DeepSeek V4.1 Flash ranks first. LiveBench runs an agentic coding category, where a model has to finish a real coding task step by step. On 10 October, DeepSeek V4.1 Flash scored 77.3 and ranked first of 69 models. Claude Opus 5.5 scored 71.7. We did not run this benchmark ourselves.

LiveBench agentic coding (livebench.ai, 2026-10-10): DeepSeek V4.1 Flash 77.3 against Claude Opus 5.5 71.7. External benchmark, not measured by us.

A broader index from Artificial Analysis points the other way: Opus 5.5 scores 58 and Flash 39. For a team moving from Opus, that gap is the honest caveat, so try Flash on your own tasks before you switch.

Our own check is that the shelf does not change the answers. We hid one fact in a long document, up to 200,000 tokens, and asked for it twice: once read from scratch, once served from the cache. Five documents out of five gave the same right answer both ways. The cached version answered in under a second. The 200,000-token one took 13 seconds read from scratch.

That check earned its place. An earlier version of our adapter served nothing from the cache, and this check caught it before any load test ran. We fixed it, and the fixed version served repeats 95 to 99% from the cache. Every measured number in this post comes from it.

Your code goes where you decide

With Claude, or with DeepSeek's API, your code and the data it touches end up with a model provider. With inferencekey on your own GPUs, it never leaves your network. With the inferencekey cloud, where these tests ran, it goes to our GPUs, not to Anthropic or OpenAI. In both cases the API keys stay on your side, inside your network. If one leaks, you rotate it there. The price and the tests here are for the inferencekey cloud. We have not priced or tested the on-premise case.

200 agents at 500K overflow the fast shelf, so about 120 is the ceiling at that size

At 500,000-token conversations the fast shelf is the ceiling. With 200 agents all asking at once, their conversations did not fit in the graphics cards' memory. The run collapsed: half the answers took over two minutes to start. Nothing was lost and nothing errored, but it was unusable. At that harsh pace, about 120 conversations of this size can be served at once.

Most tests skipped the inferencekey API and called the engine directly. The one that used it had zero errors, but its slowest answers took 22 seconds to start, not 15. It was a single short window, so we cannot yet say how much the extra hop costs on long conversations.

Worth it above about 140 subscriptions, if slower answers at peak are acceptable

Above about 140 Claude Max 20x subscriptions, one machine is a flat bill with no per-person usage cap. The ceiling is shared, about 400 agents, and you keep Claude Code. Below about 140, subscriptions cost less. If your code cannot leave the building, the same setup can run on your own GPUs. If you have ten developers, subscriptions or DeepSeek's API are still the simpler choice.

Run it yourself

Follow the DeepInfer on 4x B200 guide to serve DeepSeek V4.1 Flash and point Claude Code at it. You need four B200 cards, or a workload on the inferencekey cloud, and an inferencekey API key. With the weights on disk, our workload was ready in under two minutes.

export ANTHROPIC_BASE_URL=https://api.inferencekey.com/endpoint/<project>/<workload>
export ANTHROPIC_AUTH_TOKEN=ik_live_...
export ANTHROPIC_MODEL=deepseek-v4.1-flash
export ANTHROPIC_DEFAULT_HAIKU_MODEL=deepseek-v4.1-flash
export ANTHROPIC_DEFAULT_SONNET_MODEL=deepseek-v4.1-flash
export ANTHROPIC_DEFAULT_OPUS_MODEL=deepseek-v4.1-flash
export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1
claude