Stuffing a 24B Always-Thinking MoE into 24GB of VRAM: A Three-Batch Field Test of LFM2.5-24B-A2B

You have a 24GB GPU, a freshly released 24B model that went public two weeks ago, and a feed full of benchmark tables and marketing screenshots. Do you pull it down and run it locally? And if you do, what is it actually like? Those two questions recur every week in late 2026, and most reviews stop right after answering "yes, it runs." This time I deployed LiquidAI's LFM2.5-24B-A2B (released 2026-10-12) end-to-end on an RTX 4090, put it through three batches of 11 case studies taken from our production code, and used GLM-5.3, a cloud flagship one tier up in parameters, as the quality ceiling for comparison.

The short version: it runs, faster than expected; the agentic claims are real; fine-grained implementation and long-form writing are its clear weak spots.

What LFM2.5-24B-A2B Is

LFM2.5 is LiquidAI's Liquid Foundation Models 2.5 family, spanning 230M up to 24B; the 24B model closed out the lineup on 2026-10-12. The pitch in one sentence: a hybrid conv-plus-attention backbone combined with sparse MoE brings 24B total parameters down to roughly 2.45B active per token, so consumer hardware gets a big-model feel.

Three design choices stand out:

• Only 10 of the 40 layers are GQA attention. The other 30 are double-gated short-convolution blocks, a linear-attention substitute. The KV cache stays tiny; a 32K context barely dents VRAM.
• Each MoE block routes top-4 out of 64 experts. An activation ratio under 11% is the direct reason it sustains 200+ tok/s on a 4090.
• It is an always-think model: every answer ships with a <think> reasoning segment. That trait amplifies capability and token consumption in equal measure, as the results below will show.

Official model card comparisons (as of 2026-10-14):

Benchmark	LFM2.5-24B-A2B	Qwen3.6-35B-A3B	Note
IFEval instruction following	96.75	slightly lower	best in class
ToolSandbox tool use	80.71	slightly lower	best in class
LiveClaw agentic	48.09	slightly lower	best in class
MATH-500	96.04	comparable
GPQA Diamond knowledge	74.42	83.69	~9 points behind
SWE-Bench Verified	51.0	66.2	15 points behind

Credit where due: LiquidAI publishes its own weaknesses. The self-reported gaps in knowledge-heavy and complex software-engineering tasks matched what our field test found.

The license is Liquid LFM 1.0: commercial use permitted with conditions. Read it before production.

The Arithmetic of One RTX 4090

I went with a llama.cpp nightly build (b11609, published 2026-10-14; the new lfm2moe architecture was supported the day the weights landed) plus the official GGUF. The quantization menu:

Quant	Size	24GB card	Note
BF16	48 GB	needs offload	feasible with 192GB RAM
Q8_0	25.49 GB	does not fit	32GB cards
Q6_K	19.69 GB	very tight	little headroom
Q5_K_M	17.03 GB	workable	some headroom
Q4_K_M	14.53 GB	recommended	used in this test
QAD-Q4_0	13.58 GB	for 16GB cards	quantization-aware distilled

At Q4_K_M, total VRAM occupancy measured about 17.5GB including KV cache and compute buffers for a 32K context, with a browser and assorted resident apps still running. One command starts the server:

llama-server -m LFM2.5-24B-A2B-Q4_K_M.gguf -ngl 99 -c 32768 --jinja --port 8080

The recommended sampler settings (temperature 0.1, top_k 50, repetition_penalty 1.05) are embedded in the GGUF metadata and applied by default, which saves a documentation lookup. Model load took 6.5 seconds, respectable for 14.5GB of weights.

The real friction, on a network behind the Great Firewall, was the download itself: the 14.5GB file stalled twice on dead connections across direct and mirrored endpoints. What worked was a curl resume loop alternating between two sources, finishing in roughly 50 minutes. If you are reproducing this, start with that approach; single-stream downloaders will waste your evening.

Production Code as the Exam

