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
- LFM2.5-24B-A2B-FP8 Text Generation Model: 32GB+ VRAM
- LFM2.5-24B-A2B-MLX-6bit Text Generation Model: 24GB+ VRAM
- LFM2.5-24B-A2B Agent-Optimized MoE Reasoning Model: 12GB+ VRAM
- LFM2.5-24B-A2B-MLX-bf16 Reasoning Model for Apple Silicon: 80GB+ VRAM
What to Read Next
- Find models by VRAM (This model needs at least 32GB) → VRAM quick reference
- Explore the same model family → LFM2.5 family overview (11 articles, 17 converted builds)
- Engines that run this model → vLLM
- Formats this model is available in → MLX format guide and models
- Learn about the publisher → Liquid AI: models, licenses and articles

