Liquid AI LFM2.5 is the clearest proof yet that the open-weight AI race has stopped being a contest of pure size. Released on October 13, 2026, this 24-billion-parameter reasoning model from Boston-based AI lab Liquid AI activates only 2 billion parameters for each token it generates — and still beats substantially larger models on tool-use and agentic benchmarks. If you want an AI agent that runs on your own laptop instead of a distant data center, Liquid AI LFM2.5 is the most important model release of the month.
In this guide, we explain exactly what Liquid AI LFM2.5 is, how its mixture-of-experts design works, what the benchmarks really show (all vendor-reported, with the caveats spelled out), how fast it runs on consumer hardware, and how you can download and run it yourself today. Because the weights are open, this is one of those rare launches anyone can verify independently — no API key, no waitlist, no trust-me marketing.
Key takeaways:
- Liquid AI LFM2.5 is an open-weight 24B reasoning model that uses just 2B active parameters per token.
- It leads or ties larger rivals on 5 of 8 tool-use and agentic benchmarks, including a 3x lead on AutomationBench.
- It runs at 184 tokens per second on an Apple M5 Max and 114 tokens per second on an AMD Ryzen AI Max+ 395.
- The model is free to download from Hugging Face with day-one support in llama.cpp, MLX, vLLM, SGLang, and ONNX.
- Bigger models still win on knowledge-heavy and coding benchmarks — this model is a specialist, not an all-rounder.
In This Guide
- What Is Liquid AI LFM2.5?
- Liquid AI LFM2.5: Full Specs and What Changed
- Liquid AI LFM2.5 Benchmarks: Beating Bigger Rivals
- Speed That Runs on Your Laptop
- How to Get Liquid AI LFM2.5
- Liquid AI LFM2.5 vs Qwen3.6-35B-A3B
- Who Should Use Liquid AI LFM2.5?
- Liquid AI LFM2.5 in the October 2026 Model Wave
- Limitations and Honest Caveats
- Liquid AI LFM2.5 FAQs
- The Bottom Line

What Is Liquid AI LFM2.5?
Liquid AI LFM2.5 is an open-weight mixture-of-experts (MoE) reasoning model released by Liquid AI, the Boston-based AI lab founded as an MIT spinout. The full model name is LFM2.5-24B-A2B, and it is the largest — and, by design, the most capable — entry in the LFM2.5 family, which Liquid AI spent this year aiming at one clear goal: making capable AI run locally on consumer hardware instead of in a distant data center.
The headline idea is a split personality. The model holds 24 billion parameters in total, but it activates only 2 billion of them per token. Think of it like a hospital: 24 billion parameters is the entire building, but for any single patient (token), only the 2-billion-parameter specialist team walks into the room. The rest stays idle. That routing decision is what makes the speed and efficiency numbers possible, and it is the core of why this release matters.
It is also a reasoning model in the strict sense: it always produces a chain of thought before answering, which means it thinks through multi-step problems step by step instead of blurting out the first plausible answer. On top of that, it was trained to call tools — running code, querying APIs, browsing files — and to handle the kind of long, multi-step agent workflows that define real work in 2026: triaging an inbox, researching a topic across dozens of pages, or driving a coding agent through a multi-file refactor.
The “2B Active” Idea, Explained Simply
Most people hear “24 billion parameters” and picture a giant that needs a data center. LFM2.5 breaks that link. Its architecture uses 40 transformer layers, and inside the mixture-of-experts blocks there are 64 specialist “expert” networks. For every token, a router picks just the top 4 experts to consult. That is the A2B in the name: 2 billion active out of 24 billion total.
Why does this matter to you? Because the active parameter count — not the total — is what determines the practical cost of running the model. Memory footprint, tokens per second, and battery drain all track the 2 billion that actually compute, not the 24 billion sitting on disk. That is why the model can hit speeds that used to require a cloud API while living entirely on a high-end laptop.
Liquid AI LFM2.5: Full Specs and What Changed
It keeps the architecture of its predecessor, LFM2-24B-A2B, but upgrades nearly every number that counts:
- Parameters: 24 billion total, 2 billion active per token (MoE, 40 layers, 64 experts per block, top-4 routing).
- Context window: 131,000 tokens, up from 32K in the previous generation — enough to hold a full codebase or a long research dossier in one pass.
- Vocabulary: 128,000 entries, doubled from 65K, which notably improves handling of non-Latin text.
- Languages: 16 languages supported.
- Pre-training: roughly 33 trillion tokens, up from about 17 trillion.
- Post-training: agentic reinforcement learning run inside real agent harnesses — OpenClaw, Hermes Agent, Pi, and OpenCode — so the model learned tool use by doing tool use, not by reading about it.
- Versions: the full LFM2.5-24B-A2B reasoning release plus an LFM2.5-24B-A2B-Base version, both open-weight on Hugging Face.
- Runtime support: day-one support in llama.cpp, MLX, vLLM, SGLang, and ONNX; the Python example requires transformers version 5.0.0 or later.
The post-training detail is the one most people will underestimate. Training inside agent harnesses means the model was reinforced on the messy loop of real agent work — calling a tool, reading the result, adjusting, calling another — rather than on single-turn question answering. That is a big reason it punches above its weight on the agentic benchmarks below.
How Liquid AI LFM2.5 Compares to LFM2
Generation over generation, the pattern is clear: same expert architecture, dramatically larger window and training diet. The context window quadrupled, the vocabulary doubled, and pre-training data nearly doubled. The active-parameter count stayed at 2 billion, which tells you where Liquid AI thinks the leverage is: not in lighting up more parameters per token, but in teaching the same efficient core more of the world and giving it a longer memory.

