What Is LFM2.5-24B-A2B? Liquid AI’s Local Reasoning Model Explained

Overview

LFM2.5-24B-A2B is a text-only reasoning model from LiquidAI, built for local agents that reason, call tools, and run on-device. It has 24.0B total parameters and 2.45B active parameters per token, using a mixture-of-experts design with 64 experts per MoE block and top-4 routing. Its 40 layers comprise 30 double-gated short-convolution blocks and 10 GQA layers. The context window is 131,072 tokens, and the model was trained on a stated budget of 36 trillion tokens. The key practical point is that low active parameter count can make generation efficient, but it does not remove the memory cost of loading a 24B-parameter model; choose a quantized or device-specific checkpoint if the native checkpoint does not fit your hardware. The model uses a ChatML-like template and always begins assistant answers with a tag. It is available through Transformers, with support also listed for vLLM, SGLang, llama.cpp, MLX, ONNX Runtime, and LM Studio. The model card reports 2,565 downloads; that count is a snapshot, not a measure of quality or maintenance.

Best use cases

Local tool-using agents. Use it for workflows such as checking a record in a database, calling a scheduling API, then summarizing the result for a user. The model was post-trained for agentic workloads and supports tool calls in a defined format. Liquid AI reports a LiveClaw score of 48.09, compared with 38.19 for Qwen3.6-35B-A3B; this is a vendor-reported benchmark result, not a guarantee for every agent harness or tool schema.

Multi-step instruction following. It suits tasks that require planning and several actions, such as triaging a support request, looking up account details, and drafting a response. The model always reasons before answering, and its post-training included supervised fine-tuning, teacher specialization, two on-policy distillation stages, and agentic reinforcement learning in OpenClaw, Hermes Agent, Pi, and OpenCode. That training targets agent interactions, but it does not ensure that every plan or tool call will be correct.

Retrieval-augmented question answering. Pair it with a search index or web search to answer questions from current or private material—for example, finding a policy passage and explaining how it applies to a case. The model card specifically advises against relying on the model alone for knowledge-heavy tasks and recommends retrieval or web search. Its tool-calling strength makes it a fit for systems that can fetch evidence before generating an answer.

Long-context document workflows. The 131,072-token context window supports tasks such as reviewing a long report, comparing sections, or extracting action items from a large conversation. The model’s training included 300B tokens of long-context data at 131K context. A large context limit does not establish that every long-document task will be accurate, and the README provides no long-context benchmark results.

Local inference across different device types. The available checkpoint formats target different deployment environments: GGUF for llama.cpp and CPU inference, MLX 4-bit for Apple Silicon, FP8 for GPU serving, and ONNX for cross-platform deployment. The model card reports 184 tokens per second on an Apple M5 Max and up to 21K output tokens per second on a single NVIDIA B300 GPU. These are reported figures; the README does not specify the full benchmark setup, batch size, or prompt length.

Limitations

The model is not recommended as a standalone source of factual knowledge. Its training budget is large, but the model card still recommends retrieval or web search for knowledge-heavy tasks. It can also make mistakes in reasoning, tool selection, argument formatting, or interpretation of tool results; the provided material does not quantify these failure rates.

The model always reasons before answering. That behavior can add output tokens and latency, even though the model uses only 2.45B active parameters per token. The README does not describe a supported way to disable reasoning or provide measured latency for different prompt lengths.

The 131,072-token context limit is a maximum, not a promise that every deployment can serve that much context within available memory or with acceptable latency. No VRAM requirement, minimum system RAM, batch-size guidance, or memory benchmark is provided for the native checkpoint. The reported speed figures do not include enough hardware and workload detail to predict performance on other devices.

The model is text-only. It does not accept image, audio, or video inputs according to the supplied model details. The license is listed as other; the provided information does not state commercial-use terms or other license conditions, so check the checkpoint’s license terms before deployment. The model card lists supported languages but does not provide per-language quality scores or bias and safety evaluations. It also does not identify a newer model that supersedes it for a specific task.

How it compares

