Quantization-Aware Healing turns a 4-bit model into one that beats its 16-bit original
On August 25, 2026, Multiverse Computing published Quantization-Aware Healing, a recipe that, applied to a GPT-OSS 120B compressed to 60B and quantized to MXFP4, beats its bfloat16 version on 7 of 9 benchmarks. The method distills from the original model, not from the compressed checkpoint.
August 25, 2026. Multiverse Computing published a post on the Hugging Face blog detailing Quantization-Aware Healing, or QAH. 120B. The parameter count of the original GPT-OSS model, compressed to 60B and quantized to MXFP4 in the experiment. 7 of 9. The number of benchmarks on which the 4-bit model beats its full-precision bfloat16 counterpart. Why it matters: the result inverts the usual relationship between a 4-bit model and the 16-bit model it came from, and that inversion has direct consequences for anyone paying per token to serve a model.
The paradox of model compression
Making a large language model smaller almost always carries a cost. The standard recipe for efficient deployment is to compress the architecture first, removing layers, heads, or neurons to cut the parameter count, then quantize the remaining weights down to 4 bits to shrink memory and compute. Both steps save a lot, but together they systematically degrade the capabilities people actually care about: reasoning, mathematical problem-solving, and code generation.
That is why serious deployment pipelines add a recovery step, usually called healing, before the model reaches production. Recent open-weight releases such as gpt-oss, NVIDIA’s Nemotron family, and Multiverse Computing’s own Hypernova 60B all rely on some version of this compress-then-heal approach.
The question the post poses is the one the field had mostly left open: once a model has gone through structural compression, not just quantization, how well does that recovery step actually work, and what is the right way to do it.
Why the existing methods hit a ceiling
Most pipelines follow the same three steps: compress the architecture, quantize the compressed weights, then heal the damage. The difference between methods is entirely in that last step.
The dominant recipe is quantization-aware training, or QAT. It inserts fake-quantization operators into the forward pass and keeps fine-tuning the model on a task loss, so the weights learn to tolerate the low-precision representation. In practice that means re-running an already expensive post-training process, supervised fine-tuning, RLHF, and agentic tuning, through a noisier, lower-precision forward pass. It is costly, and the results show it can become unstable if training continues too long past its best point.
The alternative, quantization-aware distillation, or QAD, avoids re-running that history. Instead of a task loss, it distills a frozen full-precision teacher directly into the quantized student through a Kullback-Leibler divergence loss on the output logits. This works well when the only change is quantization, because a genuine full-precision version of the same model exists to serve as teacher. But once a model has gone through structural compression, with fewer layers, heads, or neurons, that assumption breaks. There is no independently trained full-precision version of the smaller architecture. The only candidate teacher is the recovered bfloat16 checkpoint, which is itself a distilled approximation of the original model. Distilling from it anchors the quantized student to a degraded target and caps its accuracy at that checkpoint’s own ceiling.
QAH’s answer: distill from the source
Quantization-Aware Healing removes that ceiling with a single change: it distills directly from the original, pre-compression model rather than from the recovered checkpoint.
The logic is clean. The original 120B model holds all the information the compression is about to remove. Instead of distilling the quantized model from a degraded version of itself, QAH distills it from the full source, tolerating the architecture gap between teacher and student. The 4-bit model therefore learns to reproduce the behavior of the big model, not the behavior of a weakened copy.
The number is striking: applied to a GPT-OSS 120B compressed to 60B and quantized to MXFP4, QAH produces a model that beats its own full-precision bfloat16 version on 7 of 9 benchmarks. The 4-bit model ends up smaller, cheaper to run, and more accurate than the checkpoint it was quantized from.
What this changes in practice
The most direct consequence is economic. An MXFP4 model occupies four times less memory than a bfloat16 model at equal parameter count. Serving a model that is both smaller and more accurate changes the economics of inference: fewer GPUs, less memory bandwidth, lower latency, without sacrificing quality, if anything the opposite.
For teams deploying open-weight models, the recipe also brings robustness. QAT could turn unstable when pushed too far; QAD was capped at the quality of the recovered checkpoint. QAH plugs into the best source available, the original model, and delivers a more reliable result precisely where the two earlier methods failed on structurally compressed models.
Caution is still warranted, and the post owns it. The result is demonstrated on one family, GPT-OSS, across nine benchmarks. Porting the gain to other architectures means reproducing the experiment. But the direction is set: the question of how to heal a model that is both compressed and quantized now has a concrete, reproducible answer.
Where MXFP4 comes from
The MXFP4 format is not arbitrary. It belongs to the Microscaling family, championed by Microsoft, AMD, Arm, Intel, NVIDIA, and Qualcomm, which shares a per-block scale factor across a group of values to represent floating-point numbers on 4, 6, or 8 bits. The block-wise approach limits precision drift where plain integer quantization would throw away too much information.
The result therefore lands on a broader trend: 4-bit quantization is now the active frontier of LLM compression, and microscaling formats are what makes it accelerable on upcoming hardware. Showing that an MXFP4 model can beat its bfloat16 source is not a lab curiosity. It is evidence that the frontier can be crossed without sacrificing quality, provided the healing step is done right.
The three recipes side by side
One table captures the difference between the recovery methods:
| Method | Teacher | Weakness |
|---|---|---|
| QAT | Task loss, no teacher | Expensive, can go unstable |
| QAD | Recovered bfloat16 checkpoint | Capped at a degraded target |
| QAH | Original pre-compression model | Requires the source checkpoint |
The table hides the cost asymmetry. QAT re-runs most of the post-training pipeline through a noisier forward pass. QAD is cheap but inherits a ceiling. QAH keeps the cheap distillation but swaps in the one teacher that still holds full information. That is the whole insight, and the 7-of-9 result is what validates it.
There is also a boundary condition worth stating plainly. QAH distills from the original pre-compression model, which means the recipe applies when you are the one compressing and holding the full source checkpoint. If you download a model that was already structurally compressed by someone else, there is no pre-compression teacher to reach for, and you are back in QAD territory. That distinction, more than the benchmark spread, determines whether QAH is available to you.
Verdict
If you deploy open-weight models in production, test Quantization-Aware Healing before settling for QAT or QAD. If your pipeline starts from a structurally compressed model, QAH is the only one of the three that does not cap out at a degraded target, and the 7-of-9 win on GPT-OSS justifies the experiment.
If you consume models through an API, this changes nothing in the short term, but it signals a generation of smaller, stronger open-weight models that will eventually push down the inference cost your providers pass along. It is a trend worth tracking in the coming months.