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

Liquid AI released LFM2.5-24B-A2B, a 24B-parameter reasoning model with only 2B active parameters per token, designed to run fast, private agents on local hardware. The model matters because it makes continuous agentic reasoning affordable on-device: each chain-of-thought token is cheap, and the model is competitive with mixture-of-experts models that have roughly 50% more total and active parameters.

The model is open-weight and available on Hugging Face alongside a base variant, LFM2.5-24B-A2B-Base.

What LFM2.5-24B-A2B is

LFM2.5-24B-A2B is a 24B-parameter reasoning model with 2B active parameters, built for fast, private agents on-device. It thinks before it answers, calls tools, and works through multi-step tasks inside popular agent harnesses.

Because only 2B parameters are active per token, each reasoning token is cheap, which allows agents to run continuously on the user's own hardware. Unlike its predecessor LFM2-24B-A2B, it is a reasoning-only model that produces an explicit chain of thought before its final answer.

Liquid AI summarizes the model's three headline properties as:

Best-in-class agent: competitive with Qwen3.6-35B-A3B, a model with ~50% more total and active parameters, on agentic and tool-use tasks, scoring 48.09 on LiveClaw versus 38.19.
Reasoning at MoE speed: the model always thinks before it answers, and with only 2B active parameters per token, each reasoning token is cheap.
Efficient inference: 184 tok/s on an Apple M5 Max and up to 21K output tok/s on a single NVIDIA B300 GPU.

Architecture and training recipe

LFM2.5-24B-A2B builds on LFM2-24B-A2B and keeps that model's architecture: 40 layers, 64 experts per MoE block with top-4 routing, and the same hybrid of gated short convolutions and grouped-query attention (GQA).

Two changes distinguish it from its predecessor:

The context window grows from 32K to 131K tokens.
An in-place tokenizer expansion doubles the vocabulary from 65K to 128K tokens for better non-Latin tokenization.

Pre-training was scaled up from ~17T to ~33T tokens. Mid-training then adds 2T tokens at 32K context, weighted toward reasoning, math, code, instruction following, and multilingual text, plus 300B tokens at 131K context, weighted toward long-context data. Tool calls and multi-turn trajectories appear throughout both phases.

Post-training turns the base model into an agent in five stages:

Supervised fine-tuning (SFT)
Teacher specialization
Multi-domain on-policy distillation (MOPD), non-agentic: distill the specialist teachers on non-agentic tasks
MOPD, agentic: a second distillation stage focused on agentic tasks
Agentic reinforcement learning (Agentic RL): train the model inside agent harnesses such as OpenClaw, Hermes Agent, Pi, and OpenCode

Benchmark results

Liquid AI evaluated LFM2.5-24B-A2B 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. It is the smallest model in the group, yet it is competitive with MoEs that have ~50% more total and active parameters.

Benchmark	LFM2.5-24B-A2B	Qwen3.6-35B-A3B	Gemma-4-26B-A4B-it	Nemotron-3.5-Lightning (30B-A3B)
AutomationBench	27.69	8.72	5.46	2.61
BFCLv4	65.01	65.00	57.09	53.78
ToolSandbox	80.71	75.02	72.09	75.13
LiveClaw	48.09	38.19	41.25	37.72
PinchBench	83.18	89.93	77.12	84.20
τ³-Bench Banking	8.04	7.63	4.54	7.01
WebArena Verified	26.75	37.62	25.62	28.69
GPQA Diamond	74.42	83.69	74.90	72.42
AA-Omniscience	-24.90	-24.35	-59.39	-3.58
HLE	7.40	7.69	8.57	5.65
IFEval	96.75	93.06	92.00	94.19
IFBench	74.69	64.21	47.44	71.67
Multi-IF	84.38	81.53	82.19	82.34
MATH-500	96.04	96.73	95.66	96.40
SWE-Bench Verified (OpenCode)	51.00	66.20	25.80	53.40
SciCode	32.71	37.35	35.42	27.78

All models were evaluated with vLLM, using each benchmark's recommended generation parameters.

Where the model is strongest