Liquid AI LFM2.5 Benchmarks: Beating Bigger Rivals
Here is the important honesty note, stated up front: every benchmark number below comes from Liquid AI’s own testing, run on vLLM with each benchmark’s recommended generation settings. They are not independently verified — but because Liquid AI LFM2.5 is open-weight, anyone can download it and re-run the tests. That verifiability is a genuine advantage over closed-model claims.
Liquid AI compared the new model against three larger rivals — Alibaba’s Qwen3.6-35B-A3B (35B total, 3B active), Google’s Gemma-4-26B-A4B-it, and NVIDIA’s Nemotron-3.5-Lightning (30B-A3B) — across 16 benchmarks. The headline result: on five of the eight tool-use and agentic benchmarks, it matches or leads the competition.
Tool-Use and Agentic Benchmarks: Where Liquid AI LFM2.5 Wins
- AutomationBench: 27.69 for Liquid AI LFM2.5 versus 8.72 for Qwen3.6-35B-A3B — more than three times the next-best score in the comparison. This is the standout result of the release.
- LiveClaw: 48.09 versus 38.19 for Qwen3.6-35B-A3B, a decisive lead on an agent-harness benchmark that mirrors real agent workflows.
- BFCLv4, ToolSandbox, and τ³-Bench Banking: Liquid AI LFM2.5 matches or leads across this set, covering function calling, tool-use sandboxes, and multi-turn banking tasks.
- Instruction following: it leads on all three instruction-following benchmarks — IFEval (96.75), IFBench (74.69), and Multi-IF — which matters because agents live or die by following multi-constraint instructions exactly.
Put plainly: for the work of calling tools, following instructions, and chaining steps into completed tasks, a 2-billion-active-parameter model is outperforming models with 50% more active parameters. That is the specialist-fragmentation story the whole open-weight market is living through right now.
Where Bigger Models Still Win
Liquid AI LFM2.5 is not an all-rounder, and the honest comparison admits it. The larger rivals keep a clear edge on knowledge-heavy benchmarks — GPQA Diamond (74.42 versus 83.69 for Qwen3.6-35B-A3B), HLE, and AA-Omniscience — and on coding benchmarks, including SWE-Bench Verified run through OpenCode (51.00 versus 66.20) and WebArena Verified (26.75 versus 37.62), plus SciCode.
Liquid AI’s own advice for these weaknesses is refreshingly practical: pair the model with retrieval or web search for knowledge-heavy work. In other words, do not ask the 2B-active brain to memorize the internet — give it tools to look things up, which is exactly what an agent framework does anyway. Played to its strengths (tools + instructions), Liquid AI LFM2.5 wins; asked to be an encyclopedia, it loses. Choose accordingly.

Speed That Runs on Your Laptop
Benchmarks tell you what a model can do; speed tells you whether you will actually use it. Liquid AI positioned the active-parameter count as the practical selling point for exactly this reason: because only 2B parameters compute per token, each reasoning token is cheaper to run, which the company says makes it feasible to run agents continuously on local hardware rather than through a cloud API.
The company-reported edge-inference numbers:
- 184 tokens per second on an Apple M5 Max — fast enough that long reasoning chains feel instant.
- 114 tokens per second on an AMD Ryzen AI Max+ 395.
- Up to 1.7x faster than the next-best compared model on edge devices, while consuming the least memory of the group.
For server-side deployments, the numbers scale too: Liquid AI reports over 21,000 output tokens per second at high concurrency on a single NVIDIA B300 GPU. That combination — laptop-class on the edge, serious throughput on a single datacenter GPU — is why the model works both for a developer’s local agent and for a team serving thousands of agent sessions.
Why On-Device Speed Is a Privacy Story Too
A model that can run an agent entirely locally removes an entire category of data-residency questions that API-based deployment cannot avoid. Your documents, code, emails, and customer data never leave the machine. For US businesses in healthcare, finance, legal, and government contracting, that is not a nice-to-have — it is often the difference between being allowed to use an AI agent and not. Liquid AI LFM2.5 makes the local option genuinely competitive for the first time at this capability level.

