A 4-bit model that beats its own full-precision source: QAH wins 7 of 9 benchmarks

Multiverse Computing released arXiv paper 2608.20953 on August 21, 2026, reporting that a GPT-OSS 120B model compressed to 60B parameters and quantized to MXFP4 matches or beats its own bfloat16 source on 7 of 9 benchmarks. "Quantization-Aware Healing: A Practical Recipe for Recovering Compressed, 4-Bit LLMs" is authored by Bakbergen Ryskulov, Iker García-Ferrero, David Montero, David Jansen, Ali Hashemi, Jezabel R. Garcia, Antonio Tiene and Román Orús. The 4-bit model uses roughly 4 times less weight memory and half the teacher's parameter count. The result ships open-weight as Hypernova-60B. ASAP summarizes the result from the paper abstract and the authors' technical blog as primary sources.

Compress-then-heal is already the standard recipe

The pipeline that applies structural compression, then 4-bit quantization, then a recovery or healing stage is the one adopted by 2026 open-weight releases including gpt-oss, NVIDIA's Nemotron family and Hypernova 60B. The first step removes layers, heads and neurons to cut the parameter count; the second drops the remaining weights to 4 bits to shrink memory and compute further. Each saves a great deal, but together they systematically degrade exactly the capabilities people care about: reasoning, mathematical problem-solving and code generation. Serious deployment pipelines therefore insert a recovery step before anything reaches production.

The gap the paper targets sits precisely there. The field has no settled answer for how to recover a model that has been through both structural compression and quantization. Every difference between methods lives in that one final stage, and how well that stage actually works had never been examined properly. That is the authors' starting point.

One change: put the pre-compression original back as teacher

What separates QAH from prior methods is a single change, restoring the teacher to the original pre-compression GPT-OSS 120B, and paper 2608.20953 reports that this change alone flipped 7 of 9 benchmarks. The dominant incumbent, quantization-aware training (QAT), inserts fake-quantization operators into the forward pass and keeps fine-tuning against a task loss. In practice that means re-running an already expensive multi-stage post-training history, supervised fine-tuning and RLHF and agentic tuning, through a noisier, lower-precision forward pass.

The alternative, quantization-aware distillation (QAD), skips that history and instead distills a frozen full-precision teacher into the quantized student through a KL-divergence loss on output logits. The assumption breaks the moment structural compression enters. When only bit width changed, a genuine full-precision version of the exact same model exists to serve as teacher. Once layers and heads are gone, no independently trained full-precision version of the smaller architecture exists anywhere. The only candidate is the recovered bfloat16 checkpoint, which is itself a distilled approximation of the original, and distilling from it caps the student at that approximation's ceiling.

QAH removes the ceiling by removing the constraint. Teacher and student do not even share an architecture: the teacher is full-size and full-precision, the student is half the size running in MXFP4. Because a teacher's output distribution is architecture-agnostic, the size and shape mismatch does not block the transfer. The student never sees hard labels, only the teacher's output distribution matched through KL divergence on the logits. To handle a healing corpus with documents up to 32k tokens, the authors reuse the memory-efficient chunked KL loss from a companion paper, computing the divergence one slice of the sequence at a time rather than materializing the full vocabulary-by-sequence grid.

Seven of nine, and where the gains landed

The QAH-healed 60B MXFP4 model scores 42.7 on the long-context reasoning benchmark AA-LCR against 35.3 for the same architecture's bfloat16 checkpoint, and the same reversal appears in 7 of 9 benchmarks. It leads by 5.6 points on AIME 2025 at 76.3 against 70.7, by 2.7 on the agentic coding benchmark Aider at 40.9 against 38.2, by 2.3 on the tool-use benchmark τ²-bench at 61.7 against 59.4, by 1.7 on GPQA Diamond at 67.4 against 65.7, by 1.5 on IFBench at 59.9 against 58.4 and by 1.0 on LiveCodeBench at 66.5 against 65.5. It trails in only two places, MMLU-Pro at 73.8 against 74.0 and SciCode at 34.2 against 35.6.

The comparison against the teacher is worth noting too. At half the parameter count and roughly a quarter of the weight memory, the QAH model passes the 120B teacher on LiveCodeBench, 66.5 against 66.0, and closes to within 1.6 points on GPQA Diamond at 67.4 against 69.0. The widest remaining gap is on AA-LCR, an extreme long-context task where the capacity lost to compression is intrinsically hardest to recover.

Reading the winners and losers together suggests a direction. The two largest gains, long-context reasoning and math, are exactly the capabilities compression damages most. The two regressions are MMLU-Pro, which leans on stored knowledge recall, and SciCode, a narrow science-coding benchmark. Distillation that matches logit distributions transfers how a model solves problems, its behavior, more readily than it restores facts held in parameters. Knowledge that lived in the neurons compression removed does not come back from an output distribution alone.