LFM2-24B-A2B. Choose LFM2.5-24B-A2B when you want the newer reasoning and agent-focused post-training, a 131K context window, and a 128K vocabulary. The supplied comparison describes the earlier model as a 24B MoE with 2B active parameters, a 32K context window, and a 65K vocabulary; it reports 112 tokens per second on an AMD CPU and 293 tokens per second on an H100, plus a 32 GB RAM deployment target. Choose LFM2-24B-A2B when its earlier checkpoint and documented deployment profile better match your environment; the provided material does not give a direct quality or cost comparison between the two.

LFM2.5-8B-A1B. Choose LFM2.5-24B-A2B when you want the larger model and its reported LiveClaw result, and can accommodate the memory cost of a 24B-parameter checkpoint. Choose LFM2.5-8B-A1B when a smaller on-device model is a better fit: its description emphasizes personal-assistant use, tool chaining, and throughput in its size class. The supplied information does not provide comparable benchmark scores, hardware requirements, or prices for these two models, so it does not establish which is faster or better for a particular task.

LFM2.5-8B-A1B-Base. Choose LFM2.5-24B-A2B for the post-trained 24B agent model when you need its stated reasoning and tool-use focus. Choose the 8B base checkpoint when you need a base model for a workflow that starts from a base checkpoint; the supplied description identifies it as part of the LFM2.5 family but does not provide detailed base-model specifications or a direct performance comparison.

LFM2-8B-A1B. Choose LFM2.5-24B-A2B for the newer model’s 131K context and agent-focused post-training. Choose LFM2-8B-A1B when the smaller edge model is a better deployment fit; its description reports 8.3B total parameters and 1.5B active parameters, and characterizes its quality as comparable to 3–4B dense models and its speed as faster than Qwen3-1.7B. Those claims are not a head-to-head comparison with LFM2.5-24B-A2B.

LFM2-24B-A2B-GGUF. Choose LFM2.5-24B-A2B when you need the newer model’s reasoning and agent post-training. Choose the GGUF checkpoint of LFM2-24B-A2B when you specifically need the earlier model in a quantized format for llama.cpp; its description reports CPU and GPU decode speeds and a 32 GB RAM target. The supplied material does not give a direct quality, speed, or cost comparison between this GGUF checkpoint and the newer model’s GGUF variant.

Technical specifications

LFM2.5-24B-A2B is a general-purpose, text-only reasoning model. It keeps the LFM2-24B-A2B architecture while extending the context window from 32K to 131K tokens and expanding the vocabulary from 65K to 128K through in-place tokenizer expansion, intended to improve non-Latin tokenization.

• Parameters: 24.0B total; 2.45B active.

• Architecture: 40 layers: 30 double-gated short-convolution blocks and 10 GQA layers. Each MoE block has 64 experts, with top-4 routing.

• Training: 36 trillion tokens stated as the training budget. The training description gives approximately 33T pre-training tokens, up from approximately 17T for the earlier model; 2T mid-training tokens at 32K context; and 300B long-context tokens at 131K context. The README does not provide training steps or compute hardware.

• Mid-training data focus: Curated, higher-quality data weighted toward reasoning, math, code, instruction following, and multilingual text. Tool calls and multi-turn trajectories appear in both mid-training phases.

• Post-training: Supervised fine-tuning, teacher specialization, two multi-domain on-policy distillation stages (one non-agentic and one agentic), and agentic reinforcement learning in OpenClaw, Hermes Agent, Pi, and OpenCode.

• Vocabulary and context: 128,000 tokens; 131,072-token context window.

• Languages listed: English, Arabic, Chinese, French, German, Italian, Japanese, Korean, Portuguese, Spanish, Vietnamese, Thai, Indonesian, Hindi, Russian, and Polish.

• Recommended generation settings: temperature: 0.1, top_k: 50, repetition_penalty: 1.05.

• Reported inference speeds: Up to 1.7× faster than comparable MoEs on-device; 184 tokens per second on an Apple M5 Max; up to 21K output tokens per second on one NVIDIA B300 GPU. The README does not specify benchmark conditions.

• Checkpoint formats: Native checkpoint for Transformers, vLLM, and SGLang; block-wise FP8 weights with dynamic FP8 activations for GPU serving; GGUF for llama.cpp and compatible tools; ONNX Runtime format for cross-platform deployment; and MLX 4-bit for Apple Silicon. A DSpark draft model for speculative decoding with SGLang is marked as coming soon.