How to Get Liquid AI LFM2.5
Getting Liquid AI LFM2.5 is refreshingly simple for a frontier-adjacent release: there is no waitlist and no API key required to start.
- Download the weights: both LFM2.5-24B-A2B and the LFM2.5-24B-A2B-Base version are open-weight on Hugging Face. Check the model card there for the exact license terms before commercial use.
- Pick your runtime: the release has day-one support in llama.cpp, MLX (for Apple Silicon), vLLM, SGLang, and ONNX. Use whichever your hardware and stack already favor.
- Python quickstart: Liquid AI’s example requires transformers version 5.0.0 or later — make sure your environment meets that before you start.
- Plug it into an agent harness: because the model was post-trained inside OpenClaw, Hermes Agent, Pi, and OpenCode, those harnesses are the natural first homes for it. Point the harness at your local endpoint and let it drive tools.
- Prefer hosted? Liquid AI also offers API integration for teams that want the model without managing GPUs — see the official announcement for details.
One practical note: 24 billion total parameters still needs real memory to load (the full weights must sit somewhere), even though only 2B compute per token. High-end consumer laptops and workstations are the target; a thin ultrabook with 8GB of RAM is not. Match the quantization to your hardware — the community around llama.cpp and MLX typically ships workable quantizations within days of a release like this.