The best way to evaluate whether a model can do the work is to hand it your own work. All 11 questions came from the multi-agent video-authoring canvas we maintain in production (I wrote up that system's architecture in Generative Canvas Agent Architecture). The exam includes defects that actually happened in production, sub-agent modules rebuilt against real assertion suites, and creative-writing tasks.

Three controls kept the results honest:

1. Machine grading. The model's code gets executed: the bug-fix answer runs against six assertions including the boundary case that triggered the original defect; the implementation task runs against ten; the slot-allocation answers are checked against ground truth produced by running the production function itself. No reviewer opinions involved.
2. Same prompt, two models. Local LFM2.5-24B-A2B and cloud GLM-5.3 received verbatim-identical prompts, answers rendered side by side. GLM-5.3 is a larger flagship serving as a quality ceiling, not a same-class competitor.
3. Full reasoning transcripts archived. For an always-think model the chain of thought is audit material, and the failure cases are where it pays off.

The Scoreboard

Batch 1: Engineering, 3/3

The most telling question involved a real production defect in a board-segment pruner: completed.slice(-keepCompletedCount) when keepCompletedCount is zero. In JavaScript, slice(-0) equals slice(0) and returns the whole array instead of an empty one. That trap lived in production for a long time before a boundary test caught it. LFM2.5 found it by reading the code alone, and the fix passed all six assertions. The assertion-driven state-machine rebuild scored 10/10 and the scenario-reasoning case 3/3. Batch 1: even with GLM-5.3.

Batch 2: Sub-Agent Specialization, Polarized

This batch mirrored day-to-day agent work, and the split was informative:

• Tool-call orchestration: 8/8, perfect. Asked to swap the second reference image while keeping it in slot two, it disconnected the old edge first, then connected the new source with an explicit slot: 1 (omitting it defaults to 0 and would evict the first image), invented no source_handle, deleted no nodes. Parameter-contract discipline was the best of the batch.
• The veto gating state machine: 5/5 plus all four semantic points. It articulated why the first veto stays inside the segment while the second escalates to the orchestrator, and why the sound-route question must be resolved by table lookup before any model judgment, because the cost of a wrong block is a deadlock that never raises an error.
• The decision-JSON extractor: 7/9. It fell into a classic off-by-one: scanning from just after the opening brace while initializing depth to zero instead of one, so the scanner closes early whenever text follows the object. It failed precisely the test case replicating the original production incident, where a greedy regex had wrecked 19 of 22 parses in one session.
• Slot-allocation exact returns: 4/5. It missed the branch where an already-wired source should return existingHandle.

Batch 3: Creative Writing, Stratified

• Video-node directive: 7/7, even with GLM-5.3. One Chinese paragraph of 80–150 characters covering action, camera, and light, no spell-word padding, no template stubs. Directly usable as node input. For "writing inside a spec," it is already good.
• Prose: 4/5, weak texture. Both models missed the length floor (573 vs 541 characters; neither reached 600), so constraint discipline was even. The craft gap was obvious: LFM2.5 fired nine consecutive similes and left no human anchor you remember; GLM produced details like a "maybe-later" folder unopened for three years.
• Flash fiction: 5/5 compliant, flat narrative. Its foreshadowing was a replay: the worn pen from the opening reappears at the end without gaining meaning. GLM made a watch running five minutes slow pay off properly.
• 15-second storyboard JSON: 6/7. Structurally valid (durations sum, narration rate, camera vocabulary), but the narration perspective drifted: grandma's first person for the first two shots, then silently the listener's for the last two, violating the stated constraint that narration transcribes grandma's voice messages, and every line was a complete sentence where the brief demanded sentences that trail off. For storyboard applications that is a real risk.

Speed

Across all 11 questions, generation throughput held at 224–257 tok/s, with prompt processing peaking around 7,900 tok/s. The official reference point is 184 tok/s on an Apple M5 Max (model card, 2026-10); a desktop 4090 comes out a notch faster, and the 2.45B active parameters per token show up exactly where you would expect.

The always-think trait needs its own line item: chains of thought ran 13,000–22,000 characters per question, several times the visible answer. Two questions burned the entire 8192-token budget on thinking and returned an empty visible answer until the budget was raised to 16384. Any system built on this model must monitor that metric, or users will see a model that thinks a lot and says nothing.

Multi-Dimensional Scoring

Dimension	Score	Basis (all measured 2026-10-14 unless noted)
Deployment friendliness	9/10	Full official GGUF lineup, embedded sampler params, day-one llama.cpp support
Single-GPU interactive speed	9/10	224–257 tok/s @ RTX 4090 Q4_K_M, 6.5s load
Agentic / tool orchestration	9/10	Orchestration 8/8, gating semantics 5/5 + 4/4 points
Fine-grained implementation	6/10	Brace-scan off-by-one, missed slot branch
Long-form Chinese writing	5/10	Compliant but simile-stacked, foreshadowing never lands, narration drifts
Knowledge-heavy tasks	6/10	Self-reported GPQA 74.42, ~9 behind peers (from model card, not re-measured)

Conclusion

LFM2.5-24B-A2B is the best single-card experience I have tested in the 24B class: one command to a working server, 200+ tok/s responses, 131K context, and an official ecosystem covering every format. Its capability profile is unusually legible. Hand it:

• Local Copilot duty and tool orchestration. Parameter-contract discipline and spec comprehension are first-tier for the parameter class, consistent with the self-reported ToolSandbox 80.71.
• Offline batch work and privacy-sensitive data. Fully local inference; 192GB of RAM opens the door to higher quants or even BF16 with offload.
• Short copy inside a spec (video prompts, schema'd scripts), where its usable-output rate already approaches cloud flagships.

Equally clear is what to keep away from it: long-form writing that needs a human touch (brand prose, storylines, finalized narration) and unattended generate-and-run code scenarios. The former belongs to cloud flagships or humans; the latter requires assertion-based guardrails, the same conclusion we reached in Why AI Video Remake Pipelines Keep Breaking: verifiable constraints beat model self-discipline. And its always-think format means every output ships with a full reasoning audit trail. Used well, that is a free explainer; used carelessly, the token bill and the response latency will remember for you.

Readers with 16GB cards: the official QAD-Q4_0 (13.58GB, quantization-aware distilled) is built for you.

References

1. LiquidAI — LFM2.5-24B-A2B model card (released 2026-10-12, accessed 2026-10-14)
2. LiquidAI — LFM2.5-24B-A2B-GGUF official quantization repo
3. ggml-org — llama.cpp Releases (b11609, 2026-10-14)
4. LiquidAI — Liquid LFM 1.0 License
5. Galen Guan — Generative Canvas Agent Architecture (this site)
6. Galen Guan — Why AI Video Remake Pipelines Keep Breaking (this site)