onnx-community/LFM2.5-24B-A2B-ONNX

Try LFM • Docs • Discord

LFM2.5-24B-A2B

LFM2.5-24B-A2B is a 24B-parameter reasoning model with only 2B active parameters, built for fast, private agents on-device. It is the largest and final model in the LFM2.5 family, which now spans two orders of magnitude: from LFM2.5-230M to LFM2.5-24B-A2B.

• 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: Always thinks before it answers. With only 2B active parameters per token, each reasoning token is cheap.
• Efficient inference: Runs up to 1.7× faster than comparable MoEs on-device, with 184 tok/s on an Apple M5 Max and up to 21K output tok/s on a single NVIDIA B300 GPU.

Find more information about LFM2.5-24B-A2B in our blog post.

🗒️ Model Details

Model	Parameters	Description
LFM2.5-24B-A2B-Base	24B (2B active)	Pre-trained base model for fine-tuning
LFM2.5-24B-A2B	24B (2B active)	Post-trained for agentic workloads

LFM2.5-24B-A2B is a general-purpose text-only reasoning model with the following features:

• Total parameters: 24.0B
• Active parameters: 2.45B
• Number of layers: 40 (30 double-gated short convolution blocks + 10 GQA)
• Experts: 64 per MoE block, top-4 routing
• Training budget: 36 trillion tokens
• Vocabulary size: 128,000
• Context length: 131,072 tokens
• Languages: English, Arabic, Chinese, French, German, Italian, Japanese, Korean, Portuguese, Spanish, Vietnamese, Thai, Indonesian, Hindi, Russian, Polish
• Generation parameters:
  • temperature: 0.1
  • top_k: 50
  • repetition_penalty: 1.05

Model	Description
LFM2.5-24B-A2B	Original model checkpoint in native format. Best for fine-tuning or inference with Transformers, vLLM, and SGLang.
LFM2.5-24B-A2B-FP8	FP8 checkpoint (block-wise FP8 weights, dynamic FP8 activations). Best for high-throughput GPU serving with vLLM and SGLang with lower memory usage.
LFM2.5-24B-A2B-GGUF	Quantized format for llama.cpp and compatible tools. Optimized for CPU inference and local deployment with reduced memory usage.
LFM2.5-24B-A2B-ONNX	ONNX Runtime format for cross-platform deployment. Enables hardware-accelerated inference across diverse environments (cloud, edge, mobile).
LFM2.5-24B-A2B-MLX-4bit	MLX format for Apple Silicon. Optimized for fast inference on Mac devices using the MLX framework.
LFM2.5-24B-A2B-DSpark	DSpark draft model for speculative decoding with SGLang, for faster generation. Coming soon.

We recommend using it for agents that need to reason, call tools, and run reliably on your device. It is not recommended for knowledge-heavy tasks on its own: pair it with retrieval or web search, which plays to its tool-calling strength.

Chat Template

LFM2.5 uses a ChatML-like format. See the Chat Template documentation for details. Example:

<|startoftext|><|im_start|>system
You are a helpful assistant trained by Liquid AI.<|im_end|>
<|im_start|>user
What is C. elegans?<|im_end|>
<|im_start|>assistant
<think>

You can use tokenizer.apply_chat_template() to format your messages automatically.

💡 Note: Unlike LFM2-24B-A2B, LFM2.5-24B-A2B is a pure reasoning model that always thinks before it answers. It adds a <think> tag directly in the chat template when starting an assistant answer.

Tool Use

LFM2.5 supports function calling in four steps:

1. Function definition: Provide the list of tools as a JSON object in the system prompt, or use tokenizer.apply_chat_template() with tools=....
2. Function call: By default, LFM2.5 writes Pythonic function calls (a Python list between <|tool_call_start|> and <|tool_call_end|> special tokens), as the assistant answer. You can override this behavior by asking the model to output JSON function calls in the system prompt.
3. Function execution: Execute the call and return the result with the tool role.
4. Final answer: LFM2.5 interprets the tool output and returns a plain-text answer addressing the original prompt.

See the Tool Use documentation for the full guide. Example:

