Liquid AI releases LFM2.5-24B-A2B, a fast reasoning model for local agents

Liquid AI's LFM2.5-24B-A2B is a Mixture-of-Experts model with 24B parameters, but only about 2B active per token. It's built for tool use and on-device agents, and Liquid AI says it hits 184 tokens per second on an Apple M5 Max.

Model releases Try it yourself Oct 12, 2026 4 min read Source: Hugging Face Trending

What this is about

Liquid AI has released LFM2.5-24B-A2B on Hugging Face. According to the company, it is the largest and last model in the LFM2.5 family, which runs from LFM2.5-230M up to this model. It's a reasoning model, so it produces a thinking section before every answer, and it's designed for "fast, private on-device agents." Agents are AI systems that call tools and work through multi-step tasks on their own. The license is listed on the page only as "other."

Architecture and training

The model is a Mixture-of-Experts (MoE): it has 24B parameters but uses only 2.45B of them per token. Each MoE block has 64 experts (specialized sub-networks), and four are selected per token. That keeps every thinking token cheap. The 40 layers consist of 30 double-gated short convolution blocks and 10 GQA (Grouped Query Attention) layers.

The architecture is the same as in LFM2-24B-A2B, with two changes: the context window grows from 32K to 131K tokens, and the vocabulary doubles from 65K to 128K tokens through a tokenizer extension that improves handling of non-Latin scripts.

Pre-training: about 33 trillion tokens (previously around 17 trillion)
Mid-training: 2 trillion tokens at 32K context with higher-quality data (reasoning, math, code, instructions, multilingual), followed by 300 billion long-context tokens at 131K
Post-training: supervised fine-tuning, teacher specialization, two on-policy distillation stages (non-agentic and agentic), and agentic reinforcement learning in agent environments such as OpenClaw, Hermes Agent, Pi and OpenCode

In total, the model card cites 36 trillion training tokens. Supported languages include English, German, French, Spanish, Chinese, Japanese and Russian.

Benchmarks

Liquid AI compared the model with Qwen3.6-35B-A3B, Gemma-4-26B-A4B-it and Nemotron-3.5-Lightning (30B-A3B) on 16 benchmarks. All figures come from the vendor.

Benchmark	LFM2.5-24B-A2B	Qwen3.6-35B-A3B	Gemma-4-26B-A4B-it	Nemotron-3.5-Lightning
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
IFEval	96.75	93.06	92.00	94.19
GPQA Diamond	74.42	83.69	74.90	72.42
MATH-500	96.04	96.73	95.66	96.40
SWE-Bench Verified (OpenCode)	51.00	66.20	25.80	53.40
WebArena Verified	26.75	37.62	25.62	28.69

The picture is mixed. LFM2.5 leads on tool use and instruction following, while Qwen3.6-35B-A3B has clear advantages in knowledge (GPQA Diamond), coding (SWE-Bench, SciCode) and web navigation. Liquid AI itself doesn't recommend the model for knowledge-intensive tasks on its own, only in combination with retrieval or web search.

Speed

With llama.cpp, Q4_K_M quantization and a 4K input, the model reaches 184 tokens/s on an Apple M5 Max and 114 tokens/s on an AMD Ryzen AI Max+ 395. That's up to 1.7 times faster than the next-best model in the comparison, with the lowest memory use. On a single NVIDIA B300 with SGLang and BF16, it reaches more than 21,000 output tokens per second at high concurrency.

What you need to try it

The BF16 weights need roughly 48 GB of memory, which is too much for consumer GPUs. The GGUF variant is more practical (about 14–16 GB at 4-bit) and runs via llama.cpp or LM Studio, including on CPU and with partial offloading. On an Apple Silicon Mac, the MLX-4bit variant is a good fit, starting at around 24 GB of unified memory. Plan for roughly 15–50 GB of disk space, depending on the variant. A long context of up to 131K costs extra memory. For Transformers, you need version 5.0.0 or newer.

Our take

LFM2.5-24B-A2B targets a gap: agents that should run locally and fast, with no cloud. With only 2.45B active parameters, speed is high, and the focus on tool use shows in the agent benchmarks. On knowledge and coding, though, Qwen3.6-35B-A3B remains ahead, and this model is text-only. All figures are vendor claims and haven't been independently verified; some benchmarks use GPT models as a user simulator. You should also check the license terms ("other") before any commercial use. The DSpark draft model for speculative decoding has been announced as "coming soon."

Terms explained simply

Mixture-of-Experts (MoE): A model made up of many specialized sub-networks (experts), only a few of which are active per token. This saves compute while keeping a large total capacity.
Active parameters: The parameters that are actually computed for a single token; here about 2.45B out of 24B.
Reasoning model: A model that writes out a thinking section before answering so it can work through problems step by step.
Agent: An AI system that independently calls tools and completes multi-step tasks.
Quantization (Q4_K_M): Weights are rounded to fewer bits so the model needs less memory and runs faster, at the cost of a slight loss in quality.
Context window: The amount of text the model can consider at once; here 131,072 tokens.
On-policy distillation: A teacher model grades or corrects the student model's own outputs so it picks up specific skills.

