Oct 24, 2026

LFM2.5-24B-A2B Hardware Guide 2026: The 2B-Active Agent MoE Needs 16GB, Not 6GB — Real VRAM Math and Which GPU to Run It On

Q: Is there an Ollama tag?

Yes: `ollama run lfm2.5:24b` pulls the ~15GB Q4_K_M build with the tool-calling and thinking template wired in.

By RunAIHome Team · 13 min read

liquid-ailfm2local-llmmoehardware-guideagentsgpullama-cpp

TL;DR: LFM2.5-24B-A2B is Liquid AI’s biggest and final LFM2.5 model: 24B total parameters, ~2.45B active per token, 131K context, built for local agents. It decodes at a vendor-measured 184 tok/s on an M5 Max and 114 tok/s on a Ryzen AI Max+ 395. The hardware story: it brings Qwen-class agentic MoE down from a 24GB card to a 16GB card — but not lower, because all 24B parameters must sit in memory.

	LFM2.5-24B-A2B	Qwen3.6-35B-A3B	LFM2.5-8B-A1B
Best for	Tool-calling agents on a 16GB card	Strongest all-rounder if you have 24GB	Any 6GB+ GPU, raw speed
VRAM floor (Q4)	~14.5GB file → 16GB card at 32K ctx	~21GB file → 24GB card	~5.4GB file → 6–8GB card
Measured decode	184 tok/s (M5 Max), 114 (Strix Halo)	107 tok/s (RTX 3090, Ollama)	253 tok/s (M5 Max), 146 (Strix Halo)
The catch	Always emits chain-of-thought; $10M license cap	Needs a 24GB card	Shallower knowledge, same license cap

Honest take: If you already own a 16GB or 24GB card, run it tonight and buy nothing. If you’re shopping specifically for this model, a RTX 5060 Ti 16GB ($679–$805) is the cheapest new card that holds it resident — but a used RTX 3090 is the smarter buy, because it also runs the Qwen3.6-35B-A3B class this model competes with.

What Liquid actually shipped on October 13

LFM2.5-24B-A2B landed on Hugging Face on October 13, 2026 — the largest model in the LFM2.5 family and, per Liquid AI, the last one. The name decodes the same way as its smaller sibling LFM2.5-8B-A1B: 24B total parameters, roughly 2.45B active per token (the “A2B”). It’s a Mixture-of-Experts model that routes each token to 4 of 64 experts, wrapped in the same hybrid architecture that makes the LFM2 family unusual: 40 layers total — 30 double-gated short-range convolution blocks and 10 grouped-query attention blocks, not a standard transformer stack.

One correction worth making up front, because launch chatter keeps getting it wrong: the 8B sibling is not a dense model. Both are MoE — 8.3B/1.5B-active for the small one, 24B/2.45B-active for this one. The decision between them is “how much knowledge do I need resident,” not “MoE vs dense.”

Versus the October 2025 LFM2-24B-A2B it replaces, two things grew: context went from 32K to 131,072 tokens, and the vocabulary doubled from 65K to 128K (mainly better non-Latin tokenization). And one thing changed fundamentally: this is a reasoning-only model. The chat template opens every assistant turn with a thinking tag, so it produces an explicit chain of thought before every answer, whether you want one or not. More on why that matters for hardware below.

Liquid pitches it squarely at on-device agents: tool calling, browser automation, and instruction following, running privately on hardware you own. That’s the same niche NVIDIA aimed at last week with Nemotron 3.5 Bolt E4B — the agent-model race has clearly moved local.

The “2B active” VRAM trap: why 6GB cards are out

The headline number invites a wrong conclusion, so here it is plainly: 2.45B active parameters does not mean 2.5GB of VRAM. Expert routing picks a different 4-of-64 subset every token, so all 24B parameters must be loaded. The active count sets your speed, not your memory footprint.

The real numbers, from the published GGUF files:

Quant	File size	Source
Q4_K_M (Liquid official)	13,853 MiB (~14.5GB)	LiquidAI GGUF repo
UD-Q4_K_XL (Unsloth)	14,188 MiB (~14.9GB)	Unsloth GGUF repo
Ollama `lfm2.5:24b` default	15GB	Ollama library

On top of the weights you need KV cache, and the 131K context window is where 16GB cards get into trouble. A community RAM-budget breakdown ran the math: at 32K context, weights plus KV cache come to ~14.15 GiB — that fits a 16GB card with ~1.85 GiB of headroom, as long as nothing else is using the GPU. At the full 128K context it’s ~16.03 GiB, which is just over the line. Liquid’s own guidance says the model was designed to fit in 32GB of system RAM, which is the comfortable-with-everything-open number, not the floor.

So the tier map looks like this:

8GB cards (RTX 4060, RTX 3070): not resident. llama.cpp’s --n-cpu-moe expert offloading exists, but we found no published runs of it with this model — until someone measures it, treat 8GB as unsupported rather than “slow but fine.”
12GB cards (RTX 3060 12GB, RTX 4070): the 14.5GB file doesn’t fit. Same offloading caveat.
16GB cards (RTX 5060 Ti 16GB, RX 9070 XT): the sweet spot this model was seemingly quantized for. Resident at 32K context; cap your context and quantize KV cache (q8_0) if you push longer.
24GB cards (used RTX 3090/4090): comfortable at any context, with headroom for a draft model or embeddings server beside it.
Unified memory (Strix Halo, Apple Silicon 32GB+): fits easily; this is the hardware class Liquid measured on.

Not sure where your card lands with your exact context setting? Our VRAM calculator does the weights-plus-KV math per model and context length.

Speed: what’s measured, what’s estimated

Two measured numbers exist, both from Liquid AI’s own launch material:

184 tok/s on an Apple M5 Max (reported as Q4_K_M in some coverage, MLX in other — the quant behind the headline number is genuinely ambiguous across sources)
114 tok/s on an AMD Ryzen AI Max+ 395 (Strix Halo)

Sanity-check with the bandwidth ceiling: at Q4_K_M, ~2.45B active parameters means reading roughly 1.5GB of weights per token. The M5 Max moves 614 GB/s, so the hard ceiling is ~410 tok/s and the measured 184 is ~45% of it — believable for a hybrid-conv model with routing overhead. Strix Halo at 256 GB/s has a ~170 tok/s ceiling, and the measured 114 is ~67% of it. Both pass.

For discrete NVIDIA cards there are no independent published benchmarks yet — early Hacker News reports say “very fast on a 4090” without numbers. ModelFit publishes estimates for the architecturally identical predecessor (LFM2-24B-A2B): ~225 tok/s on an RTX 3090 and ~257 tok/s on an RTX 4090, flagged at ±15% typical error. Both sit well under the respective 620–680 tok/s bandwidth ceilings, so they’re plausible — but treat every number in the right column below as an estimate until llama-bench runs land:

Hardware	Bandwidth	Decode	Status
Apple M5 Max	614 GB/s	184 tok/s	Measured (Liquid AI)
Ryzen AI Max+ 395	256 GB/s	114 tok/s	Measured (Liquid AI)
RTX 3090 24GB (used)	936 GB/s	~190–260 tok/s	Estimated (ModelFit, predecessor model)
RTX 4090 24GB (used)	1,008 GB/s	~220–295 tok/s	Estimated (ModelFit, predecessor model)
RTX 5060 Ti 16GB	448 GB/s	~110–140 tok/s	Estimated (bandwidth-scaled)

Whatever the exact figure, every card on this list decodes far past reading speed (~7–10 tok/s). Speed is not the deciding factor here — it’s whether the model fits, and whether its quality covers your use case.

Where it beats Qwen3.6-35B-A3B — and where it doesn’t

Liquid’s launch benchmarks compare directly against Qwen3.6-35B-A3B, the model this one is clearly priced (in VRAM) to undercut. Vendor numbers, so apply the usual salt, but the pattern is coherent:

Benchmark	LFM2.5-24B-A2B	Qwen3.6-35B-A3B
LiveClaw (agentic)	48.09	38.19
AutomationBench	27.69	8.72
Instruction following (3 benchmarks)	leads all 3	—
MATH-500	96.04	96.73 (near-tie)
HLE	7.40	7.69 (near-tie)
GPQA Diamond	74.42	83.69
SWE-Bench Verified (OpenCode)	51.00	66.20

Liquid’s claim is winning or matching on five of eight benchmarks while decoding up to 1.7× faster — note the speed comparison was not a head-to-head run on the same machine. The honest read: this model wins at the agent loop (tool calls, browser automation, following instructions precisely) and loses at knowledge and hard coding. A 2.45B-active model routing through 24B total parameters simply carries less than Qwen’s 35B — GPQA and SWE-Bench show exactly that gap.

That maps cleanly onto hardware tiers. If you have a 16GB card, this is now arguably the best agent model you can hold resident — see our 16GB VRAM tier guide for what it displaces. If you have 24GB, Qwen3.6-35B-A3B remains the stronger generalist at 107 tok/s on a used 3090, and the interesting pattern is running both: LFM2.5 as the always-loaded agent/router, Qwen pulled in for the hard problems.

The always-thinking catch

LFM2.5-24B-A2B cannot skip its reasoning phase — every response starts with a chain-of-thought block. For agent use this is mostly good (the thinking is where tool-call planning happens), but it has two practical costs:

Latency per short answer. A “what’s 2+2”-class query still generates thinking tokens first. At 114–184 tok/s this is tolerable; on slower hardware it compounds.
Framework handling. Your client has to parse out the thinking block. Ollama and LM Studio handle the template natively; if you’re wiring raw llama.cpp output into a pipeline, strip the reasoning segment before passing text downstream, or tool-call parsing breaks.

