LFM2.5-24B-A2B-MLX-8bit Text Generation Model: 32GB+ VRAM

LFM2.5-24B-A2B-MLX-8bit Text Generation Model: 32GB+ VRAM

At a Glance

Item Value
Repository LiquidAI/LFM2.5-24B-A2B-MLX-8bit
Family guide LFM2.5 guide (11 articles)
Publisher guide Liquid AI: models and licenses
Published 2026-10-13
License lfm1.0
Formats MLX / safetensors
Paper arXiv:2511.23404
Source type Primary source (the publisher itself)

Values determined by this site’s code when the information was collected. Dates are JST.

Overview

LiquidAI has released its reasoning-focused MoE model, LFM2.5-24B-A2B, in MLX format with 8-bit quantization for Apple Silicon. The conversion was performed using mlx-lm version 0.32.0, and the repository is named LiquidAI/LFM2.5-24B-A2B-MLX-8bit. The base model features a Mixture of Experts (MoE) architecture where just over 2B of the total 24B parameters are active at a time, designed as a reasoning model emphasizing agent use cases and tool calling.

According to the abstract of the related paper “LFM2 Technical Report“, the LFM2 series aims to balance efficient operation on edge devices with task performance. Through hardware-aware architecture search, it adopts a hybrid configuration combining gated short convolutions and a small number of Grouped-Query Attention (GQA) blocks. LFM2.5-24B-A2B is positioned as the largest and final model in this series.

Specifications

According to the model card, the specifications of the base model (LiquidAI/LFM2.5-24B-A2B) are as follows. The parameter configuration remains unchanged in the 8-bit quantized version.

  • Total parameters: 24.0B
  • Active parameters: 2.45B
  • Architecture: MoE (lfm2_moe). Total 40 layers (30 double-gated short convolution blocks + 10 GQA blocks)
  • Experts per MoE block: 64 (top-4 routing)
  • Vocabulary size: 128,000
  • Context length: 131,072 tokens
  • Supported languages: English, Arabic, Chinese, French, German, Italian, Japanese, Korean, Portuguese, Spanish, Vietnamese, Thai, Indonesian, Hindi, Russian, Polish
  • Quantization method for the newly released MLX-8bit version: 8-bit (group size 64, affine mode). The MoE routing gates remain in float32 and are unquantized

Performance

The base model card includes a table comparing LFM2.5-24B-A2B with other MoE models (Qwen3.6-35B-A3B, Gemma-4-26B-A4B-it, Nemotron-3.5-Lightning (30B-A3B)) across 16 benchmarks. These are measurements published by the model creators themselves.

→ Scroll horizontally to see all columns

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

This table shows that LFM2.5-24B-A2B performs strongly in agent and tool-calling benchmarks. It significantly outperforms the other three models on AutomationBench with 27.69, and achieves the highest scores on LiveClaw (48.09), ToolSandbox (80.71), and IFBench (74.69). It also scores highest on IFEval (compliance rate) at 96.75, demonstrating excellent precision in following format instructions. On the other hand, it trails Qwen3.6-35B-A3B on advanced science tasks like GPQA Diamond (74.42) and the extremely difficult benchmark HLE (7.40), as well as SWE-Bench Verified (51.00) for real repository bug fixes, where Qwen3.6-35B-A3B scores 66.20. It also lags behind other models on PinchBench and WebArena Verified, indicating that knowledge-intensive and certain browser-interaction tasks are not its primary strengths, according to the release notes.

Strengths and Use Cases

The base model, LFM2.5-24B-A2B, is designed to build agents that operate quickly and reliably on-device. The model card recommends its application for “agents that need to reason, call tools, and operate reliably in local environments." Conversely, it explicitly notes that it is not suited for standalone knowledge-intensive tasks, recommending combination with external search or RAG (Retrieval-Augmented Generation) to leverage its tool-calling strengths.

Specifically, it features the following use cases and characteristics:

  • Agentic and Tool Calling (Function Calling): As demonstrated by the benchmarks in the model card, it has strong aptitude for tool usage and automation tasks. While tool calling outputs Python-like function call syntax by default (enclosed in special tokens), it can also be switched to JSON format via system prompt instructions. It is trained to be compatible with major agent frameworks such as OpenClaw, Hermes Agent, and Pi.
  • Explicit Chain of Thought: Tuned as a pure reasoning model, it always employs <think> tags to articulate its reasoning process before outputting the final answer. Because the MoE configuration keeps active parameters per token down to approximately 2.45B, computational overhead remains low even when incorporating longer thinking processes.
  • 131,072-Token Long Context Processing: Significantly expanded from the previous generation’s (LFM2) 32K context, it supports autonomous execution by agents retaining long conversation histories, multiple tool execution results, and expansive contexts.
  • Multilingual Support: The tokenizer vocabulary has been expanded to 128,000, supporting processing across 16 languages including Japanese (English, Arabic, Chinese, French, German, Italian, Korean, Portuguese, Spanish, Vietnamese, Thai, Indonesian, Hindi, Russian, and Polish).