Sources

Hugging Face Trending huggingface.co

#liquid-ai#moe#agents#on-device#reasoning#open-weights

Read the original source

Try it yourself: LFM2.5-24B-A2B

Explained step by step, no prior knowledge needed – on your own computer or free in your browser.

What can I do with it?

The model thinks before every answer, calls tools (functions) and works through multi-step tasks, all locally on your machine. It works well as the engine for agent programs such as Hermes, OpenClaw or Pi. It follows instructions very well and understands several languages, including German.

Who is it worth it for?

Interesting for developers and tinkerers who want to build local, private agents with tool calls. Less suitable as a pure knowledge model or for demanding coding.

Size24 B parameters (2.45 billion active)

Download14 GB (about 19 min at 100 Mbit/s)

Licensecustom license (see Model Card)

TypeLanguage model (text chat)

Hugging FaceLiquidAI/LFM2.5-24B-A2B

What your computer needs

Graphics card (NVIDIA), fully in VRAM at least 17 GB VRAMe.g. RTX 3090, RTX 4090, Tesla P40 – fastest; with less VRAM, see the next line

Graphics card + system memory (MoE offloading) from approx. 6 GB VRAM + 32 GB RAMdie Experten liegen im Arbeitsspeicher, nur der Kern auf der Grafikkarte (llama.cpp/LM Studio). Langsamer als komplett im VRAM, aber auf normalen PCs machbar

Mac (Apple Silicon M1–M5) from 32 GB unified memoryThe GPU and CPU share the memory – the model can use about 70% of it

CPU only (no graphics card) Runs smoothly without a graphics cardan estimated 15 words per second on a current desktop PC (MoE: only 2.45 billion parameters active per word). This requires at least 32 GB of RAM.

Storage approx. 16 GB freeModel download plus programs

Google Colab Colab Pro onlywith MoE offloading on a T4/L4 plus a High-RAM runtime (about 51 GB of RAM); free Colab doesn't have enough RAM

Which variant is right for me?

Many models come in several sizes or "quantizations." These are compressed versions: smaller and faster, but slightly less accurate. Rule of thumb: pick the largest variant whose memory requirement fits in your VRAM (video memory). The scripts below choose this for you automatically.

Variant	Download	Needs approx.	Compatible graphics cards
`Q4_K_M` Default	14 GB	17 GB	e.g. RTX 3090, RTX 4090, Tesla P40
`Q5_K_M`	17 GB	20 GB	e.g. RTX 3090, RTX 4090, Tesla P40
`Q6_K`	20 GB	23 GB	e.g. RTX 3090, RTX 4090, Tesla P40
`Q8_0`	26 GB	30 GB	e.g. RTX 5090
`BF16`	48 GB	54 GB	e.g. multiple professional GPUs (2× A6000, H100) or DGX Spark

On consumer hardware, use the GGUF variant (e.g. Q4_K_M, roughly 14–16 GB) with llama.cpp or LM Studio; on Apple Silicon, use MLX-4bit. The original BF16 weights (~48 GB) and FP8 are meant for GPU servers running vLLM or SGLang.

All 24B parameters must fit in memory, even though only about 2.45B are active.
According to Liquid AI, 184 tokens/s on an Apple M5 Max and 114 tokens/s on an AMD Ryzen AI Max+ 395 (Q4_K_M).
GGUF is optimized for CPU inference with offloading.
A context of up to 131K tokens needs additional memory.
Transformers version 5.0.0 or newer is required.

How do I find out what my computer has?

Windows: Press Ctrl + Shift + Esc → Task Manager → Performance tab → click GPU on the left. At the bottom you'll see Dedicated GPU memory (that's your VRAM). You'll find system memory under Memory.
Mac: Apple menu at the top left → About This Mac. You'll see your chip (e.g. M2) and memory (e.g. 16 GB). On Apple chips, graphics and processor share this memory.
Linux: Type nvidia-smi in the terminal (shows your graphics card and its memory) and free -h for system memory.

Guide

Google Colab (in your browser, no installation)

Google Colab is a free service from Google. It gives you a computer with a graphics card in your browser for a few hours. All you need is a Google account. For this model: Colab Pro only – needs the L4 GPU (22.5 GB); the free T4 is too small.

Download the notebook. Click the button and save the file.
Download colab.ipynb
Open Colab. Go to colab.research.google.com and sign in with your Google account.
Upload the notebook. In the window that appears, click Upload on the left (or choose File → Upload notebook at the top) and select the file colab.ipynb.
Turn on the GPU. In the top menu, go to Runtime → Change runtime type → under Hardware accelerator, select T4 GPU (with Colab Pro: L4 or A100) → Save.
Start everything. Runtime → Run all (keyboard shortcut Ctrl + F9). If you see the warning “This notebook was not authored by Google,” click Run anyway.
Wait. The cells run one after another. A green checkmark appears to the left of each cell when it's done. Installation and download take about 9 minutes here.
Try it out. The result appears below the last cell. To test something else, change the text in the cell and run it again with Shift + Enter. The last cell starts a proper chat with an input field.
Clean up. When you're done: Runtime → Disconnect and delete runtime. This saves your free quota.

