DeepSeek put frontier-class agentic coding weights under a plain MIT license this week, and the feeds spent two days quoting the same efficiency number back at each other. North read the number and then asked whose balance sheet it actually lands on. Her answer is the unfashionable one: the cache win belongs to whoever runs the inference fleet, and the thing a mid-market company would own got three times heavier. There is a working box, an engineer has run it, and it costs about $80,000. Below is the single test that decides whether signing that check makes any sense. - Muximus
On September 10, DeepSeek released frontier-class agentic coding weights under a plain MIT license, and within eight hours an engineer had them running on a single four-GPU node: 45 of 45 test cases completed, 713 tokens per second aggregate across eight concurrent sessions. The bill for that node is roughly $80,000. The efficiency breakthrough everyone is quoting did nothing to bring it down.
Two different costs hide inside the phrase "open weights," and this release moved them in opposite directions. Serving a model to many users at once got cheaper, and that is money in the pocket of whoever operates the inference fleet. Owning one got more expensive, because the weights grew roughly three times bigger. A leader deciding what to do about this week's news needs to know which of those two numbers lands on their own budget.
Once that is sorted out, the decision framework has one input, and money is not it. The test is whether any workload carries a contractual, regulatory, or data-residency obligation that requires the weights to sit on hardware the organization controls. If one does, the hardware now exists and can be priced to the dollar. If none does, the arithmetic below says rent.
The license was never the variable
The model card states that "This repository and the model weights are licensed under the MIT License," and the LICENSE file backs it up: 1,084 bytes of unmodified MIT, with no addendum and no acceptable-use policy, on a repository nobody has to request access to. Nothing in it would make a general counsel read twice.
That is also not news. The identical MIT text ships on the eight DeepSeek flagships before this one, back to R1 in January 2025 - V4-Pro, both April V4-Flash builds, the July refresh and both August releases, V3.2, V3.1. DeepSeek's last bespoke-license weights, the V2.5 line and deepseek-vl2, stop in December 2024. Nine consecutive flagship releases, same terms, ungated.
Anyone who has been waiting for the license terms to loosen before putting open weights on owned hardware has been waiting for something that already happened, nine times. What changed this week is the box. Under the unchanged license sits a multimodal mixture-of-experts model - a design that routes each token to a small subset of specialist sub-networks rather than running the whole model every time - with a 40-layer causal encoder-decoder stack, a 1M-token context window, and 8B parameters activated per token during prefill, 16B during decode.
And the thing the waiting was supposed to deliver, a model small enough to be practical on owned hardware, moved the wrong way.
The number everyone is quoting is a serving number
The technical headline is Compressed Sparse Attention 2 and FP4 main-KV caching in E2M1 format, which brings the key-value cache - the running memory of an in-progress conversation - down to 890 bytes per token. A full 1M-token session therefore holds roughly 890 MB, under one percent of a single 96GB card. That is a genuine result, and it was never the thing keeping this class of model off a company's own hardware. Shrinking it does not change who can own one.
The constraint is the weights, and they are heavier than the headline suggests. The "552B" on the model card is the backbone only; safetensors metadata reports 763,205,315,794 parameters, the backbone plus roughly 196B of Engram conditional memory plus the vision components. Total blob size on Hugging Face is 510.3 GB, against 159.6 GB for the predecessor V4-Flash. That is 3.2 times larger. A box that loaded the previous Flash will not load this one.
Practitioners noticed immediately. One Hacker News commenter working through the parameter arithmetic figured that "256 GB memory is insufficient to even load the model at q4," flagging that he was unsure of the count; others registered the same disappointment that the weights went past 470B at all.
The usual escape hatch is a community quantization, a compressed copy at lower numeric precision. Twenty-six exist for this model. Every one has zero downloads, and no quality results have been published for any of them; the smallest real weights are a mixed 2-bit GGUF at 168.9 GB and an expert-pruned 2-bit MLX build at 212.9 GB. There is also a structural reason to expect less from this route, put well by HN commenter aenis: "internally its mostly FP4 already, so there won't be a cut-in-half-but-almost-just-as-good quant."
So the cheap path down is not there yet. The expensive path up is.
Somebody built the box
Within hours of the release, the repository 0xSero/deepseek-v4.1-flash-4x-rtx-pro-6000 appeared: a Docker launcher for four RTX PRO 6000 Blackwell cards at 96GB each, 128GB of DDR5, and local NVMe. It has 34 stars and, more usefully, numbers.
All 45 test cases completed successfully. Throughput measured at roughly 201 tokens per second single-stream and 713 tokens per second aggregate across eight concurrent sessions. A separate capacity test, filling 4,063,744 KV tokens across eight distinct 500,000-token inputs, ran at 599.7 tokens per second aggregate.
That is a working existence proof at a scale a single team can buy. NVIDIA's marketplace lists the RTX PRO 6000 Blackwell at $16,000 today; street pricing at Newegg and B&H runs $15,599 to $16,999. Four cards is $64,000 in GPUs alone, before DDR5, NVMe, chassis, power supply and CPU. A defensible all-in figure is $75,000 to $85,000. A frontier-class agentic coder inside a private network is now a purchase order with part numbers on it.
What $80,000 does not include
It does not include a quality program, because nobody has run one. The repository says so itself: the setup is "still experimental," "Broader quality testing remains pending," and "These are performance tests, not quality scores." Video processing failed in that run and multi-image handling is unresolved. The release also ships without a Jinja chat template, pointing at DeepSeek's Rust deepseek-recipe toolkit instead.
The most consequential report comes from Hugging Face user WiSFoR, replying in the four-GPU repo's discussion thread: "kept failing on tool caliing benchmarks. disabling dspark solved it." Tool calling is the entire job of an agentic coder. The fix is one line, and a buyer learns it from a stranger's reply rather than from documentation. That is an honest picture of the operational knowledge around this model, and it belongs in the capex memo alongside the hardware quote.
Every performance figure on the model card is DeepSeek's own - "All base models are evaluated in our internal framework under the same evaluation settings," the card states - and no independent replication exists. A Hugging Face pull request titled "Add community evaluation results" looks like one until it is read closely: the results were "extracted from the model card's Instruct-model benchmark table." DeepSeek's numbers, re-imported.
Evaluated in DeepSeek's own internal framework, those numbers cut both ways. The vendor reports 90.6 Pass@1 on Terminal-Bench 2.1 and 74.2 Resolved on DeepSWE v1.1, against 87.9 and 62.7 for its own 1.6T-backbone V4-Pro and 89.1 and 74.0 for Opus-5.0, plus a Codeforces rating of 3471. The same internal table shows it losing: Terminal-Bench 3.0 at 30.0 against Opus-5.0's 43.3, Terminal-Bench 4.0 at 31.2 against 51.8, ProgramBench 20.3 against 37.0, NL2Repo 64.0 against 75.3, and behind on GPQA Diamond. Against GPT-5.6 Sol the table adds SEC-Bench Pro, 62.8 against 74.3 - the comparison HN commenter AlexWApp drew, reading the same rows.
A vendor that publishes five rows where its own model loses has earned some credit. It is still the vendor's scoreboard, and acceptance testing remains the buyer's job.
The arithmetic the finance meeting will run
DeepSeek serves the same model through its API. Its pricing page, not the model card, lists $0.15 per million input tokens on a cache miss, $0.003 per million on a cache hit, and $0.60 per million output tokens, off-peak.
That 50-fold spread between a miss and a hit governs the whole comparison. One practitioner posted observed spend rather than a projection: mmastrac ran the preview model "around 2,126,605,070 tokens for $22.04" - an effective $0.0104 per million, 14.5 times below list input, reachable only with near-total cache hits.
Both bases belong in the memo. At list, $80,000 of hardware is on the order of 130 to 530 billion tokens of API usage, depending on the input-output mix. At the heavily-cached rate that practitioner actually measured, it is closer to 7.7 trillion. Both ends are large, and the spread is the finding: cache-hit rate moves this calculation by more than an order of magnitude, and it, rather than the sticker price of the box, is what a build-versus-buy case has to model. Very few mid-market organizations will burn through even the low end before the hardware depreciates. A capex case built on savings will not survive the first finance review, and it does not deserve to.
The cache win does pay off, for whoever is running the fleet. Smaller KV means far more concurrent long-context sessions on the same VRAM, which is serving-provider economics. On the model's Hugging Face discussion board, Gavin-chen worked the same sum for an 8× H200 configuration with 1,128 GB of VRAM and put it, in Chinese, at theoretically 500 concurrent sessions. That is a margin story for an inference vendor, and it is why API prices keep falling. It is not a reason to buy a box.
The verdict
Wait on cost. Move on residency, where residency is real.
The test is whether any workload carries a contractual, regulatory, or data-residency obligation that requires the weights to sit on hardware the organization controls. Regulated client code, a sovereignty clause, a customer who will not sign off on outbound inference. If one of those is real, the answer moved this week from "not available" to "$75,000 to $85,000, plus a quality-acceptance program nobody has run yet, on weights nobody can take away" - a procurement exercise with part numbers, a measured throughput figure and a documented list of unknowns.
If no such obligation exists, the same finance meeting ends in one line: rent it, and revisit when the quantizations have been tested.
What sorts an organization into one of those two meetings is a legal question rather than a financial one, which means it can be settled this quarter without benchmarking anything.
