LFM2.5-24B-A2B: Liquid AI's Open 24B Agent Model With Only 2B Active

Liquid AI has released LFM2.5-24B-A2B, an open-weight reasoning model with 24 billion total parameters and only about 2 billion active per token, aimed squarely at agents that run on your own laptop or workstation. According to the Liquid AI announcement on Hugging Face, it decodes at 184 tokens per second on an Apple M5 Max and scores 48.09 on the LiveClaw agent benchmark against 38.19 for the larger Qwen3.6-35B-A3B. The weights, plus a base model, are on Hugging Face today.

It is the next step after the company's smaller on-device models. If you followed LFM2.5-2.6B and the tiny LFM2.5-230M, this is the "bigger brain, same cheap tokens" tier.

TL;DR: LFM2.5-24B-A2B at a glance

Why does a 24B model with 2B active parameters matter?

In a mixture-of-experts (MoE) model, a router picks a few "expert" sub-networks for every token, so most of the weights sit idle on any given step. That is why a 24B model can cost about as much per token as a 2B one. The catch is memory: all 24B parameters still have to fit somewhere, so you need a machine with enough RAM or unified memory, even though the compute per token is small.

Liquid AI's argument is that reasoning models spend most of their tokens thinking, so cheap tokens matter more than raw parameter count. An agent that loops through plan, tool call, observe, and retry can burn tens of thousands of tokens on a single task. When each token is cheap and local, you can leave that agent running continuously without a metered API bill and without sending files to a third party.

That is the same economic logic behind other recent local-first releases we have covered, such as MiniCPM-V 4.7 35B-A3B and the experiment of streaming MoE experts from an SSD. It also connects to the debate over whether phones will really run huge models, which we looked at in Qualcomm's 100B-parameter claim.

What changed from LFM2-24B-A2B?

Liquid AI says LFM2.5-24B-A2B keeps the architecture of its predecessor: 40 layers, 64 experts per MoE block with top-4 routing, and a hybrid of gated short convolutions and grouped-query attention (GQA). Most layers use short convolutions, which are cheap and keep memory growth low, while a minority use attention for long-range lookup. That hybrid is the core Liquid design idea and the reason its models are small and fast for their capability.

What did change, per the announcement:

• Context: 32K to 131K tokens.
• Tokenizer: an in-place expansion that doubles the vocabulary from about 65K to 128K tokens, which should help non-Latin languages.
• Pre-training: scaled from roughly 17T to roughly 33T tokens.
• Mid-training: 2T extra tokens at 32K context weighted toward reasoning, math, code, instruction following and multilingual text, then 300B tokens at 131K context weighted toward long-context data. Tool calls and multi-turn trajectories appear in both phases.
• Behavior: it is now a reasoning-only model that writes an explicit chain of thought before the final answer.

How was it trained to be an agent?

Post-training is the interesting part. Liquid AI describes a multi-stage recipe: multi-domain on-policy distillation (MOPD) from specialist teachers on non-agentic tasks, a second MOPD stage focused on agentic tasks, then agentic reinforcement learning run inside real harnesses, named as OpenClaw, Hermes Agent, Pi and OpenCode. Training in the actual tool-calling loops that users will run is a deliberate choice: many small models look fine on isolated function-calling tests and then fall apart inside a long agent session.

If you want background on those harnesses, see our guides to OpenClaw and the Hermes Agent vs OpenClaw comparison.

What do the benchmarks say?

Agent tool belt illustrating tool-use benchmarks for LFM2.5-24B-A2B

Liquid AI evaluated the model against Qwen3.6-35B-A3B, Gemma-4-26B-A4B-it and Nemotron-3.5-Lightning on 16 benchmarks covering tool use and agentic workflows, knowledge, instruction following, math and coding. All models were run with vLLM using each benchmark's recommended generation parameters. The company notes LFM2.5-24B-A2B is the smallest model in the group.

