News · 2026-10-25

ISTA’s two-bit DeepSeek quant matches three reported tests in a 249 GB package

ISTA-DASLab has released a heavily compressed DeepSeek-V4.1-Flash checkpoint that matches the base release on three reported benchmarks. The recommended package is a 248.84 GB download, despite descriptions emphasizing two-bit weights and a 12 GB graphics-card configuration. The achievement concerns carefully allocating precision and moving state across hardware tiers, rather than putting the complete model inside a small GPU.

Key facts

• The IQ2_XXS package combines a 138.24 GB backbone with a 110.60 GB shared Engram file.
• ISTA-DASLab reports matching the base on three tests at reasoning effort 50.
• Its tested route uses Strata with one 12 GB GPU, additional system memory, and storage.
• The primary source is ISTA-DASLab’s release card, reviewed for this October 25 briefing.

Two-bit is a useful description of a compression target, but an incomplete shopping list. Large models contain components with different storage needs and different sensitivity to reduced precision. This release combines several formats and a large shared lookup table. Ignoring that table produces a misleading impression of the actual download.

The model is a sparse mixture of experts: it contains many specialist blocks while activating only a few for an individual token. That makes the distinction between total stored weights and active computation especially important. Fewer active experts do not mean the inactive experts vanish from disk or no longer need a route to the processor.

ISTA-DASLab’s release uses two complementary methods. The first learns scalar quantization grids and scales: it chooses a restricted set of numerical values that can stand in for more precise weights. The second decides how to spend a fixed storage budget across tensors. Some parts can tolerate less precision; other parts receive more of the budget.

A concrete analogy is packing a relief shipment under a strict weight limit. Compressing every object identically is rarely best. Fragile instruments need protection, while bulky packaging can be reduced aggressively. Here the scarce resource is stored precision, and the allocator tries to preserve the computations most sensitive to losing it. The quantization lesson explains the basic trade between numerical detail and compact representation.

The underlying grid-learning paper and the allocation paper give the method a research foundation. The latter’s authors describe their subject as “Model Compression with Exact Budget Constraints via Riemannian Manifolds.” That paper supports the allocation approach; it is not an independent verification of the new checkpoint’s scores.

The release card reports parity on a mathematics test, a difficult scientific-question test, and a coding test. That is meaningful evidence within the disclosed setup. It shows that aggressive compression need not automatically destroy performance on every demanding task. The honest interpretation remains narrower than a statement that every answer or every probability distribution is unchanged.

The strongest objection is coverage. These are three already high-scoring evaluations, and the card provides no confidence intervals or independent replication. Near a test’s ceiling, a score may conceal differences that appear in other prompts, longer coding sessions, or ordinary conversation. The community discussion asks for broader evidence. Those questions do not prove damage; they identify what the public evaluation has not characterized.

Hardware claims require similar precision. The model card’s 12 GB figure is video memory for a configuration that keeps the remaining backbone in system memory and maps the Engram table from the drive. It does not publish one universal host-memory minimum. A machine with a 12 GB GPU and modest system memory is therefore not automatically sufficient. Ground Truth’s offloading lesson explains why lowering one memory requirement can move the demand elsewhere.

A separate development improves the software story. llama.cpp pull request 31086 merged DeepSeek-V4.1-Flash architecture support on October 25. That is an upstream integration milestone. It does not establish that every distributed binary contains the change or that this particular quantized package works unchanged in every backend. The release card still names Strata as its tested route.

The practical next step is independent testing of a clearly identified package on a clearly identified machine, with tasks that expose both quality and runtime limits. The release is significant because it combines a concrete artifact, explicit file accounting, and strong reported scores. Its caveat is equally concrete: roughly a quarter-terabyte download and a small GPU-memory number describe different parts of the same system, and three matching scores cannot stand in for a complete quality audit.

Primary source, verified: read the paper →

Ground Truth. (2026, October 25). ISTA’s two-bit DeepSeek quant matches three reported tests in a 249 GB package. Ground Truth. https://groundtruth.day/news/ista-deepseek-two-bit-quant-is-a-249gb-download.html

@misc{groundtruth:ista-deepseek-two-bit-quant-is-a-249gb-download,
  title  = {ISTA’s two-bit DeepSeek quant matches three reported tests in a 249 GB package},
  author = {{Ground Truth}},
  year   = {2026},
  month  = {oct},
  url    = {https://groundtruth.day/news/ista-deepseek-two-bit-quant-is-a-249gb-download.html}
}

Topics: open-weights · quantization · local-ai · inference