<|startoftext|><|im_start|>system
List of tools: [{"name": "get_candidate_status", "description": "Retrieves the current status of a candidate in the recruitment process", "parameters": {"type": "object", "properties": {"candidate_id": {"type": "string", "description": "Unique identifier for the candidate"}}, "required": ["candidate_id"]}}]<|im_end|>
<|im_start|>user
What is the current status of candidate ID 12345?<|im_end|>
<|im_start|>assistant
<|tool_call_start|>[get_candidate_status(candidate_id="12345")]<|tool_call_end|>Checking the current status of candidate ID 12345.<|im_end|>
<|im_start|>tool
[{"candidate_id": "12345", "status": "Interview Scheduled", "position": "Clinical Research Associate", "date": "2023-11-20"}]<|im_end|>
<|im_start|>assistant
The candidate with ID 12345 is currently in the "Interview Scheduled" stage for the position of Clinical Research Associate, with an interview date set for 2023-11-20.<|im_end|>

Training

LFM2.5-24B-A2B keeps the LFM2-24B-A2B architecture with two changes: the context window grows from 32K to 131K tokens, and the vocabulary doubles from 65K to 128K tokens through an in-place tokenizer expansion for better non-Latin tokenization.

• Pre-training: ~33T tokens, up from ~17T.
• Mid-training: 2T tokens at 32K context on curated, higher-quality data weighted toward reasoning, math, code, instruction following, and multilingual text, then 300B tokens of long-context data at 131K context. Tool calls and multi-turn trajectories appear in both phases.
• Post-training: supervised fine-tuning, teacher specialization, two multi-domain on-policy distillation stages (one non-agentic, one agentic), and agentic reinforcement learning inside popular agent harnesses (OpenClaw, Hermes Agent, Pi, OpenCode), so the model learns their tools, system prompts, and interaction patterns.

🏃 Inference

LFM2.5 is supported by many inference frameworks. See the Inference documentation for the full list.

Name	Description	Docs	Notebook
Transformers	Simple inference with direct access to model internals.	Link
vLLM	High-throughput production deployments with GPU.	Link
SGLang	High-throughput production deployments with GPU.	Link	—
llama.cpp	Cross-platform inference with CPU offloading.	Link
MLX	Apple's machine learning framework optimized for Apple Silicon.	Link	—
LM Studio	Desktop application for running LLMs locally.	Link	—

Transformers.js

If you haven't already, you can install the Transformers.js JavaScript library from NPM using:

npm i @huggingface/transformers

You can then use the model as follows:

import { pipeline, TextStreamer } from "@huggingface/transformers";

// Create a text generation pipeline
const generator = await pipeline(
  "text-generation",
  "onnx-community/LFM2.5-24B-A2B-ONNX",
  { dtype: "q4f16", device: "webgpu" },
);

// Define the list of messages
const messages = [
  { role: "user", content: "What's the capital of France?" },
];

// Generate a response
const output = await generator(messages, {
  max_new_tokens: 512,
  do_sample: false,
  streamer: new TextStreamer(generator.tokenizer, {
    skip_prompt: true,
    skip_special_tokens: true,
  }),
});
console.log(output[0].generated_text.at(-1).content);

ONNX Runtime

Here's a quick start example with ONNX Runtime:

from transformers import AutoConfig, AutoTokenizer
import onnxruntime
import numpy as np
from huggingface_hub import snapshot_download

# 1. Load config, processor, and model
model_id = "onnx-community/LFM2.5-24B-A2B-ONNX"
config = AutoConfig.from_pretrained(model_id)
tokenizer = AutoTokenizer.from_pretrained(model_id)
eos_token_id = config.eos_token_id

filename = "model_q4f16.onnx" # Options: "model_q4.onnx", "model_q4f16.onnx"
model_path = snapshot_download(repo_id=model_id, allow_patterns=f"onnx/{filename}*") # Download the graph + weights
session = onnxruntime.InferenceSession(f"{model_path}/onnx/{filename}")

# 2. Prepare inputs
prompt = "What is C. elegans?"
messages = [{"role": "user", "content": prompt}]
inputs = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="np")
input_ids = inputs['input_ids']
attention_mask = inputs['attention_mask']
batch_size = input_ids.shape[0]
num_logits_to_keep = np.array(1, dtype=np.int64)

past_cache_values = {}
for inp in session.get_inputs():
    name = inp.name
    shape = inp.shape
    dtype = np.float32 if inp.type == "tensor(float)" else np.float16
    if name.startswith("past_key_values"):
        # Attention KV cache: shape [batch_size, num_kv_heads, 0, head_dim]
        past_cache_values[name] = np.zeros([batch_size, shape[1], 0, shape[3]], dtype=dtype)
    elif name.startswith("past_conv"):
        # Conv cache: shape [batch_size, hidden_size, conv_L_cache]
        past_cache_values[name] = np.zeros([batch_size, shape[1], shape[2]], dtype=dtype)