For applications, the strengths are tool use and instruction following. LFM2.5-24B-A2B leads or matches the competition on five of the eight tool-use and agentic benchmarks — AutomationBench, BFCLv4, ToolSandbox, LiveClaw, and τ³-Bench Banking — and on AutomationBench it scores more than three times the next-best model. It also leads on all three instruction-following benchmarks (IFEval, IFBench, and Multi-IF).

Where larger models still win

Larger models keep an edge on knowledge-heavy benchmarks such as GPQA Diamond, HLE, and AA-Omniscience, and on coding benchmarks such as SWE-Bench Verified (OpenCode) and SciCode. Liquid AI's guidance is to pair LFM2.5-24B-A2B with retrieval or web search for knowledge-heavy workloads.

Inference speed on CPU and GPU

LFM2.5-24B-A2B ships with day-one support across the inference ecosystem, including llama.cpp, MLX, vLLM, SGLang, and ONNX.

Edge inference. LFM2.5-24B-A2B is the fastest of the compared MoEs, decoding 184 tokens/s on an M5 Max and 114 tokens/s on a Ryzen AI Max+ 395. That is up to 1.7x faster than the next-best model, while using the least memory.

GPU inference. LFM2.5-24B-A2B is the fastest model in its size class, reaching over 21K output tokens per second at high concurrency on a single B300.

How to run LFM2.5-24B-A2B

Load it with transformers

Install the latest version of transformers (compatible with transformers>=5.0.0):

pip install -U transformers

Then load and run the model:

from transformers import AutoModelForCausalLM, AutoTokenizer, TextStreamer

model_id = "LiquidAI/LFM2.5-24B-A2B"
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    device_map="auto",
    dtype="bfloat16",
#   attn_implementation="flash_attention_2" <- uncomment on compatible GPU
)
tokenizer = AutoTokenizer.from_pretrained(model_id)
streamer = TextStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)

prompt = "What is C. elegans?"

input_ids = tokenizer.apply_chat_template(
    [{"role": "user", "content": prompt}],
    add_generation_prompt=True,
    return_tensors="pt",
    tokenize=True,
)["input_ids"].to(model.device)

output = model.generate(
    input_ids,
    do_sample=True,
    temperature=0.1,
    top_k=50,
    repetition_penalty=1.05,
    max_new_tokens=512,
    streamer=streamer,
)

Point an agent harness at it

Serve LFM2.5-24B-A2B locally behind any OpenAI-compatible backend, then point your agent harness at it. For example, with Hermes Agent:

hermes config set model.provider custom
hermes config set model.base_url http://localhost:8080/v1
hermes config set model.default LFM2.5-24B-A2B
hermes config set model.context_length 131072
hermes config set model.api_mode chat_completions
hermes config set agent.tool_use_enforcement true

The port depends on the serving backend: llama.cpp and MLX use 8080, vLLM uses 8000, SGLang uses 30000, and LM Studio uses 1234. The model card documents OpenClaw and Pi configurations, and Liquid AI publishes a guide covering the full local agent setup.

Availability and getting started

Both LFM2.5-24B-A2B and LFM2.5-24B-A2B-Base are open-weight and available on Hugging Face.

Download: LFM2.5-24B-A2B-Base and LFM2.5-24B-A2B on Hugging Face.
Use in your harness: Liquid AI's guide covers running a local agent such as OpenClaw, Hermes Agent, and Pi.
Fine-tune: Liquid AI publishes fine-tuning tutorials in its cookbook for adapting LFM2.5-24B-A2B to a specific task.

What this means for on-device agents

LFM2.5-24B-A2B targets a specific trade-off: a reasoning model whose chain of thought is cheap enough to run continuously on local hardware. The 2B active parameter count keeps per-token cost low, the 131K context window supports long multi-turn agent trajectories, and the agentic RL stage trains the model inside real harnesses rather than only on static data.

The trade-off is explicit in the benchmark table: the model is strongest on tool use and instruction following, and weaker than larger models on knowledge-heavy and coding benchmarks. Liquid AI's own recommendation is to pair it with retrieval or web search when knowledge is the bottleneck.