LFM2.5-24B-A2B-MLX-bf16 Reasoning Model for Apple Silicon: 80GB+ VRAM

LFM2.5-24B-A2B-MLX-bf16 Reasoning Model for Apple Silicon: 80GB+ VRAM

At a Glance

Item Value
Repository LiquidAI/LFM2.5-24B-A2B-MLX-bf16
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 a bfloat16 (bf16) MLX export of the reasoning model “LFM2.5-24B-A2B". Designed for execution on Apple Silicon, it was converted from the original checkpoint (revision 6b45d2eb) using mlx-lm 0.32.0. The weights remain in bf16 without quantization, and the MoE router portion (feed_forward.gate) is notably kept in float32.

The base model, LFM2.5-24B-A2B, is reported to inherit Liquid AI’s design philosophy as outlined in the related paper “LFM2 Technical Report" (arxiv:2511.23404), aiming for a hybrid configuration combining gated short convolutions and a very small number of GQA blocks via hardware-in-the-loop architecture search under edge latency and memory constraints.

Specifications

  • Total parameters: 24.0B
  • Active parameters: 2.45B (per token)
  • Architecture: MoE (lfm2_moe), 64 experts per MoE block, top-4 routing
  • Layer configuration: 40 layers (30 gated short convolution blocks + 10 GQA blocks)
  • Vocabulary size: 128,000
  • Context length: 131,072 tokens (128K)

Performance

The model card for this repository includes a table comparing multiple precisions (bf16/8bit/6bit/5bit/4bit) derived from the same LFM2.5-24B-A2B.

→ Scroll horizontally to see all columns

Repository Weights Bits per weight Top-1 agreement Mean KL
LFM2.5-24B-A2B-MLX-bf16 bfloat16 16 94.19% 0.0681
LFM2.5-24B-A2B-MLX-8bit 8-bit 8.50 93.33% 0.0808
LFM2.5-24B-A2B-MLX-6bit 6-bit 6.51 91.17% 0.1108
LFM2.5-24B-A2B-MLX-5bit 5-bit, 6-bit embedding 5.52 88.23% 0.1652
LFM2.5-24B-A2B-MLX-4bit 4-bit, 6-bit embedding 4.53 83.35% 0.2907

The Top-1 agreement (the rate of selecting the same next token as the original float32 model) is highest for the bf16 version at 94.19%. Lower quantization bits decrease the agreement rate and increase KL divergence (distribution shift from the original model, where lower is closer). According to the publishers, the reason the agreement rate is not 100% even for the bf16 version is that bfloat16 rounding in the MoE router alters some expert selections. In other words, although the bf16 version is unquantized, it occupies a position where outputs may deviate very slightly from the original model due to rounding errors in router calculations.

Benchmark scores themselves are published in the model card for the original model LFM2.5-24B-A2B, rather than the quantized version, showing measurement results compared against MoE models of the same class by the publishers.

Benchmarks

→ 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

LFM2.5-24B-A2B scores highest among the comparison targets in tool usage, agent, and instruction-following categories such as AutomationBench, ToolSandbox, LiveClaw, IFEval, and IFBench. IFEval, which measures compliance with formatting instructions, scores 96.75, the highest among the four compared models. On the other hand, GPQA Diamond, which measures difficult scientific questions, stays at 74.42, falling short of Qwen3.6-35B-A3B (83.69) which has about 50% more parameter scale. SWE-Bench Verified (resolution rate), which measures whether real GitHub issues can be resolved via repository editing, also shows a gap at 51.00 compared to Qwen3.6-35B-A3B (66.20), resulting in inferior autonomous coding correction capabilities. The difficult benchmark HLE scores 7.40, with low scores overall across models and only a slight difference from Qwen3.6-35B-A3B (7.69). MATH-500, measuring high school to competition-level mathematics, ranges from 96.04 to 96.73 with almost no significant differences across all four models. It should be noted that all of these measurements were conducted by the publishers themselves.

Strengths and Use Cases

LFM2.5-24B-A2B-MLX-bf16 is intended for primary use cases involving fast and private autonomous agents and tool utilization (Function Calling) running locally on devices such as Macs powered by Apple Silicon.

A major feature of the base model LFM2.5-24B-A2B is that it is a “thinking model" that invariably inserts reasoning steps before outputting answers. Through the chat template, it is structured to automatically output the final answer after </think> at the start of the assistant’s response. Because active parameters per token are as small as 2.45B, it has the advantage of keeping computational load low even when generating a large volume of thinking tokens.

Additionally, it has undergone reinforcement learning and distillation tailored for use in agent harnesses (such as Hermes Agent, OpenClaw, Pi, and OpenCode), designed with high accuracy for tool invocation when provided with tool definitions. Tool calls are output in Python list format by default, enabling smooth execution of workflows that feed external tool execution results back into the model.

Meanwhile, the model card explicitly states that “performing knowledge-intensive tasks standalone is not recommended." Rather than relying solely on the model’s internal memory, it is recommended to utilize its strong tool-calling capabilities in combination with external search (RAG) or web search.

Supported languages include 16 languages: English, Japanese, Arabic, Chinese, French, German, Italian, Korean, Portuguese, Spanish, Vietnamese, Thai, Indonesian, Hindi, Polish, and Russian. The context length is also expansive at 131,072 tokens (128K), making it suitable for running agents while retaining long logs or multi-turn tool execution histories.

Hardware Requirements

Estimated requirements (calculated by Local Model Watch) — 24.0B parameters

Your VRAM Quantization File size Est. memory needed
80GB class (A100 / H100) MLX 44.7GB 53.6GB

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.

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

This model is distributed in the MLX format (safetensors) for Apple Silicon. There is no gated requirement demanding license agreement upon acquisition, and it can be obtained directly from the Hugging Face repository.

The mlx-lm library is used for execution. Version 0.32.0 or later is required to correctly perform expert routing processing. Note that earlier versions will load without error but fail to yield normal outputs. Installation or updates can be performed with the following command:

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

A minimal code example for loading the model from a Python script and running inference is shown below. Because the reasoning process consumes many tokens, specifying a larger value for max_tokens is recommended.

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

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

messages = [{"role": "user", "content": "What is C. elegans?"}]
prompt = tokenizer.apply_chat_template(messages, add_generation_prompt=True)

# Generation parameters recommended in generation_config.json
sampler = make_sampler(temp=0.1, top_k=50)
logits_processors = make_logits_processors(repetition_penalty=1.05)

text = generate(
    model,
    tokenizer,
    prompt=prompt,
    max_tokens=4096,
    sampler=sampler,
    logits_processors=logits_processors,
)
reasoning, _, answer = text.partition("</think>")
print(answer.strip())

Alternatively, you can launch an OpenAI-compatible local API server using mlx_lm.server. Because the default generated token limit (512 tokens) truncates reasoning mid-way, launch the server by specifying a maximum token count.

mlx_lm.server --model LiquidAI/LFM2.5-24B-A2B-MLX-bf16 --temp 0.1 --top-k 50 --max-tokens 8192

Once the server starts, requests can be accepted via http://localhost:8080/v1, allowing it to connect as a backend for various agent frameworks such as Hermes Agent and OpenClaw.

Related Articles

What to Read Next

Sources