The newly released model is an 8-bit quantization of this base model for Apple Silicon on Macs. By using MLX as the inference engine, it is well-suited for running agents locally on Mac environments at high speeds.

Hardware Requirements

Estimated requirements (calculated by Local Model Watch) — 24.0B parameters (taken from the base model LiquidAI/LFM2.5-24B-A2B)

Your VRAM Quantization File size Est. memory needed
32GB (RTX 5090, etc.) MLX 8bit 23.7GB 28.5GB

Inference engine support (architecture name matched against each project’s own model registry in its source code, checked 2026-11-17): llama.cpp: registered, vLLM: registered, MLX (mlx-lm): registered.

Memory estimates add a 20% runtime overhead (KV cache, etc.) to the actual size of the distributed files. Actual usage varies with context length, batch size and inference engine. These figures are computed by this site from file sizes, not published by the model’s authors. Compare with other models in our VRAM quick reference. What the quantization names mean: glossary.

Can You Run It Locally?

Not usable in Ollama, LM Studio and llama.cpp yet — we have found no GGUF build.

The publisher ships MLX / safetensors only. However, llama.cpp’s registry does list this architecture, so conversion to GGUF is possible and the model will run once someone publishes a converted build. Today it can be run with transformers, vLLM or MLX (Apple Silicon), using the memory figures in the table above.

License — lfm1.0 (Commercial use allowed with conditions): LiquidAI’s LFM Open License v1.0. Commercial use is allowed, except by legal entities with annual revenue of $10 million or more (Section 5). Redistribution requires the license text and notice of changes.

Compression: the MLX 8bit build measures 8.49 bits per weight — about 53% the size of the original 16-bit weights, calculated by this site from the actual file sizes.

Compiled by this site’s code from the published formats, converted builds we have found, and each engine’s own model registry. “Not found" means we have not seen such a build, not that none exists. License summaries are not legal advice — check the publisher’s original terms before relying on them.

Recent Models in the Same Size Class

Models with 15–40B parameters that Local Model Watch covered recently, listed by code from our article log for comparison. VRAM tiers are this site’s estimates; licenses are as stated on the model cards.

→ Scroll horizontally to see all columns

Model Parameters Smallest VRAM tier License Our article
IFM/Jais-3-32B-GGUF 34.8B 24GB apache-2.0 Jais-3-32B-GGUF Arabic and English 32B Dense Model: 24GB+ VRAM (2026-11-17)
IFM/Jais-3-MoVA-36B-A4B-GGUF 37.4B 32GB apache-2.0 Jais-3-MoVA-36B-A4B-GGUF Text Generation Model: 32GB+ VRAM (2026-11-17)
tencent/Hy-Memory-30B-A3B 30.1B 12GB apache-2.0 Hy-Memory-30B-A3B Text Generation Model: 12GB+ VRAM, GGUF Builds (2026-11-17)
KRAFTON/Raon-1-mini-preview 28.8B 24GB apache-2.0 Raon-1-mini-preview Reasoning-Enabled Language Model: 24GB+ VRAM (2026-11-17)
ggml-org/Flint-GGUF 39.8B 32GB apache-2.0 Flint-GGUF Coding MoE Language Model: 32GB+ VRAM (2026-11-17)

How to Get It

The model is distributed in safetensors format from the Hugging Face repository (LiquidAI/LFM2.5-24B-A2B-MLX-8bit). Since it is not a gated repository, you can download it directly without prior application or consent procedures. The model operates under the lfm1.0 license.

For inference, use mlx-lm, the language model toolkit for MLX, Apple Silicon’s machine learning framework. The model card explicitly states that mlx-lm 0.32.0 or later is required. Versions older than 0.32.0 may allow loading the model, but will cause bugs where MoE expert routing fails to function correctly, so please be sure to update to the latest version.

First, install or upgrade the library:

pip install -U "mlx-lm>=0.32.0"

A minimal code example to run inference from a Python script applies the recommended sampling settings from the model card (temperature: 0.1, top_k: 50, repetition_penalty: 1.05):

from mlx_lm import load, generate
from mlx_lm.sample_utils import make_sampler, make_logits_processors

model, tokenizer = load("LiquidAI/LFM2.5-24B-A2B-MLX-8bit")

prompt = "What is C. elegans?"

if tokenizer.chat_template is not None:
    messages = [{"role": "user", "content": prompt}]
    prompt = tokenizer.apply_chat_template(
        messages, add_generation_prompt=True
    )

sampler = make_sampler(temp=0.1, top_k=50)
logits_processors = make_logits_processors(repetition_penalty=1.05)

response = generate(
    model,
    tokenizer,
    prompt=prompt,
    max_tokens=4096,
    sampler=sampler,
    logits_processors=logits_processors,
    verbose=True,
)

When utilizing tool calling, passing tools as an argument to tokenizer.apply_chat_template() automatically applies formatting conforming to the ChatML-style template.

Related Articles

What to Read Next

Sources