Liquid AI's LFM2.5-24B-A2B: 24B parameters, 2B active — agents move on-device

TL;DR: On October 13, 2026, Liquid AI released LFM2.5-24B-A2B — a reasoning model with 24B parameters where only ~2B are active per token (Mixture-of-Experts). On five of eight agentic and tool-use benchmarks it beats Qwen3.6-35B-A3B, a model roughly 50% heavier in both total and active parameters. Speed: 184 tokens/s on an Apple M5 Max, and up to 21,000 output tokens/s on a single NVIDIA B300. Weights are open on Hugging Face — both the base and the post-trained versions.

What exactly shipped

LFM2.5-24B-A2B is the largest and final model of the LFM2.5 family, which now spans two orders of magnitude: from the tiny LFM2.5-230M up to this 24B. The whole family targets one scenario — agents that run on the user’s device, not in someone else’s datacenter.

The design is mixture-of-experts: 24B parameters in total, but only about 2B are engaged per token. That’s the core trick: big-model quality at small-model inference cost. The license is LFM1.0, weights are open, the model handles 16 languages, and there’s an accompanying paper (arXiv: 2511.23404).

Benchmarks: fewer active parameters, more agentic punch

Liquid AI compares the new model against Qwen3.6-35B-A3B — a MoE with ~35B total and 3B active parameters, roughly 50% heavier on both counts. Across eight agentic and tool-use benchmarks, LFM2.5-24B-A2B wins five.

Two gaps stand out:

LiveClaw measures agentic behavior on live tasks; AutomationBench measures automation of real work processes. The AutomationBench gap is more than threefold: 27.69 versus 8.72. For a model one-and-a-half times smaller than its rival, that’s a strong result.

Speed: where this model actually lives

Thanks to the small active footprint, the model runs noticeably faster than comparable MoEs — Liquid AI claims up to 1.7× speedup on-device. Concrete numbers:

• 184 tokens/s on an Apple M5 Max — comfortably faster than reading speed, on a laptop;
• up to 21,000 output tokens/s on a single NVIDIA B300 — the server scenario, where the same model serves a stream of requests.

The asymmetry matters: 24B parameters need to live somewhere (tens of gigabytes at full precision, much less quantized), but each token only computes over a 2B-parameter slice. That makes the model realistic for high-end laptops and workstations — and out of reach for phones, where the smaller LFM2.5 models rule.

Why on-device agents at all

Demand for local agents comes from three sources, and we see all three in our own work.

Privacy. An agent reads your email, documents, code, chats. Sending all that to the cloud means trusting a provider not just with a model call, but with your entire digital life. A local model removes the question.

Money. An agent looping “think → call tool → think again” burns tokens in batches. A local model turns an API bill into an electricity bill.

Latency. Agent loops are sensitive to per-step latency: a hundred milliseconds to the cloud on every round compounds into seconds of waiting. Local inference answers instantly.

What makes LFM2.5-24B-A2B interesting is that it erases the main counter-argument for the first time: a local model used to mean a noticeably dumber model. Now a laptop-class model beats heavy MoEs on agentic tasks.

The caveats, honestly

Three things to keep in mind.

First, the benchmarks are vendor-reported — independent measurements are still pending. Second, Qwen3.6-35B-A3B wins three of the eight tests — this isn’t a total victory, it’s a new point on the price/quality map. Third, 24B parameters is still tens of gigabytes of weights: “on-device” here means a Mac Studio or a gaming PC, not a smartphone.

Why this is close to home

We build MaxGraph, a memory layer for AI agents — and we read this release as the missing half of an equation.

A local agent without memory is an intern with amnesia: every morning it shows up for its first day at work. An on-device model solves the privacy of computation, but not the privacy and continuity of the agent’s knowledge about you. If the agent’s memory lives in someone else’s cloud, the local model’s privacy is only half-done.

The pairing we see as the endgame of this trend: local model + local memory. The model thinks on your machine, the memory sits on your disk as a file, embedding search over it runs locally too. A fully private agent — not because you trust someone, but because there’s no one you need to trust. LFM2.5-24B-A2B makes the left half of that pairing real today.

FAQ

Where do I download and run it? Weights are on Hugging Face (base and post-trained), there’s a Liquid AI playground, plus docs on local inference and fine-tuning.

Will my laptop handle it? You need headroom for 24B parameters (much less when quantized). The claimed 184 tok/s is on an Apple M5 Max; weaker hardware will be slower, but the 2B active slice makes this one of the fastest models in its weight class.

Does it replace cloud frontier models? No. It replaces the middle class of cloud models in agentic scenarios — where speed, cost, and privacy matter more than the last percent of reasoning.

What does agent memory have to do with it? An agentic benchmark is by definition multi-step work with tools. An agent that doesn’t remember yesterday spends steps rediscovering what it already knew. Memory is the second most important multiplier of agent usefulness after the model itself.

What’s next

• Why local inference is also about money: our token savings benchmark.
• How hybrid memory search works: graph + vectors.
• Why agents forget — and what to do about it: the breakdown.