Good to know: The free GPU is limited (usually a few hours per day). After about 90 minutes of inactivity, Colab disconnects, and you'll have to start everything over.

Windows 10 / 11

The easiest way is Ollama, a free program that launches AI models with a single command.

Update your graphics driver (NVIDIA cards only): Install the NVIDIA app or the latest driver. For AMD cards, use the latest Adrenalin driver.
Install Ollama. Download the file OllamaSetup.exe from ollama.com/download/windows, double-click it, and choose Install. Afterward, a small llama icon appears in the taskbar at the bottom right.
Open a terminal window. Press the Windows key, type PowerShell and press Enter. A blue or black window opens.
Start the model. Copy this command ("Copy" button), paste it into the window with a right-click, and press Enter:
```
ollama run hf.co/LiquidAI/LFM2.5-24B-A2B-GGUF:Q4_K_M
```
The first time, Ollama downloads the model (14 GB (about 19 min at 100 Mbit/s)). After that, it's instant.
Start typing. Once >>> Send a message appears, type your question and press Enter. Type /bye to end the chat.

Not enough memory? Pick a smaller variant from the table above, e.g. ollama run hf.co/LiquidAI/LFM2.5-24B-A2B-GGUF:Q4_K_M.

Prefer automatic? A script that picks the right variant for you

Download both files into the same folder: try_windows.ps1 demo.py
Open the folder in File Explorer, right-click an empty spot and choose Open in Terminal.

Paste this command and press Enter:

powershell -ExecutionPolicy Bypass -File try_windows.ps1

If needed, the script installs Ollama via winget, measures your VRAM (video memory) and downloads the matching variant.

macOS

Macs with an Apple chip (M1 to M5) are ideal. Older Intel Macs are very slow.

Install Ollama. Download it from ollama.com/download/mac, open the file, and drag Ollama into your Applications folder. Launch Ollama once – a llama appears in the menu bar at the top.
Open Terminal. Press Cmd + Space, type Terminal, and press Enter.
Start the model. Paste the command (Cmd + V) and press Enter:
```
ollama run hf.co/LiquidAI/LFM2.5-24B-A2B-GGUF:Q4_K_M
```
The first time, the model is downloaded (14 GB (about 19 min at 100 Mbit/s)).
Start typing. Type your question and press Enter. Quit with /bye.

Pick the right variant automatically

try_mac.sh

cd ~/Downloads
bash try_mac.sh

Linux

Check your GPU. nvidia-smi should show your card. If it doesn't, install the driver on Ubuntu and restart:
```
sudo ubuntu-drivers install
```

Install Ollama:

curl -fsSL https://ollama.com/install.sh | sh

Start the model:
```
ollama run hf.co/LiquidAI/LFM2.5-24B-A2B-GGUF:Q4_K_M
```
Exit with /bye. Use ollama ps to check whether the model is running on the GPU.

Or let it pick the right variant automatically:

try_linux.sh

bash try_linux.sh
# mit Python/transformers statt Ollama:
MODE=hf bash try_linux.sh

Try it

You have a tool get_weather(city). What will the weather be like in Hamburg tomorrow, and should I take an umbrella?

Explain step by step how I can summarize an Excel spreadsheet of sales figures by month.

Write an email to my landlord in exactly three sentences, polite, without using the word 'unfortunately'.

If something goes wrong

The original weights need about 48 GB; on normal PCs, you're better off with the GGUF or MLX-4bit variant.

The model always thinks first (think tag), so plan for more output tokens.

Recommended parameters: temperature 0.1, top_k 50, repetition_penalty 1.05.

For factual knowledge, combine it with web search or retrieval; on its own it's weaker there.

Tool calls use Python style by default; if you want JSON, you have to request it in the system prompt.

“out of memory,” a crash, or your computer freezes

The model is too big for your VRAM (video memory). Pick a smaller variant from the table above and close other programs, especially games and browsers with lots of tabs.

It runs, but extremely slowly

Your CPU is probably doing the work instead of your graphics card. In Ollama, the PROCESSOR column of ollama ps shows how much runs on the GPU. If it says "100% CPU", update your graphics driver or pick a smaller variant that fits entirely into VRAM (video memory).

“ollama” or “python” is not found

Close the terminal window and open it again so it recognizes the newly installed program. For Python on Windows: reinstall it and check Add python.exe to PATH.

Windows: "Running scripts is disabled on this system"

Run the script with exactly the command above: powershell -ExecutionPolicy Bypass -File try_windows.ps1. This allows execution for this one time only.

Error message when loading the model (version, "trust_remote_code", unknown architecture)

Brand-new models often need the latest software version. With Ollama: update Ollama. With Python: pip install -U transformers in the activated environment. The Model Card usually lists the exact version.

Tokenstrom generates the scripts and notebook automatically. Please take a quick look before running them – they're plain, readable text. Mind the model's license: custom license (see Model Card).

Ask the AI assistant

Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.

Connecting …

The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.

Comments

What do you think? Already tried it? Write it here, no sign-up needed.

Loading comments …

Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.