• Inference frameworks listed: Transformers, vLLM, SGLang, llama.cpp, MLX, ONNX Runtime, and LM Studio. The quick start requires transformers>=5.0.0.

• Input and output convention: ChatML-like messages. Tool calls use <|tool_call_start|> and <|tool_call_end|> markers and, by default, Pythonic function-call syntax. The system prompt can request JSON function calls instead.

• License: Listed as other; the supplied material does not specify the terms.

• Hardware and memory: No VRAM or minimum RAM requirement is stated for this model. The README’s speed claims do not provide enough detail to infer a general hardware requirement.

Model inputs and outputs

Inputs

• Text messages: A list of messages with roles such as system and user, formatted with the model’s ChatML-like template. Use tokenizer.apply_chat_template() to format messages.

• Tools: Tool definitions can be supplied as a JSON object in the system prompt or passed to tokenizer.apply_chat_template() with tools=....

• Context constraint: The model supports a context window of up to 131,072 tokens. The usable limit in a deployment depends on its serving configuration and available memory; the README does not give hardware-specific limits.

• Modalities: Text only; the supplied model details do not describe image, audio, or video input.

Outputs

• Assistant text: A generated response, with reasoning initiated by a tag in the chat template.

• Tool calls: By default, Pythonic function calls enclosed by <|tool_call_start|> and <|tool_call_end|>. The model can be prompted to output JSON function calls instead.

• Tool results: The application executes the call and returns its result with the tool role; the model then produces a plain-text response. The application must implement tool execution and handle the returned data.

Getting started

This example uses Transformers 5.0 or later, formats a user message with the model’s chat template, and streams the generated 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",
    # Uncomment on a compatible GPU:
    # attn_implementation="flash_attention_2",
)
tokenizer = AutoTokenizer.from_pretrained(model_id)
streamer = TextStreamer(
    tokenizer,
    skip_prompt=True,
    skip_special_tokens=True,
)

messages = [{"role": "user", "content": "What is C. elegans?"}]
input_ids = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt=True,
    return_tensors="pt",
    tokenize=True,
)["input_ids"].to(model.device)

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

Frequently asked questions

Q: Can I use LFM2.5-24B-A2B commercially?

A: The model metadata lists the license as other, but the supplied information does not state commercial-use terms. Review the checkpoint’s license before using it in a commercial product.

Q: What hardware or VRAM do I need to run it?

A: The README gives no minimum VRAM or RAM requirement for this model. It reports 184 tokens per second on an Apple M5 Max and up to 21K output tokens per second on a single NVIDIA B300 GPU, but does not provide benchmark conditions or memory figures.

Q: How does it compare with LFM2-24B-A2B for agent tasks?

A: LFM2.5-24B-A2B adds agent-focused post-training and expands context from 32K to 131K tokens. The supplied information does not provide a direct agent benchmark comparing it with LFM2-24B-A2B.

Q: What failure modes or quality issues should I expect?

A: The model card warns against using it alone for knowledge-heavy tasks and recommends retrieval or web search. The supplied material does not report quantified failure rates or specific safety and bias evaluations.

Q: Can I fine-tune it, and which framework should I use?

A: The native checkpoint is described as suitable for fine-tuning and inference with Transformers, vLLM, and SGLang. The quick-start example requires transformers>=5.0.0; the README does not provide a fine-tuning recipe or hardware requirements.

Q: What input format does it expect?

A: It expects text messages formatted with a ChatML-like template. Use tokenizer.apply_chat_template(); tool definitions can be passed through the template or included as JSON in the system prompt.

Q: How fast is inference, and what batch size should I use?

A: Liquid AI reports 184 tokens per second on an Apple M5 Max and up to 21K output tokens per second on one NVIDIA B300 GPU. The README does not state batch sizes or enough benchmark details to predict throughput for a particular workload.

Q: Is the model actively maintained?

A: The supplied information identifies LiquidAI as the maintainer and lists inference formats and frameworks, but it does not state a maintenance schedule or support commitment.

This is a simplified guide to an AI model called LFM2.5-24B-A2B maintained by LiquidAI. If you like these kinds of analysis, join AIModels.fyi or follow us on Twitter.