LiquidAI LFM2.5 Review 2026: Edge AI on a Raspberry Pi — With a License Catch

By AIFoss · 9 min read
lfm2.5liquid-aiedge-aiollamaselfhostedopen-source

TL;DR: LFM2.5 is the fastest small-model family you can self-host in 2026 — the 8B-A1B MoE decodes at 253 tok/s on an M5 Max in under 6GB of memory, and the 230M model runs on a Raspberry Pi 5 in under 300MB. The catch: despite widespread “Apache 2.0” claims, both ship under the LFM Open License v1.0, which cuts off free commercial use above $10M annual revenue. Superb for edge agents and data extraction; skip it for coding.

LFM2.5-8B-A1BLFM2.5-230MQwen3 8B (dense)
Best forFast local chat, tool-use agentsPi/phone extraction pipelinesGeneral reasoning + coding
LicenseLFM Open License v1.0 ($10M cap)LFM Open License v1.0 ($10M cap)Apache 2.0 (no cap)
Memory~5GB (Q4_K_M)<300MB on a Pi 5~5.5GB (Q4_K_M)
The catchNo coding benchmarks published230M-class reasoning limits3–5× slower decode per token

Honest take: If you’re an individual, a homelab, or a company under $10M revenue, LFM2.5-8B-A1B is the best speed-per-gigabyte model you can run today — but if your work is code or your company might outgrow the license, Qwen3’s clean Apache 2.0 is the safer default.

Liquid AI spent 2026 releasing a family of models that behave unlike anything else in the local AI space. The flagship LFM2.5-8B-A1B landed May 28, 2026; the tiny LFM2.5-230M followed on June 25. Both are built on Liquid’s hybrid architecture — mostly gated convolution layers with a handful of attention layers — and the practical result is decode speed that embarrasses same-size transformers. This review covers what the family actually is, the license fine print most coverage gets wrong, how to run both models, and where they genuinely lose to Qwen.

What LFM2.5 actually is

LFM2.5-8B-A1B is a sparse mixture-of-experts model: 8.3B total parameters, but only about 1.5B active per token. Liquid pretrained it on 38T tokens (up from 12T for the previous LFM2 generation) and gave it a 128K context window. The architecture is the interesting part: 18 double-gated LIV convolution layers plus just 6 GQA attention layers. Convolutions scale linearly with sequence length, so prefill and decode stay fast where a standard transformer bogs down.

The numbers Liquid publishes are striking: 253 tok/s decode on an Apple M5 Max via MLX, around 146 tok/s on a Ryzen AI Max+ 395, and 18.5K aggregate output tok/s on a single H100 at high concurrency. On quality, the model posts IFEval 91.8, MATH-500 88.8, and AIME 2025 42.5 — instruction-following and math results that sit well above what a 1.5B-active budget should buy.

LFM2.5-230M is the other end of the family: 230 million parameters, built for hardware where even a 1B model is too heavy. Liquid’s figures — 42 tok/s on a Raspberry Pi 5 in 293MB of memory, 213 tok/s on a Galaxy S25 Ultra — were the reason it trended on r/LocalLLaMA. VentureBeat reports it beats models four times its size at structured data extraction, which matches its intended role: JSON extraction, classification, and lightweight tool-calling on devices with no GPU at all. There’s also a mid-size LFM2.5-2.6B for laptops, but the 8B-A1B and 230M are the two that matter for most setups.

Day-one runtime support is unusually broad: llama.cpp, MLX, vLLM, and SGLang for both models, plus ONNX for the 230M.

The license: not Apache 2.0, and you should care

Most social coverage calls these models Apache 2.0. That’s wrong, and it’s the single most important fact in this review.

Both models ship under the LFM Open License v1.0 (tagged lfm1.0 on Hugging Face). The text is based on Apache 2.0 and grants royalty-free, perpetual rights to use, modify, and distribute the models and derivatives — no copyleft, your fine-tunes stay yours, and research, education, and non-profit use are free with no limit.

The material difference: free commercial use ends when your organization’s annual revenue exceeds $10M USD. Past that threshold you must contact Liquid AI for a commercial license. That makes it a source-available-style license, not OSI open source — the same family of restriction as Llama’s 700M-MAU clause, just with a much lower bar.

What this means in practice:

  • Hobbyists, homelabs, researchers, non-profits: unrestricted. Run it, fine-tune it, publish derivatives.
  • Startups and small businesses under $10M revenue: free commercial use, including in products.
  • Anything that might scale past $10M: budget for a Liquid AI license or pick an Apache 2.0 model now — migrating an embedded edge model after you ship is painful.

For a broader map of which model licenses actually permit what, see our open-source LLM licensing guide.

Running LFM2.5 locally