A real problem you’ll hit, and the fix: on a 16GB card with the default Ollama context settings, pushing a long agent session toward high context will OOM or silently spill to shared memory and tank throughput. Cap the context at 32K (num_ctx 32768) and, in llama.cpp, quantize the KV cache with --cache-type-k q8_0 --cache-type-v q8_0 — the same tuning that gains 27% on Qwen3.6 keeps this model inside 16GB.

How to run it tonight

Fastest path is Ollama — the official tag went live at launch:

ollama run lfm2.5:24b
# pulls ~15GB (Q4_K_M), then:
# >>> Write a bash one-liner to find the 10 largest files
# <think>The user wants a bash one-liner... </think>
# find . -type f -exec du -h {} + | sort -rh | head -10

For llama.cpp, Unsloth’s GGUF repo has the UD-Q4_K_XL build (14,188 MiB):

llama-server -hf unsloth/LFM2.5-24B-A2B-GGUF:UD-Q4_K_XL \
  -ngl 99 -c 32768 --cache-type-k q8_0 --cache-type-v q8_0

vLLM and SGLang are supported for batch serving (Liquid’s 21K output tok/s figure on a single NVIDIA B300 came from SGLang in BF16 — a data-center number, not a home-lab one). For the full family setup walkthrough, our sister FOSS site covers it in aifoss.dev’s LFM2.5 family review, and if you want to wire it into a local coding agent, see aicoderscope.com’s Continue.dev + Ollama stack guide.

The license: same $10M catch as the rest of the family

Like every LFM2.5 release, this ships under the LFM Open License v1.0, not Apache 2.0, no matter what aggregators say. Free commercial use is capped at organizations under $10 million in annual revenue — and revenue counts across the whole legal entity including affiliates under common control. Home labbers and indie developers are fine; if you’re inside a larger company, you need a commercial agreement with Liquid AI before shipping on it.

What to actually buy

Prices as of October 2026, all verified against current street prices (not MSRP):

Your situation	The machine	Price	Where
Already own a 16GB+ card	Nothing — run it tonight	$0	—
Cheapest new card that holds it resident	RTX 5060 Ti 16GB	$679–$805	Check price
Want 128K context + room for Qwen3.6-35B too	Used RTX 3090 24GB	$1,456–$1,558	Check price
Quiet always-on agent box, no tower	GMKtec EVO-X2 64GB (Strix Halo, 114 tok/s measured)	~$2,199	Check price
Undecided — test the workload first	Rented RTX 3090, from $0.07/hr	pay per hour	Vast.ai

The 5060 Ti row deserves one caveat: at $679–$805 street (MSRP $429 — nobody sells at MSRP), it’s only worth buying if this 16GB-class agent workload is specifically what you’re building for. For $650–$880 more, the used 3090’s 24GB runs this model and the entire 24GB-tier catalog — the value-king math still holds even at 2026’s inflated used prices. And if your plan is a dedicated low-power agent appliance, the Strix Halo mini PC route gets you the one configuration with a vendor-measured number.

Recommended Gear

RTX 5060 Ti 16GB — cheapest new card that holds the model resident at 32K context
RTX 3090 24GB (used) — full 128K context, plus the entire 24GB-tier model catalog
GMKtec EVO-X2 — Strix Halo mini PC, the 114 tok/s measured configuration

FAQ

Can I run LFM2.5-24B-A2B on an 8GB or 12GB GPU? Not resident — the Q4_K_M file alone is ~14.5GB, and all 24B parameters must be loaded despite only 2.45B being active per token. CPU expert offloading via llama.cpp’s --n-cpu-moe is theoretically possible but has no published benchmarks for this model yet. If you have 8GB, run LFM2.5-8B-A1B instead — same family, same tool-calling focus, ~5.4GB.

Is it better than Qwen3.6-35B-A3B? At agent tasks (tool calling, automation, instruction following), Liquid’s benchmarks say yes — LiveClaw 48.09 vs 38.19. At knowledge and coding, no — Qwen wins GPQA Diamond 83.69 vs 74.42 and SWE-Bench Verified 66.20 vs 51.00. It’s also a 16GB model vs Qwen’s 24GB floor, which for many readers is the deciding line.

Why does it think before every answer? It’s a reasoning-only model — the chat template opens every turn with a thinking tag and there’s no toggle to disable it. Budget for the extra tokens; at 114+ tok/s on supported hardware it’s rarely noticeable.

Can I use it commercially? Under the LFM Open License v1.0, yes if your organization’s total annual revenue is under $10M. Above that you need a commercial agreement with Liquid AI. It is not Apache 2.0.

Is there an Ollama tag? Yes: ollama run lfm2.5:24b pulls the ~15GB Q4_K_M build with the tool-calling and thinking template wired in.

Sources

Last updated October 24, 2026. Prices and specs change; verify current rates before purchasing.

Was this article helpful?

Get the numbers before you buy

New GPU and mini-PC benchmarks, VRAM thresholds, and price checks — sent when there's something worth acting on, not on a schedule. No spam, unsubscribe anytime.