Liquid AI has published a new batch of checkpoints for its LFM2.5 model family on Hugging Face, in GGUF Q4_0 format, trained with a method it calls QAD — quantization-aware distillation. Across four sizes (230M, 350M, 1.2B-Instruct and 2.6B), the checkpoints recovered 97.1%, 96.5%, 97.4% and 96.6% of their respective BF16 baseline scores on benchmarks.
If you don't run models locally, that sentence won't land. To see why it matters, you need to know what Q4_0's reputation actually is inside the llama.cpp ecosystem.
A format the community had already abandoned
Q4_0 was one of the earliest 4-bit quantization schemes, and its rule is blunt: every 32 weights share one scaling factor, and the rest gets packed straight down to 4-bit integers. The community later built the K-quant family (Q4_K_M, Q5_K_M and others), which allocates bit-width by tensor importance and delivers noticeably better accuracy at the same size — so Q4_0 was mostly retired, surviving only on older devices and older runtimes.
It kept one advantage nobody could take away: its regular structure maps directly onto Arm CPUs' int8 dot-product instructions. K-quant's block-splitting and lookup tables need extra steps on a phone's CPU; Q4_0 doesn't. That's exactly what Liquid AI's new speed numbers are built on — across the same set of models, Q4_0 checkpoints ran 4% to 33% faster than Q5_K_M, and 3% to 14% faster than Q4_K_M.
So the only thing holding Q4_0 back was ever accuracy. QAD is aimed squarely at that.
Moving quantization into training
The standard approach is PTQ (post-training quantization): train the full model first, compress it afterward, check how much accuracy is lost, and switch formats if the drop is too big. QAD flips that — the model learns during training what shape it will eventually be squeezed into. A high-precision teacher model distills into a quantized student model, with quantization constraints baked into training so the weight distribution moves toward the 4-bit grid ahead of time. As Liquid AI put it on its blog, QAD substantially improves the Q4_0 checkpoint.
None of this is conceptually new — quantization-aware training has been used on vision models for years. What makes it expensive on language models is that each target format needs its own dedicated training run. A vendor willing to pay that cost has clearly decided the math works out: the download and inference volume of an on-device model is worth training a dedicated format for.
Verified across four machines
Testing covered two categories of hardware: a MacBook Pro and a NucBox EVO-X2 running GPU inference, and a Samsung Galaxy S26 Ultra and a Raspberry Pi 5 running Arm CPU inference. The Raspberry Pi 5's presence on that list is notable — it represents the class of device with no GPU and tight memory, exactly where Q4_0's advantage is biggest.
Rough size math: at 4-bit precision, the 2.6B model's weights come to a bit over 1.4GB; add KV cache and runtime overhead and it still fits on a phone with 8GB of memory, with room to spare for other tasks. The 230M model is in the hundreds-of-megabytes range — small enough to ship inside an app as a genuinely local feature.
What this batch of checkpoints is betting on
The direction of the trade-off is what's new here. For the past two years, the dominant strategy for on-device inference has been to shrink the model — distill down to fewer parameters, or switch to a smarter quantization format. Liquid AI took a third path this time: leave the format and the parameter count alone, and push all the optimization pressure onto the training side.
The cost is that it only works for Liquid AI's own models. The community can't apply this method to rescue someone else's Q4_0 weights — that requires the original training pipeline. This is something only the model vendor itself can provide, and it's one of the few places in the on-device small-model race where a real gap can open up: same 2.6B size, same llama.cpp runtime, whoever's 4-bit version loses the least accuracy wins that round.
For developers, the bar hasn't moved: GGUF Q4_0 is the most universally supported format, loadable directly by llama.cpp and any Q4_0-compatible runtime, with no code changes and no new operators required. That's exactly why Liquid AI chose it over a custom format — compatibility is itself a distribution advantage.
Sources: Liquid AI official blog, CocoLoop, Hugging Face model page; accuracy-recovery percentages for all four sizes and both speed ranges verified against the vendor's published figures.