Two cautions apply. First, these are the vendor's own numbers, with a comparison set the vendor chose, so treat them as a strong claim to reproduce rather than a settled ranking. Second, Liquid itself says to pair the model with retrieval or web search for knowledge-heavy work. It is a tool-calling specialist, not a general oracle. We have not independently run these benchmarks.

For comparison with the earlier family: the 2.6B model reported 77.83 on ToolSandbox in our LFM2.5-2.6B coverage. The new post does not restate a ToolSandbox figure in the text we reviewed, so we do not compare the two directly.

How fast is it, really?

Wrench and gear pair representing inference speed and tool calling in LFM2.5-24B-A2B

Liquid AI's speed claims:

The company says that on edge hardware it is up to 1.7x faster than the next-best model in its comparison while using the least memory, and the fastest in its size class on the B300. Real numbers depend on quantization, context length, and the runtime, so expect lower speeds at long contexts and on weaker chips. If you are weighing local hardware for this class of model, our write-up of the NVIDIA RTX Spark ecosystem covers one route.

How do I run LFM2.5-24B-A2B locally?

There are two paths.

Directly with transformers. Liquid AI says to install a recent transformers (version 5.0.0 or newer) and load the model with AutoModelForCausalLM and AutoTokenizer, with a TextStreamer for token streaming. The model card includes the exact snippet, and flash attention can be enabled on compatible GPUs.

Behind an OpenAI-compatible server, pointed at an agent. This is the path most readers want. Serve the model with any compatible backend and set your harness's base URL to it. Per the announcement, default ports are:

The model card carries ready configs for OpenClaw and Pi, and the announcement shows Hermes Agent as the worked example. Liquid also links fine-tuning tutorials if you want to adapt the model to your own task.

A sensible first test

Rather than trusting leaderboard numbers, run a small private eval of your own: take ten real tasks from your workflow (renaming files, triaging an inbox export, calling two or three of your own tools), run them through this model and through whatever you use today, and compare success rate and wall-clock time. A model that wins on LiveClaw but fumbles your specific tool schemas is not the right model for you.

What are the limits and open questions?

• Memory footprint. 24B total parameters is far beyond a typical phone. Think laptops, mini-PCs and workstations with ample unified memory, not handsets.
• Reasoning-only. It always thinks first. That can add latency on simple queries and consume context, which matters when your agent already juggles many tool results.
• Knowledge and coding gaps. By Liquid's own admission, larger models lead on GPQA Diamond, HLE, AA-Omniscience, SWE-Bench Verified and SciCode.
• License. The Hugging Face metadata lists the license as "other". Open weights do not automatically mean permissive terms.
• Independent verification. At publication time the results are Liquid AI's. Community replications will tell us how well the numbers hold on other harnesses.

How does this fit the local agent trend?

Over the past months the open-model story has shifted from "can small models chat?" to "can they run an agent loop reliably?" Releases built around harnesses like OpenClaw and Hermes Agent, plus fast MoE routing, are the clearest sign. Liquid's pitch is that a hybrid convolution-attention design gets you more agent capability per watt than a pure transformer MoE of similar active size. Whether that holds beyond Liquid's chosen benchmarks is the thing to watch.

For builders, the practical question is cost and privacy. If an agent can handle your tool-use workload on hardware you already own, you remove per-token costs and keep sensitive data local. If it cannot, a frontier API remains the fallback, and you can route only the hard steps there.

Related reading

• LFM2.5-2.6B: Liquid AI's on-device agent model
• LFM2.5-230M: a 230M model for phones and robots
• MiniCPM-V 4.7 35B-A3B on-device MoE
• Running MoE models larger than RAM from SSD
• Qualcomm's 100B-parameter phones claim, checked
• Hermes Agent vs OpenClaw
• Liquid AI model card on Hugging Face

Figures and specs are as reported by Liquid AI on October 13, 2026 and may change as the model card and independent tests evolve.