LFM2.5-24B-A2B brings fast, private agent execution to local devices

LFM2.5-24B-A2B brings fast, private agent execution to local devices

Published October 13, 2026

LFM2.5-24B-A2B is a 24B-parameter reasoning model with 2B active parameters. It is designed for fast, private agents running on local hardware. The model reasons before answering, supports tool calls, and handles multi-step tasks through agent harnesses.

Because only 2B parameters are active for each token, reasoning tokens require relatively little computation, allowing agents to run continuously on local systems.

Key results include:

• Agent performance: LFM2.5-24B-A2B scores 48.09 on LiveClaw, compared with 38.19 for Qwen3.6-35B-A3B, which has approximately 50% more total and active parameters.
• Reasoning with a mixture-of-experts architecture: The model consistently reasons before producing its final answer while activating only 2B parameters per token.
• Inference speed: It reaches 184 tokens per second on an Apple M5 Max and up to 21K output tokens per second on a single NVIDIA B300 GPU.

Building a reasoning agent with 2B active parameters

LFM2.5-24B-A2B builds on LFM2-24B-A2B and retains its architecture: 40 layers, 64 experts per mixture-of-experts block with top-4 routing, and a combination of gated short convolutions and grouped-query attention (GQA).

The context window increases from 32K to 131K tokens. An in-place tokenizer expansion also doubles the vocabulary from 65K to 128K tokens, improving tokenization for non-Latin languages. Unlike its predecessor, LFM2.5-24B-A2B is a reasoning-only model that produces an explicit chain of thought before its final answer.

Pre-training increased from approximately 17T to 33T tokens. Mid-training added 2T tokens with a 32K context window, emphasizing reasoning, mathematics, code, instruction following, and multilingual text. It also added 300B tokens with a 131K context window, emphasizing long-context data. Tool calls and multi-turn trajectories were included throughout both phases.

Post-training converted the base model into an agent through five stages:

1. Supervised fine-tuning (SFT)
2. Teacher specialization
3. Non-agentic multi-domain on-policy distillation (MOPD): Specialist teachers are distilled on non-agentic tasks.
4. Agentic MOPD: A second distillation stage focuses on agentic tasks.
5. Agentic reinforcement learning (Agentic RL): The model is trained inside agent harnesses including OpenClaw, Hermes Agent, Pi, and OpenCode.

Benchmark results

LFM2.5-24B-A2B was evaluated against Qwen3.6-35B-A3B, Gemma-4-26B-A4B-it, and Nemotron-3.5-Lightning on 16 benchmarks covering tool use, agentic workflows, knowledge, instruction following, mathematics, and coding. It is the smallest model in the comparison, while remaining competitive with mixture-of-experts models that have approximately 50% more total and active parameters.

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

The model performs particularly well on tool use and instruction following. It leads or matches the other models on five of the eight tool-use and agentic benchmarks: AutomationBench, BFCLv4, ToolSandbox, LiveClaw, and τ³-Bench Banking. On AutomationBench, its score is more than three times that of the next-best model. It also leads on all three instruction-following benchmarks.

The larger models perform better on knowledge-focused benchmarks such as GPQA Diamond, HLE, and AA-Omniscience, as well as on coding benchmarks including SWE-Bench Verified (OpenCode) and SciCode. Retrieval or web search can therefore supplement LFM2.5-24B-A2B in knowledge-heavy applications.

Inference speed on CPUs and GPUs

LFM2.5-24B-A2B supports several inference frameworks, including llama.cpp, MLX, vLLM, SGLang, and ONNX.

Edge inference

Among the compared mixture-of-experts models, LFM2.5-24B-A2B decodes 184 tokens per second on an Apple M5 Max and 114 tokens per second on a Ryzen AI Max+ 395. This is up to 1.7 times faster than the next-best model, while using the least memory.

GPU inference

At high concurrency, the model reaches more than 21K output tokens per second on a single NVIDIA B300, making it the fastest model in its size class in the reported comparison.

Using LFM2.5-24B-A2B

The model can be loaded with the latest version of transformers, compatible with transformers>=5.0.0:

pip install -U transformers

The following Python example loads the model and generates a response:

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,
)

Connecting the model to an agent harness

LFM2.5-24B-A2B can be served locally through an OpenAI-compatible backend and then connected to an agent harness. For Hermes Agent, the configuration can be set as follows:

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 varies by serving backend:

• llama.cpp and MLX: 8080
• vLLM: 8000
• SGLang: 30000
• LM Studio: 1234

The model card includes configurations for OpenClaw and Pi, while the agent-harness documentation covers the complete setup.

Availability

LFM2.5-24B-A2B and LFM2.5-24B-A2B-Base are open-weight models available on Hugging Face. The models can be used for local agents, and LFM2.5-24B-A2B can be adapted to specific tasks through fine-tuning.