# 3. Generation loop
max_new_tokens = 1024
generated_tokens = np.array([[]], dtype=np.int64)
for i in range(max_new_tokens):
  logits, *present_cache_values = session.run(None, dict(
      input_ids=input_ids,
      attention_mask=attention_mask,
      num_logits_to_keep=num_logits_to_keep,
      **past_cache_values,
  ))

  ## Update values for next generation loop
  input_ids = logits[:, -1].argmax(-1, keepdims=True)
  attention_mask = np.concatenate([attention_mask, np.ones_like(input_ids, dtype=np.int64)], axis=-1)
  for j, key in enumerate(past_cache_values):
    past_cache_values[key] = present_cache_values[j]
  generated_tokens = np.concatenate([generated_tokens, input_ids], axis=-1)
  if np.isin(input_ids, eos_token_id).any():
      break

  ## (Optional) Streaming
  print(tokenizer.decode(input_ids[0]), end='', flush=True)
print()

# 4. Output result
print(tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0])

🔧 Fine-Tuning

We recommend fine-tuning LFM2.5 for your specific use case to achieve the best results.

Name	Description	Docs	Notebook
CPT (Unsloth)	Continued Pre-Training using Unsloth for text completion.	Link
CPT (Unsloth)	Continued Pre-Training using Unsloth for translation.	Link
SFT (Unsloth)	Supervised Fine-Tuning with LoRA using Unsloth.	Link
SFT (TRL)	Supervised Fine-Tuning with LoRA using TRL.	Link
DPO (TRL)	Direct Preference Optimization with LoRA using TRL.	Link
GRPO (TRL)	GRPO with LoRA using TRL.	Link

📊 Performance

Benchmarks

We compared LFM2.5-24B-A2B with relevant MoE models on 16 benchmarks covering knowledge, instruction following, math, code, tool use, and agentic workflows.

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

Evaluation settings

All the models were evaluated with vLLM and the following generation parameters:

• AutomationBench: temperature = 0.6, top_p = 0.95, max_turns = 50, no max output tokens (bounded by the model's context window).
• BFCLv4: temperature = 0.001, max output tokens = 4096.
• ToolSandbox: temperature = 0, max output tokens = 1024; user simulator: GPT-4o-2024-08-06, temperature = 0, max output tokens = 1024.
• LiveClaw: temperature = 1.0 (vLLM default; the agent sets no temperature), max output tokens = 8192.
• τ³-Bench Banking: official user model (GPT-5.2, low reasoning effort) with default BM25 retrieval, temperature = 0, max output tokens = 16384 per turn.
• WebArena Verified: temperature = 0.6, top_p = 0.95, max_turns = 40 (number of browser actions allowed), no max output tokens (bounded by the model's context window).
• Other evals: temperature = 0.6, max output tokens = 32768.

Edge Inference

LFM2.5-24B-A2B is the fastest of the compared MoEs at reading in prompts and generating answers. It decodes 184 tokens/s on an Apple M5 Max and 114 tokens/s on an AMD Ryzen AI Max+ 395, up to 1.7x faster than the next-best model, while using the least memory.

Evaluation settings

Collected on Pipette, Liquid AI's device benchmarking infrastructure, with llama.cpp, Q4_K_M quantization, and a 4K-token input context.

GPU Inference

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

Evaluation settings

We measure GPU throughput (total output tokens / wall time) on a single NVIDIA B300 GPU with SGLang 0.5.22, using 1,024 input tokens, up to 256 output tokens, and BF16 weights. At each concurrency level, we continuously maintain the target number of in-flight requests, replacing each completed request immediately.

📬 Contact

• Got questions or want to connect? Join our Discord community
• If you are interested in custom solutions with edge deployment, please contact our sales team.

Citation

@article{liquidAI202624BA2B,
  author  = {Liquid AI},
  title   = {LFM2.5-24B-A2B: Built for Fast On-Device Agents},
  journal = {Liquid AI Blog},
  year    = {2026},
  note    = {www.liquid.ai/blog/lfm2-5-24b-a2b},
}

@article{liquidai2025lfm2,
  title   = {LFM2 Technical Report},
  author  = {Liquid AI},
  journal = {arXiv preprint arXiv:2511.23404},
  year    = {2025}
}