QAH stops where QAT collapses

QAH reaches its 54.9 peak in about 100 steps, roughly 7 times faster than QAT, which peaks at 54.6 around step 700 and then sheds nearly 19 points by step 1,200. To isolate the effect of the loss function from everything else, the authors quantized a GPT-OSS 9B model to MXFP4 and tracked the average of MMLU-Pro, LiveCodeBench and GPQA Diamond as training progressed. On peak accuracy the two methods are effectively tied. They separate on how fast they get there and what happens afterwards: QAH stays within about two points of its peak for the rest of training, while QAT falls off sharply the moment it passes its own.

The difference matters as a deployment property rather than an accuracy one. Shipping a QAT checkpoint requires catching an early-stopping point against a held-out signal, and getting that judgment wrong means serving a model that has already begun degrading. A sufficiently trained QAH checkpoint simply does not drift, so it can be served as is. The authors locate the reason in the loss itself: KL distillation ties the student to a fixed teacher distribution, so once the student catches up it has no incentive to move, while a cross-entropy objective keeps pushing toward hard labels and eventually erodes capabilities inherited from the original.

From a release-pipeline standpoint that property is worth more than the 0.3-point difference in peak accuracy, because it removes a human judgment call. For any organization shipping models repeatedly, a procedure that requires catching the peak on every release is a place where accidents happen.

Quantization stops being a tax and becomes a second lesson

QAH uses 4 times less weight memory while raising accuracy, which reframes quantization as a second opportunity to teach rather than a price paid for efficiency. In the authors' framing, the quantization stage under QAH is no longer lossy postprocessing applied after healing finishes. It is a second full pass of distillation against the original teacher, supervision the bfloat16 checkpoint never received. The 4-bit student is not compensating for information lost to quantization; it is picking up information the earlier recovery stage lacked the time or data to transfer.

The headline deserves a careful reading here. "4-bit beats full precision" does not mean quantization improves models. It means the 60B bfloat16 checkpoint it was measured against was undertrained to begin with, and QAH supplied the remainder. The authors say as much, describing that checkpoint as the best full-precision version of this architecture that exists rather than an independently trained model. What this result overturns is not a law of physics but the industry's tacit assumption that the post-compression recovery stage was already good enough.

Where this lands for teams that must self-host

Cutting weight memory by 4 times while halving the parameter count moves a model up one tier in terms of what fits on a single GPU. Compute per token drops roughly by half, and for model families that ship in bfloat16 rather than 4-bit, the combined parameter and precision reduction pushes that closer to 8 times less compute per token. For any organization running models on its own hardware, these are the numbers that decide machine class and machine count.

Two situations feel this most directly. The first is organizations in healthcare, finance and the public sector where data cannot leave the premises and self-hosting is mandatory. Those teams have generally settled for small models or deferred adoption, and a healing recipe that preserves near-original capability through compression and quantization changes the menu. The second is on-device and edge deployment, where accuracy loss at 4 bits has been the blocking objection and that premise now warrants re-examination.

One prerequisite comes attached. QAH only works when the pre-compression original is available as teacher. In the open-weight ecosystem that is fine, since gpt-oss 120B can simply be downloaded, but there is no way to apply this to a frontier model whose weights are closed. The technique is structurally open-weight-only, which makes it precisely the right tool for teams compressing open models for their own deployment.

Before generalizing the result

The comparison target is not an independently trained 60B model but a single bfloat16 checkpoint recovered by distillation from GPT-OSS 120B, and the benchmark suite runs to 9 entries. The headline results all come from one pipeline, and the head-to-head against QAT is a separate GPT-OSS 9B experiment averaged over three benchmarks. Whether the same reversal reproduces on other model families or other compression ratios has not been shown.

The cost accounting has a missing line as well. The 100-steps-against-700 comparison counts student training steps only. QAH presumes an offline pass that precomputes the original 120B teacher's logits, and running that over a corpus reaching 32k tokens is a cost the step count does not capture. A real total-cost comparison has to put teacher-logit precomputation and storage on the same page.

One item the abstract raises about itself is worth carrying forward. The authors report a large, reproducible quality gap between distributed-training backends, meaning the same recipe run on different infrastructure produced different outcomes. Success in the healing stage rides on the training stack and not only on the loss function. Given that the authors state their aim as a recipe deployable without a multi-week hyper-parameter search, how controllable that gap turns out to be is the next thing worth verifying.

Source: Bakbergen Ryskulov et al., "Quantization-Aware Healing: A Practical Recipe for Recovering Compressed, 4-Bit LLMs" (arXiv:2608.20953, August 21, 2026) and the Multiverse Computing technical blog (August 25, 2026). Summarized by ASAP.