Liquid AI's New 230M Model Runs on a Raspberry Pi and Beats Models 4x Its Size at Data Extraction

TL;DR

Liquid AI just shipped LFM2.5-230M, its smallest model yet, and the pitch is refreshingly narrow: it is built to run anywhere and do one family of jobs well. At 230 million parameters it decodes at 42 tokens per second on a Raspberry Pi 5 in a 293 MB footprint, hits 213 tokens per second on a Galaxy S25 Ultra, and on structured data extraction it beats Gemma 3 1B, a model more than four times its size. The weights are open, both base and post-trained variants are on Hugging Face, and there is day-one support for llama.cpp, MLX, vLLM, SGLang, and ONNX. The honest part: Liquid tells you up front not to use it for math, code, or creative writing. This is a screwdriver, not a Swiss Army knife, and that is exactly why it is interesting.

What it actually is

LFM2.5-230M is built on the LFM2 architecture, which is not a vanilla transformer. The 230M model is 14 layers: 8 double-gated short convolution blocks plus 6 grouped-query attention blocks. The convolution blocks handle most of the sequence mixing cheaply, and attention is sprinkled in only where it earns its keep. That hybrid layout is the reason a model this small can hold a 32,768-token context and still scream on a CPU, where a pure-attention model of the same size would choke on the quadratic cost.

Think of it like a kitchen that uses a sharp knife for almost everything and only fires up the expensive food processor for the few tasks that truly need it. Attention is the food processor: powerful, hungry, and overkill for chopping a single onion. Most layers here just use the knife.

It was pre-trained on 19 trillion tokens, covers ten languages, and has a mid-2024 knowledge cutoff. The post-trained variant went through three stages: supervised fine-tuning with distillation, direct preference optimization, and multi-domain reinforcement learning. The license is Liquid's own lfm1.0, so read it before you ship a commercial product on top, but the weights are right there for you to pull.

Why "runs anywhere" is the whole point

The headline number for builders is not a benchmark, it is the footprint. Quantized to 4-bit, the model fits in 293 MB on a Raspberry Pi 5 and 375 MB on a phone. That is small enough to sit resident in memory on hardware you already own and never touch the network. Liquid reports 523 tokens per second prefill and 42 decode on the Pi, and 1,158 prefill with 213 decode on a Snapdragon Gen4 phone.

For the homelab and edge crowd this is the dial that matters. A model that fits in a few hundred megabytes and runs on a $80 single-board computer changes where you put the work. Document parsing, log triage, pulling fields out of forms, simple tool-calling assistants on a phone or a robot: all of it can stay local, with no per-token bill and no data leaving the device. The latency floor is whatever your CPU does, not whatever the API gods feel like today.

The benchmarks, including the ones that hurt

Liquid tested it against Granite 4.0-H-350M, Gemma 3 1B, and Qwen3.5-0.8B across ten benchmarks. Where it shines is instruction-following and extraction. On IFEval it scores 71.71 against Qwen's 59.94 and Gemma's 63.49. On IFBench the gap widens to 38.40 versus 22.87 and 20.33. On the clinical-extraction CaseReportBench it posts 22.51 against Qwen's 13.83 and Gemma's 2.28.

Now the part nobody else will put in bold. On broad knowledge it gets walloped: MMLU-Pro 20.25 against Qwen's 37.42. On GPQA Diamond it manages 25.41, a hair behind Qwen's 27.41. Liquid itself says, in writing, that the model is not for reasoning-heavy workloads: no advanced math, no code generation, no creative writing. That is not a flaw they forgot to mention; it is the design. They spent the parameter budget on following instructions and extracting fields, and they let the trivia and the calculus go.

Why a builder should care

The interesting shift here is philosophical. Most of the last two years has been a race to make one model do everything, and the price has been size, cost, and a network dependency you cannot escape. LFM2.5-230M is the opposite bet: a model deliberately bad at most things so it can be excellent and tiny at a few. If your product is "turn this messy document into clean JSON," you do not need a frontier model's worldview, you need a reliable extractor that runs on the device in your hand.

• Match the model to the task, not to the leaderboard. A 230M specialist that beats a 1B generalist at extraction is worth more to an extraction pipeline than the generalist, and it costs a fraction to run.
• Local-first becomes practical at this size. Under 300 MB on a Pi means you can put inference where the data already is. No egress, no API key, no rate limit.
• Read the limitations as a spec, not a warning. "Not for math or code" tells you precisely what to route elsewhere. A small model with an honest boundary is easier to build on than a big one that fails silently.
• The runtimes are already there. llama.cpp, MLX, vLLM, SGLang, and ONNX on day one means you can wire it into whatever you already run without waiting on a community port.

The broader signal is that the small-model frontier is now about specialization and placement, not just shaving parameters. Liquid did not try to make a tiny model that is a worse version of a big one. They made a tiny model that is a better version of a big one at the one thing it does, and small enough to live on a credit-card computer. For anyone shipping on the edge, that trade is starting to look like the obvious one.

Key Takeaways

• LFM2.5-230M is a 230M-parameter open-weight model from Liquid AI, released June 25, 2026, with base and post-trained variants on Hugging Face.
• It runs at 42 tok/s on a Raspberry Pi 5 (293 MB, 4-bit) and 213 tok/s on a Galaxy S25 Ultra, with day-one support for llama.cpp, MLX, vLLM, SGLang, and ONNX.
• It beats Gemma 3 1B and Qwen3.5-0.8B on instruction following (IFEval 71.71, IFBench 38.40) and on the CaseReportBench extraction task (22.51 vs 13.83 and 2.28).
• It deliberately trails on broad knowledge and reasoning (MMLU-Pro 20.25) and is explicitly not recommended for math, code, or creative writing.
• The architecture is a hybrid: 8 double-gated short-convolution blocks plus 6 grouped-query attention blocks, which is why it stays fast on CPU at a 32K context.

Sources: Liquid AI: LFM2.5-230M blog, LFM2.5-230M model card (Hugging Face), VentureBeat, MarkTechPost