The models are small enough that setup is the easy part. With Ollama installed, the most reliable path is pulling the official GGUFs directly from Hugging Face:

# The 8B-A1B flagship (~5GB at Q4_K_M)
ollama run hf.co/LiquidAI/LFM2.5-8B-A1B-GGUF:Q4_K_M

# The 230M edge model (runs on anything)
ollama run hf.co/LiquidAI/LFM2.5-230M-Instruct-GGUF:Q4_K_M

Liquid also maintains a LiquidAI namespace on ollama.com with prebuilt tags — check there first, since named tags survive repo reorganizations better than hf.co paths. On Apple Silicon, skip Ollama and use MLX (mlx-lm) — the 253 tok/s headline number is an MLX result, and llama.cpp lands meaningfully lower on the same hardware. For serving multiple users, vLLM and SGLang both support the architecture natively.

Two practical notes. First, the usual Ollama context trap applies: the default context window is small, so set num_ctx explicitly (e.g., 32768) in a Modelfile if you’re feeding it documents — the model supports 128K. Second, quantization behaves normally here; Q4_K_M is the sensible default, and our GGUF quantization guide applies unchanged.

On a Raspberry Pi 5, the 230M model at Q4_K_M through llama.cpp is a genuinely usable always-on endpoint — roughly 42 tok/s with under 300MB resident. That’s fast enough for real-time extraction and classification jobs that would otherwise mean a cloud API bill. Our sister site has a full Pi 5 edge inference build guide around exactly this setup.

Where it beats Qwen — and where it doesn’t

The natural rival for the 8B-A1B is Qwen3 8B, the default choice in this weight class since 2025.

LFM2.5 wins on speed, decisively. Only ~1.5B parameters are active per token, and the convolution-heavy architecture decodes faster than even that number suggests. On the same Apple Silicon or mid-range CPU, expect roughly 3–5× the tokens per second of a dense 8B. For latency-sensitive agents — voice assistants, interactive tools, anything a human is waiting on — that’s the whole ballgame. It also wins on memory headroom and on native 128K context (Qwen3 8B is 32K native, 128K only via YaRN scaling).

Qwen wins on raw capability breadth, especially code. Liquid publishes strong instruction-following and math numbers but no SWE-bench or Aider Polyglot results, and the community consensus matches: LFM2.5 is not a coding model. If you’re wiring a local model into Continue.dev or Cline, a Qwen3-class dense model or a dedicated coder remains the right call. Qwen also carries the cleaner license, as covered above.

The honest framing: LFM2.5-8B-A1B is a specialist in exactly the workloads edge deployment cares about — instruction following, tool calls, extraction, chat — delivered at interactive speed on hardware like a MacBook Pro M5 Max or a mini PC. It is not a general-purpose frontier-quality brain.

When NOT to use LFM2.5

  • Coding assistants. No published coding benchmarks, and it shows in practice. Use Qwen3-Coder-class models instead.
  • Anything at a company that may exceed $10M revenue. The license cliff is real; pick Apache 2.0 (Qwen3, Codestral 2) if that’s a live risk.
  • Deep multi-step reasoning at the 230M tier. The small model is an extraction and classification tool, not a chat companion — expect it to fail open-ended questions gracefully at best.
  • Established fine-tuning pipelines. The hybrid LIV-convolution architecture is newer than the transformer stack; tooling like Unsloth and axolotl centers on standard transformers, so check current support before committing to a fine-tune.

Verdict

LFM2.5 is the most interesting small-model release of 2026 so far. The 8B-A1B gives you near-instant local inference in 5GB, and the 230M makes a $80 Pi board a legitimate inference node. Liquid’s architecture bet paid off, and the day-one llama.cpp/MLX/vLLM support means none of it is theoretical. The only asterisks are the ones this review leads with: it can’t code, and the LFM Open License is friendly right up until your revenue says otherwise. Within those lines, run it — it’s the best speed-per-gigabyte deal in local AI today.

FAQ

Is LFM2.5 open source? Open-weight, yes; OSI open source, no. The LFM Open License v1.0 is Apache-2.0-derived but caps free commercial use at $10M annual revenue. Research, personal, education, and non-profit use are unrestricted.

What hardware do I need for LFM2.5-8B-A1B? About 5GB of RAM or VRAM at Q4_K_M. Any Apple Silicon Mac, any 8GB+ GPU, or a modern CPU with 8GB of free RAM runs it — Apple Silicon via MLX is the fastest consumer path at up to 253 tok/s on an M5 Max.

Can LFM2.5-230M really replace a cloud API? For narrow jobs, yes. At 42 tok/s in under 300MB on a Raspberry Pi 5 it handles JSON extraction, classification, and simple tool-calling around the clock for the cost of the board’s electricity. It is not a general chat model.

Sources

Was this article helpful?