LFM2.5-24B-A2B: a 24B reasoning model built to spend like a 2B one per word piece
Liquid AI's 24B model uses 2.45B parameters per word piece and ships a 24.8 GB compressed file. Free for business only under 10M USD revenue.
The size printed on a model's name is a poor guide to how fast it will answer you. LFM2.5-24B-A2B, the model Liquid AI released on 13 October, has 24 billion parameters (the numbers that make up a model, a rough measure of its size). That is the 24B in the name. The A2B means about 2 billion parameters active for each word piece it writes, roughly one in ten (2.45B by the model card). A word piece, or token, is the unit a model reads and writes, roughly three quarters of a word. Liquid built it for agents: programs that reason, call tools and run on your own hardware. It also published an official compressed copy, a file of 24.8 GB, which on paper fits one 48 GB graphics card with plenty of room left over.
Two things before anything else. First, the license: you can use this model commercially for free only while your company, counting the companies it owns or is owned by, makes less than 10 million US dollars a year. Above that line, commercial use is not covered. Second, we planned to measure its speed on one rented GPU and the test never ran, so every speed figure in this post is Liquid's. Everything in the table below is checked against Liquid's files.
| Question | Answer | Where it comes from |
|---|---|---|
| Size of the whole model | 24.0B parameters | Liquid's model card |
| Used for each word piece written | 2.45B parameters | Liquid's model card |
| Official compressed file | 24.8 GB | Hugging Face (where Liquid publishes the files), adding up the file sizes |
| Full-size file | about 48 GB | Hugging Face (where Liquid publishes the files), adding up the file sizes |
| Longest conversation it accepts | 131,072 word pieces | config file |
| Fits one 48 GB card? | Should, with room for long conversations | our arithmetic, not a measurement |
| Free for commercial use? | Only under 10M USD annual revenue, affiliates included | the license |
| Our own speed numbers | None, the test did not run | our deploy test report |
A team of 64 specialists
The trick behind the A2B has a technical label, mixture of experts, and a simple idea. A model works on each word piece in a series of steps, one after another. Picture most of those steps as a room with 64 specialists. When a word piece comes in, a small router at the entrance picks 4 of them to work on it and the other 60 stay in the back. Every specialist has to be in the building, which is why the file is big. But only the 4 on duty do any work, which is why each word piece is cheap.
So a mixture of experts pays memory like a big model and pays work like a small one. That is the whole bet of LFM2.5-24B-A2B: the capacity of a 24B model, the per-word-piece effort of a 2B one. The model card adds two more details that matter for an agent. It always thinks before it answers, unlike its predecessor LFM2-24B-A2B. And when it needs a tool, it asks in a fixed, easy-to-detect format, so the program around it can reliably run the tool and hand back the result.
The steps are not all the usual kind either. Of its 40 steps, only 10 look back at everything said so far, which is what makes long conversations expensive. The other 30 only look at the last few word pieces. That detail comes back when we get to memory.
Liquid also says plainly what it is not for. On its own it should not be trusted to know facts, so pair it with a web search or with a search over your own documents. That is a refreshing line to find on a model card.
What it is good at, by Liquid's own numbers
The answer first: on Liquid's own tests, it is strongest on agent workflows, tool use and following instructions. It is behind Qwen on fixing real code, where it solved 51 of every 100 test tasks against Qwen's 66 (51.00 against 66.20). It is also behind on hard science questions, where it got about 74 of every 100 right against Qwen's 84 (74.42 against 83.69), and on web browsing.
Liquid compares it with three similar open models: Alibaba's Qwen, Google's Gemma and NVIDIA's Nemotron. All three rivals are also teams of specialists, with more of their parameters at work per word piece. Liquid publishes no comparison with a classic model, where every parameter works on every word piece. So whether this beats a classic ~24B model on the same card, in speed or quality, is exactly what neither Liquid nor we can tell you yet.
A selection from the model card, all run by Liquid:
| Test | LFM2.5-24B-A2B | Qwen3.6-35B-A3B | Gemma-4-26B-A4B-it | Nemotron-3.5-Lightning |
|---|---|---|---|---|
| AutomationBench (agent workflows) | 27.69 | 8.72 | 5.46 | 2.61 |
| LiveClaw (agent tasks) | 48.09 | 38.19 | 41.25 | 37.72 |
| ToolSandbox (tool use) | 80.71 | 75.02 | 72.09 | 75.13 |
| BFCLv4 (tool calling) | 65.01 | 65.00 | 57.09 | 53.78 |
| PinchBench (agent tasks) | 83.18 | 89.93 | 77.12 | 84.20 |
| WebArena Verified (web browsing) | 26.75 | 37.62 | 25.62 | 28.69 |
| IFBench (following instructions) | 74.69 | 64.21 | 47.44 | 71.67 |
| SWE-Bench Verified (fixing real code) | 51.00 | 66.20 | 25.80 | 53.40 |
| GPQA Diamond (hard science questions) | 74.42 | 83.69 | 74.90 | 72.42 |
These are the vendor's numbers under the vendor's setup. On tool calling (BFCLv4) it is a tie with Qwen, 65.01 against 65.00. Gaps as large as 27.69 against 2.61 on AutomationBench are exactly what an independent run should check first.
Liquid says it writes 184 word pieces a second on a high-end Apple laptop chip (M5 Max), and 114 on an AMD Ryzen AI Max+ 395. Taking a page as about 650 word pieces, our arithmetic puts that at a page of text every three or four seconds on the Apple chip. But this model always thinks before it answers, and that hidden reasoning comes first: those word pieces count in the speed figure and in the wait before the first word of the answer, so the visible answer arrives slower than these numbers suggest. That is with an even smaller copy of the model, which Liquid made for laptops. By Liquid's count, it is up to 1.7 times faster than the next-best model it tried. On one top-end data-center card (an NVIDIA B300) answering many people at once, Liquid reports over 21,000 word pieces per second, added up across all of them. One person sees only a small share of that.
Why one 48 GB card should be enough, on paper
On paper, yes: the compressed model takes about half of a 48 GB card, and even a conversation at the maximum length needs only about 2.7 GB more.
The official compressed copy stores most of the model's numbers at half the precision, which halves the file: 24.8 GB against about 48 GB for the full-size one. Liquid recommends this copy for high-throughput serving on GPUs, with lower memory use.
This whole paragraph is our arithmetic on the config file, not a measurement. The file leaves about 23 GB of the card free. The program that runs the model takes some of that for itself, and we have not measured how much. The rest holds each conversation's memory of what was said, and here the 10-out-of-40 design helps a lot. A conversation at the full 131,072-word-piece length needs about 2.7 GB of that memory. A model where all 40 steps looked back would need four times that. So one card should have room for the model and several long conversations at once.
One honest limit on the "2B per word piece" idea, and this is our reasoning, not a measurement. The saving is clearest when one person is talking to the model. When many people use the model at once, their word pieces each pick different specialists, so soon most of the 64 are busy. Fetching each busy specialist from the card's memory takes time, so with many users the model starts to behave more like a classic 24B one and its speed advantage shrinks. That is also why Liquid's 21,000 figure says nothing about how fast one person gets an answer.
The license, in plain words
The model ships under the LFM Open License v1.0, and the clause that matters is short:
- The license sets a threshold of 10,000,000 US dollars of annual revenue.
- Commercial use is allowed only while you, or your "Legal Entity", stay under it.
- "Legal Entity" counts every company that controls you, that you control, or that is under common control with you.
- "Commercial Use" is broad: any use "for direct or indirect commercial advantage or monetary compensation". An internal tool that saves your team time can count.
- Above the threshold, commercial use "is not licensed under this Agreement". Non-commercial and research use by a qualified non-profit is exempt from the threshold.
- Breaking the terms ends the license automatically.
It works like a bar that lets local bands play for free. A band signed to a big label is measured by the label, not by the four people on stage. Above the line, this license does not cover the gig. Our reading is that you would then need a separate agreement with Liquid, but the license itself does not spell that out. If you share the model files with others, you include the license, mark your changes and keep the notices. If your company is near the line, or part of a group, this is a conversation for your lawyer, not for a blog post.
We spotted the model in the AI Search news roundup of 18 October (chapter at 37:47). Two details there need a correction. The host says the license is "mostly Apache 2.0" (a common license with no revenue limit), and it is not. The "48 gigabytes" he mentions is the full-size copy. The compressed one is about half that.
What we planned to measure
We have no speed numbers yet, because no GPU was ever rented. Here is the plan we would have run, in plain steps (the exact commands are in the engineers' section), and the one network permission that stopped it.
The GPU. One 48 GB graphics card, the kind you can rent by the hour, with a newer card as first choice and an older, slower one as a last resort. We have not checked that the compressed copy loads on any of them.
The software and why. vLLM, the program our platform uses to run models. It already knows this model's design, so it can separate the model's reasoning from its final answer and pick out its tool requests without extra code. This model needs a newer vLLM than the one we install by default, so the plan was to ask for a newer version just for this model.
The steps. Tell the platform which model and version to run, let it rent the card, then ask the model a few kinds of questions: one about code, one in Spanish, one that needs a tool, one that hides a fact deep inside a very long text, and several people asking at once. There is no code example to link, because the draft never ran and was never published.
What went wrong. The AI assistant running our test has a safety check, and it refused to open the network connection a rented GPU needs to receive questions from our platform. We chose not to work around it, so no GPU was rented.
Credit where it is due
Liquid AI trained the model on 36 trillion word pieces, then refined it by having it work inside real agent tools (OpenClaw, Hermes Agent, Pi and OpenCode). It released it in several versions, from the compressed copy for data-center cards to smaller ones for laptops, with support on day one in the main open-source programs that run models. The vLLM project already knows how this model is built and publishes a recipe with the settings to run it. AI Search put it in front of us. Our part this time is small: reading the files, checking the sizes, doing the memory arithmetic and writing the test plan.
What two billion parameters on duty buy in seconds, on one rented card, is still an open question. The script that will answer it is called bench.py.
For engineers
Checkpoint. LiquidAI/LFM2.5-24B-A2B-FP8, sha f54bf39547fd5b7955abb9fe8d1b151e31fbbddb, created 2026-10-12T22:19:54Z, last modified 2026-10-13T06:11:42Z, not gated, license_name: lfm1.0. 10 safetensors shards (1,857,173,880 to 2,660,477,032 bytes), repo total 24,766,905,221 bytes (about 23.1 GiB). Safetensors parameters: 23,200,792,576 F8_E4M3 + 770,792,704 BF16 + 2,432 F32 = 23,971,587,712. BF16 repo LiquidAI/LFM2.5-24B-A2B: 47,964,602,405 bytes, sha 1769516a. Released variants: Base, post-trained, FP8, GGUF, ONNX, MLX-4bit. A DSpark draft model for SGLang speculative decoding is listed as "Coming soon".
Architecture (config.json): Lfm2MoeForCausalLM, model_type: lfm2_moe. 40 layers: 30 double-gated short convolution blocks and 10 GQA attention layers. 64 experts per MoE block, top-4 routing, moe_intermediate_size 1536, 2 dense layers. Hidden 2048, 32 attention heads, 8 KV heads, vocab 128,000, max_position_embeddings 131,072, rope_theta 1e7, tied embeddings. Card: 24.0B total, 2.45B active. The chat template inserts <think> when the assistant turn starts (always-on reasoning).
Active parameters under load. 2.45B active is per token. With batched requests, different tokens route to different top-4 sets, so the union of experts read per decode step grows with batch size and the memory-bandwidth advantage over a dense model narrows. The B300 figure below is aggregate throughput, not per-user decode speed.
Quantization. compressed-tensors FP8_BLOCK: weights FP8 static in 128x128 blocks, activations FP8 dynamic per group of 128. Not quantized: lm_head, model.embed_tokens, MoE router gates, conv weights. SGLang launch on the FP8 card: python -m sglang.launch_server --model-path LiquidAI/LFM2.5-24B-A2B-FP8 (no SGLang version given).
KV cache, by arithmetic (not measured). Only the 10 attention layers keep KV: 10 x 8 KV heads x 64 head_dim x 2 (K and V) x 2 bytes = 20 KiB per token, about 2.5 GiB for a full 131,072-token sequence. head_dim 64 is assumed as 2048 / 32. The config has no explicit head_dim. Conv layers keep a small fixed per-sequence state (conv_L_cache 3).
Training (card and blog): 36T token budget. Pre-training about 33T (up from about 17T for LFM2-24B-A2B). Mid-training 2T tokens at 32K, then 300B tokens at 131K. Context grew from 32K to 131K and vocab from 65K to 128K through in-place tokenizer expansion. Post-training: SFT, teacher specialization, two on-policy distillation stages (non-agentic and agentic), agentic RL inside OpenClaw, Hermes Agent, Pi and OpenCode.
Tools and sampling. Tool calls are Pythonic lists between <|tool_call_start|> and <|tool_call_end|>. Recommended sampling, also in generation_config.json (so vLLM applies it by default): temperature 0.1, top_k 50, repetition_penalty 1.05.
Serving with vLLM. Liquid's vLLM docs: LFM2.5 architectures ship in vLLM 0.23.0 and later. Leave max_tokens unset unless you mean to cap output, since a low cap cuts reasoning models off mid-thought. Pass top_k, min_p and repetition_penalty through extra_body. The vLLM recipe for LFM2.5: native support for Lfm2MoeForCausalLM (no --trust-remote-code), min_vllm_version 0.23.0, --reasoning-parser qwen3, --enable-auto-tool-choice --tool-call-parser lfm2. The recipe text lists the 8B-A1B as the MoE example and does not name the 24B-A2B. Our docs facts come from a copy of the Liquid page saved on 2026-10-19 (the live fetch was blocked).
Planned command, never run:
vllm serve LiquidAI/LFM2.5-24B-A2B-FP8 \
--max-model-len 131072 \
--reasoning-parser qwen3 \
--enable-auto-tool-choice --tool-call-parser lfm2
with the workload's vllm_version pinned to 0.31.0. That release requires torch 2.13.0 built for CUDA 13, so the plan restricted pods to CUDA 13.x hosts. The InferenceKey worker default is DEFAULT_VLLM_VERSION = "0.20.0", overridable per workload with vllm_version, which the worker passes to pip install vllm==<version>.
Planned GPU. L40S 48 GB first, RTX 6000 Ada 48 GB as fallback, A40 48 GB as last resort (Ampere, FP8 through Marlin, slower). Container disk 80 GB. No pod was created.
Vendor speed claims. 184 tok/s decode on Apple M5 Max and 114 tok/s on AMD Ryzen AI Max+ 395 (llama.cpp, Q4_K_M, 4K-token input, Liquid's Pipette infrastructure). Over 21K output tok/s on one NVIDIA B300 at high concurrency (SGLang 0.5.22, 1,024 input tokens, up to 256 output tokens, BF16 weights, total output tokens over wall time).
Full vendor benchmark table (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. tau3-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. All evaluated with vLLM. No dense-model comparison is published.
Liquid API pricing (blog): 0.10 USD per 1M input tokens, 0.05 USD per 1M cached input tokens, 1.00 USD per 1M output tokens. Day-one support for llama.cpp (GGUF), MLX, vLLM, SGLang and ONNX.
What blocked the test. A network permission on our side refused the connection a rented GPU needs to receive jobs from our platform, before any GPU was rented. No bypass was attempted, so there are no numbers.
Prepared, never run. bench.py: streamed reasoning, code and Spanish cases, a tool-call round trip, needle tests at 8K, 32K and 100K, and 4 and 8 parallel requests.
Limits.
- No InferenceKey measurements of any kind for this model: no tokens/s, time to first token, VRAM, quality or samples.
- Untested: whether the FP8 checkpoint loads and runs on vLLM 0.23+ or 0.31.0 on an Ada 48 GB card, or on an A40 through Marlin.
- The KV figure is arithmetic with an assumed head_dim. The free-memory figure is card size minus weights only: vLLM reservation, CUDA context and activation memory were not estimated or measured.
- The "2B active" saving is per token. It does not promise per-user speed under concurrent load.
- No SGLang version is documented for the FP8 checkpoint.
- All benchmarks and speed figures are Liquid's, with comparisons only against other MoE models.
- The license reading above is ours, not legal advice. The license has no governing law clause.
Sources: model card, FP8 card, license, Liquid blog, Liquid vLLM docs, AI Search roundup.