LiquidAI LFM2.5-8B-A1B Hardware Guide 2026: 253 tok/s on an M5 Max, Under 6GB VRAM, and Which Consumer Cards Actually Hit These Numbers

By RunAIHome Team · 10 min read
liquid-ailfm2local-llmmoehardware-guideapple-siliconryzen-aillama-cpp

TL;DR: LFM2.5-8B-A1B is a Mixture-of-Experts model with 8.3B total parameters but only 1.5B active per token, so it decodes like a 1.5B model while answering like a 3–4B one. Liquid AI measured 253 tok/s on an M5 Max and 146 tok/s on a Ryzen AI Max+ 395 — both in under 6GB of memory. That means it runs fast on almost any GPU with 6GB or more, or a recent laptop. The catch isn’t hardware; it’s the license.

Apple Silicon (M5 Max)Ryzen AI Max+ 395Mainstream RTX (6–16GB)
Best forMac users, MLX stack128GB mini PC ownersAnyone with a spare GPU
Measured decode~253 tok/s~146 tok/s~45–240 tok/s (est., see table)
Memory used<6GB (Q4)<6GB (Q4)~5.4GB (Q4_K_XL)
The catchMLX day-one, greatFast for a non-GPU8GB card is plenty — no need to overbuy

Honest take: If you already own any GPU with 6GB+ of VRAM — even a used RTX 3060 — you can run this model well. Don’t buy hardware for it; the whole point of LFM2.5-8B-A1B is that it makes the hardware you already have feel fast. Just read the license before you ship anything commercial.

What LFM2.5-8B-A1B actually is

Liquid AI released LFM2.5-8B-A1B as an edge-focused Mixture-of-Experts (MoE) model built for fast, reliable tool calling on consumer hardware. The naming tells the story: 8.3 billion total parameters, ~1.5 billion active per token (that’s the “A1B” — roughly one billion active). It’s the scaled-up successor to the October 2025 LFM2-8B-A1B, with the context window expanded from 32,768 to 131,072 tokens (128K) and pretraining scaled from 12 trillion to 38 trillion tokens.

The architecture is the interesting part. It’s a hybrid, not a standard transformer: 24 layers total — 18 double-gated short-range “LIV” convolution blocks and 6 grouped-query attention (GQA) layers. The convolution-heavy design is why it stays cheap on memory bandwidth, and the MoE routing is why it decodes so fast for its knowledge level.

For home labbers, one number matters more than any benchmark: only 1.5B parameters are computed per token. Decode speed on a local model is memory-bandwidth-bound — the GPU has to read the active weights out of VRAM for every single token. A dense 8B model reads ~8B weights per token; this reads ~1.5B. That’s the entire reason it’s fast.

The speed numbers that made it trend

Liquid AI published two measured decode figures on laptop-class silicon, and both stayed under 6GB of memory:

  • 253 tokens/second on an Apple M5 Max
  • 146 tokens/second on an AMD Ryzen AI Max+ 395 (Strix Halo)

For context, human reading speed is roughly 7–10 tokens/second, so both of these are far past the point where the text outruns your eyes. Even a 70B model on a fast rig struggles to hit 30 tok/s; this little MoE triples that on a laptop.

At the server end, Liquid reports the model sustaining ~18,500 output tokens/second at high concurrency on a single H100 — over 1.6 billion tokens per day. On an iPhone it manages around 30 tok/s. The through-line is that this model is optimized for throughput per gigabyte, not raw parameter count.

What to expect on your actual GPU

Here’s the important caveat, stated plainly: the two laptop numbers above are measured by Liquid AI; the discrete-GPU numbers below are estimates. Because decode is memory-bandwidth-bound and the active weight set is tiny, you can approximate expected tok/s from a card’s memory bandwidth relative to the M5 Max’s ~546 GB/s. These are ballpark figures to set expectations, not benchmarks — treat them as such until independent runs land:

HardwareMemory bandwidthExpected decode (est.)Notes
Apple M5 Max~546 GB/s~253 tok/s (measured)MLX path
RTX 50901,792 GB/s~230–250 tok/sOverkill for this model
RTX 40901,008 GB/s~130–150 tok/sComfortable
Ryzen AI Max+ 395~256 GB/s~146 tok/s (measured)Faster than bandwidth predicts — hybrid arch helps
RTX 3090 (used)936 GB/s~120–140 tok/sValue pick if you already own one
RTX 5060 Ti 16GB448 GB/s~70–90 tok/sFine; you’ll never notice
RTX 3060 12GB360 GB/s~40–50 tok/sStill 5× reading speed

Two takeaways. First, a $4,000 RTX 5090 gives you essentially no real-world benefit over a $300 card here — you’re already generating faster than you can read on anything. Second, the Ryzen AI Max+ 395 punches above its bandwidth class because the LIV-convolution layers don’t lean on raw memory throughput the way a dense transformer does. That’s a genuine architectural win, not marketing.

VRAM and GGUF sizes: it fits almost anywhere

This is where LFM2.5-8B-A1B separates from every “8B” model you’ve fought with. It ships with day-one llama.cpp, MLX, vLLM, and SGLang support, and the GGUF quants are tiny. Real file sizes from the Unsloth GGUF repository:

QuantFile sizeFits on
Q4_K_M~5.0GBAny 6GB+ card
Q4_K_XL~5.35GBAny 6GB+ card
Q5_K_M~6.36GB8GB card
Q6_K~7.09GB8GB card
Q8_K_XL~9.34GB12GB card
BF16 (full)~16GB24GB card, or CPU

The headline is that Q4 fits under 6GB with room for context, which is why the RTX 3060, the RTX 4060 8GB, and every 8GB-and-up card runs it without offloading. Compare that to a dense 8B like Llama 3.1 8B, where the same Q4_K_M is also ~4.9GB but decodes at roughly a third the speed because it fires all 8B weights per token.

If you’re on the fence about VRAM tiers in general, our best local AI models by VRAM tier guide maps which models fit which cards — LFM2.5-8B-A1B lands firmly in the “even a budget GPU handles it” bracket.

Where it fits — and where it doesn’t

LFM2.5-8B-A1B is built for a specific job: fast, reliable tool calling and data extraction on-device. That’s its lane, and it’s excellent in it — think local agents that route requests, parse documents, fill structured outputs, and call functions without the round-trip latency of a cloud API.

On raw knowledge, keep expectations calibrated. The predecessor LFM2-8B-A1B scored around 64.8 on MMLU (roughly Llama-3.2-3B territory), 37.4 on MMLU-Pro, and 34.4 on GPQA Diamond — i.e., quality comparable to a good 3–4B dense model, which is exactly what Liquid claims. LFM2.5’s extra pretraining lifts these, but this is not a reasoning powerhouse and it’s not a coding model. Liquid did not publish a SWE-bench score, and you shouldn’t expect one; for coding agents you still want something like Qwen3-Coder-Next on a 24GB card. See our note on why local LLMs got good in 2026 for how MoE sparsity changed the speed-vs-quality trade.

So the honest positioning: run LFM2.5-8B-A1B as the fast front-end of a local stack — the router, the tool-caller, the extractor — and hand the hard reasoning to a bigger model when you need it.

The license catch most posts got wrong

A lot of the launch coverage called this “Apache 2.0.” It isn’t. LFM2.5-8B-A1B ships under the LFM Open License v1.0, which is based on Apache 2.0 but adds one material clause: free commercial use is capped at organizations with under $10 million in annual revenue. Above that line you need a commercial agreement with Liquid AI.

For the vast majority of this site’s readers — home labbers, indie developers, small shops — that threshold is irrelevant and you can use, fine-tune, and ship it freely. But it’s not the no-strings Apache license people assume, so if you’re building inside a larger company, check the revenue line before you bake it into a product. Read the terms at liquid.ai/lfm-license.

How to run it tonight

The fastest path on any platform is Ollama or llama.cpp with the Unsloth GGUF:

# llama.cpp — Q4_K_XL, fits under 6GB
$ ./llama-cli \
    -hf unsloth/LFM2.5-8B-A1B-GGUF:Q4_K_XL \
    -ngl 99 \
    -c 8192 \
    -p "Extract the invoice total and due date as JSON"

On a Mac, the MLX build is the one that hits the 253 tok/s figure — the Apple M5 Max is the reference machine Liquid measured on, and MLX is where Apple Silicon pulls ahead of the Metal path. On a Ryzen AI Max+ 395 mini PC, the iGPU path via Vulkan/ROCm gets you the ~146 tok/s. On any NVIDIA card, CUDA llama.cpp or Ollama is plug-and-play.

For a full step-by-step setup across the whole LFM2.5 family — including the smaller thinking variants — our sister FOSS site has a dedicated walkthrough at aifoss.dev’s LFM2.5 family review.

Don’t have a GPU at all and want to test throughput at scale before committing? Spinning up an hour on a cloud card is cheaper than a coffee run — a rented card on RunPod lets you confirm the tok/s and tool-calling behavior fit your workload before you touch your own hardware. For a model this small, though, you almost certainly don’t need to.

FAQ

Is LFM2.5-8B-A1B better than a dense 8B model? Different goals. It matches a 3–4B dense model on knowledge benchmarks but decodes 2–3× faster than a dense 8B because only 1.5B params are active per token. For tool-calling and extraction it’s a clear win; for deep reasoning a dense model of the same footprint may answer better but slower.

How much VRAM do I really need? 6GB is enough for the Q4 quant with a usable context window. 8GB gives you comfortable headroom and Q5/Q6. You do not need a 16GB or 24GB card for this model.

Does it run on a CPU or a phone? Yes. Liquid reports ~30 tok/s on an iPhone, and the sub-6GB footprint means it runs on CPU-only laptops and mini PCs too, just slower. It’s genuinely an edge model.

Is it free for commercial use? Free under the LFM Open License v1.0 if your organization earns under $10M/year. Above that, you need a commercial license from Liquid AI. It is not plain Apache 2.0 despite what several launch articles said.

What’s the fastest way to get the 253 tok/s number? An Apple M5 Max running the MLX build. On other hardware you’ll land wherever your memory bandwidth puts you — see the estimate table above.

Products mentioned in this guide (all fine for LFM2.5-8B-A1B — a 6GB+ card is all it needs):

Prices and availability move weekly; specs verified as of July 2026.

Sources

Was this article helpful?