Liquid AI LFM2.5 vs Qwen3.6-35B-A3B
The most informative comparison in Liquid AI’s release is against Alibaba’s Qwen3.6-35B-A3B — a model with 35B total parameters and 3B active per token, i.e., bigger on both counts. Here is how they stack up on the numbers Liquid AI published:
| Metric | Liquid AI LFM2.5 | Qwen3.6-35B-A3B |
|---|---|---|
| Total / active parameters | 24B / 2B | 35B / 3B |
| AutomationBench | 27.69 | 8.72 |
| LiveClaw | 48.09 | 38.19 |
| IFEval / IFBench | 96.75 / 74.69 | Lower (trails) |
| GPQA Diamond | 74.42 | 83.69 |
| SWE-Bench Verified (OpenCode) | 51.00 | 66.20 |
| WebArena Verified | 26.75 | 37.62 |
| Edge speed (best reported) | 184 tok/s (M5 Max) | Slower (up to 1.7x gap) |
| Memory footprint | Lowest of compared group | Higher |
| Weights | Open-weight (HF) | Open-weight (HF) |
The pattern is unmistakable: LFM2.5 wins the agent race — tools, instructions, speed, memory — while Qwen3.6-35B-A3B wins the knowledge and coding race. Neither is “better” in the abstract. The right question is what your workload looks like: if your agents spend their time calling tools and following multi-step instructions, the model is the efficiency pick; if they spend it recalling obscure facts or writing complex code from scratch, the bigger model earns its keep.
Who Should Use Liquid AI LFM2.5?
It is not trying to be everything to everyone. It is a specialist, and specialists reward the right buyer. Here is who gets the most from it:
Agent and Automation Developers
If you build with OpenClaw, OpenCode, or similar harnesses, the model was literally post-trained in your environment. It is the rare model whose training distribution matches your deployment distribution. Local inference means your agent loops run with single-digit-millisecond latency instead of API round-trips — the difference between an agent that feels alive and one that feels like watching paint dry.
Privacy-Sensitive Teams and Regulated Industries
Healthcare, finance, legal, and government-adjacent work often cannot send data to a third-party API. This model gives those teams a genuinely capable agent brain that never lets data leave the building. Download the weights, run them on your own hardware, and the entire data-residency conversation gets much shorter.
Indie Hackers and Cost-Conscious Builders
API bills are the silent killer of agent startups: every reasoning step, every tool call, every retry costs tokens. A local copy of the model turns that variable cost into a fixed one — the hardware you already own. For prototypes, internal tools, and always-on background agents, the economics are hard to beat: the weights are free to download.
Who Should Look Elsewhere
If your workload is knowledge-heavy Q&A without retrieval, or competitive-level code generation, the benchmark table above says the bigger models still win. Also, if you have no local GPU or Apple Silicon hardware and no interest in managing inference, a hosted API model remains the simpler path — Liquid AI offers API access for exactly that case.
Liquid AI LFM2.5 in the October 2026 Model Wave
Context makes this release bigger than itself. Benchmark tracker BenchLM counts 22 confirmed model launches in October 2026 alone, pushing its leaderboard past 221 tracked models. It landed on October 13 — two days before Meta’s 816-billion-parameter Muse Spark Open and NVIDIA’s Nemotron 3.5 arrived on October 15, the same day the UAE’s Institute for Machine Intelligence shipped six variants of its Jais 3 family.
That timing is the story. A 24B model launching 48 hours before an 816B model — and still being the more interesting release for agent builders — is the clearest signal yet that the open-weight market is fragmenting into specialists rather than racing to the biggest parameter count. Efficiency, not sheer size, is becoming the valuable currency. Compare that with the other efficiency bet of the month, Nvidia-backed Elorian Glimpse with its visual-reasoning scratch space: the frontier is no longer one race but several, and Liquid AI LFM2.5 is winning the on-device agent heat.
Limitations and Honest Caveats
No honest review skips the weak spots. Here they are, plainly:
- Vendor-reported benchmarks: every number in this article comes from Liquid AI’s own testing. The methodology is documented (vLLM, each benchmark’s recommended settings), and open weights make independent verification possible — but treat the numbers as the company’s best case until third parties re-run them.
- Knowledge and coding gaps: as shown above, bigger rivals lead on GPQA Diamond, HLE, SWE-Bench Verified, and WebArena. Do not deploy Liquid AI LFM2.5 as a standalone knowledge oracle.
- Hardware floor: “runs on a laptop” means a capable laptop. The full 24B weights still need substantial RAM/VRAM to load, even in quantized form.
- License check required: “open-weight” is not one license. Read the Hugging Face model card’s license terms before commercial deployment.
- Young ecosystem: released October 13, 2026 — community quantizations, fine-tunes, and harness integrations are still catching up. Early adopters should expect some rough edges.
Liquid AI LFM2.5 FAQs
Is Liquid AI LFM2.5 free?
Yes — Liquid AI LFM2.5 is open-weight and free to download from Hugging Face, in both the full reasoning version and a Base version. You can run it locally at no licensing cost, though you should check the model card for the exact license terms before commercial use. Liquid AI also offers hosted API access for teams that prefer not to manage their own GPUs.
Can Liquid AI LFM2.5 run on a laptop?
That is its headline design goal. Liquid AI reports 184 tokens per second on an Apple M5 Max and 114 tokens per second on an AMD Ryzen AI Max+ 395, with the lowest memory footprint among the models it compared. You will need a capable machine with enough RAM/VRAM to hold the 24B weights (quantized versions help), but no data center is required.
How does Liquid AI LFM2.5 compare to Qwen3.6-35B-A3B?
Despite being smaller (24B/2B vs 35B/3B), it beats Qwen3.6-35B-A3B on tool-use and agentic benchmarks — 27.69 vs 8.72 on AutomationBench and 48.09 vs 38.19 on LiveClaw — plus all three instruction-following benchmarks. Qwen3.6-35B-A3B fights back on knowledge-heavy tests (GPQA Diamond 83.69 vs 74.42) and coding (SWE-Bench Verified 66.20 vs 51.00). All figures are vendor-reported by Liquid AI.
Where can I download Liquid AI LFM2.5?
From Hugging Face, where Liquid AI published both LFM2.5-24B-A2B and LFM2.5-24B-A2B-Base. The release includes day-one support for llama.cpp, MLX, vLLM, SGLang, and ONNX, and the Python example needs transformers 5.0.0 or later. See the official Liquid AI announcement for links and integration details.
Is Liquid AI LFM2.5 good for coding?
It is decent but not chart-topping. It scored 51.00 on SWE-Bench Verified via OpenCode against 66.20 for Qwen3.6-35B-A3B, so bigger models still lead at raw code generation. Where Liquid AI LFM2.5 shines for developers is agentic coding workflows — driving tools, following multi-step instructions, and iterating inside harnesses like OpenCode, where it was post-trained. For a deeper look at the launch data, see this detailed LFM2.5 specs and benchmark breakdown.
The Bottom Line
Liquid AI LFM2.5 is the most important efficiency story of October 2026: a 24-billion-parameter model that only ever uses 2 billion of them, beats bigger rivals where agents actually work (tools, instructions, speed), and runs on hardware you already own. It is not the best model at everything — knowledge-heavy and coding benchmarks still belong to larger models — but it was never trying to be. It is trying to be the model that finally makes capable AI agents local, private, and cheap to run. On that mission, the benchmarks say it is winning. Download it, run it, and verify the claims yourself — that is the whole point of open weights.
