LFM2.5-24B-A2B: 16 GB Local Agent vs Haiku 5.5

Liquid AI released LFM2.5-24B-A2B on 13 October 2026. It's a 24B mixture-of-experts model with 2.45B active parameters, trained with reinforcement learning inside agent harnesses including Hermes Agent, OpenCode, OpenClaw and Pi. Liquid's pitch is a tool-calling agent that runs on your own machine.

Two questions decide whether it belongs in your setup. Does it fit your GPU at the context length an agent actually reaches? And is running it locally cheaper than paying Liquid's API, or Claude Haiku 5.5, for the same session? I worked out both from the config file, the GGUF file sizes and the official price lists. Short version: a Q4 build with 128K of context fits on a 16 GB card if you quantize the KV cache, and on the API, Haiku 5.5 beats it on cost even after Haiku's 100K price line kicks in.

Table of Contents

• What LFM2.5-24B-A2B is
• Why the KV cache is tiny
• Memory by quant and context
• Which card it fits
• One agent session, costed on two APIs
• Running it locally in Hermes Agent
• Where it wins and where it doesn't
• Four catches before you switch
• FAQ
• Conclusion
• Sources

What LFM2.5-24B-A2B is

Liquid calls it the largest and final model in the LFM2.5 family. It ships as BF16 safetensors plus FP8, GGUF, ONNX and MLX 4-bit builds, with day-one support in llama.cpp, vLLM, SGLang and MLX.

Why the KV cache is tiny

Only 10 of the 40 layers are attention layers. The other 30 are short convolutions with a 3-token window, and they keep a fixed state of well under 1 MiB per conversation that doesn't grow with context.

From config.json: 32 attention heads over a hidden size of 2,048 gives a head dimension of 64, and there are 8 KV heads. So the cache per token at FP16 is:

2 (key and value) x 10 layers x 8 KV heads x 64 x 2 bytes = 20,480 bytes, or 20 KiB per token.

At the full 131,072-token context that's 2.50 GiB. If all 40 layers kept a KV cache, the same context would cost 10 GiB, four times as much.

Memory by quant and context

Liquid's GGUF repo lists these file sizes. GPU memory is counted in binary units, so I converted each to GiB, then added the KV cache at FP16 and at q8_0.

These totals cover weights plus KV cache. llama.cpp's compute buffers and the CUDA context come on top, so leave roughly 1 GiB spare.

Which card it fits

• 12 GB card: no full-GPU fit. The smallest file, QAD-Q4_0, is 12.65 GiB on its own. You can offload some experts to system RAM, and with only 2.45B active parameters per token an MoE handles that better than a dense 24B would. It will still be slower.
• 16 GB card (RTX 4060 Ti 16 GB, 4070 Ti Super, 5070 Ti): Q4_K_M at 32K fits with about 1.8 GiB to spare. For the full 128K, use a q8_0 cache (14.86 GiB) or the QAD-Q4_0 file (13.97 GiB with a q8_0 cache). Q4_K_M with an FP16 cache at 128K is 16.03 GiB, which doesn't fit.
• 24 GB card (RTX 3090, 4090): Q6_K with the full 128K context at FP16 cache, 20.84 GiB.
• 32 GB card or a 32 GB+ Mac: Q8_0 fits, with caveats. 26.24 GiB at 128K needs a 32 GB card. On a Mac, macOS keeps part of unified memory for itself, so a 32 GB machine is tight at Q8_0. Q6_K is the safer choice there.

You can check any of these in the AI VRAM Calculator. It now has an LFM2.5-24B-A2B preset that counts only the 10 attention layers. The calculator's lowest weight precision is INT4, which is close to Q4_K_M. For the method behind these numbers, see the local LLM VRAM guide.

One agent session, costed on two APIs

If your hardware doesn't fit, or you want a hosted fallback, Liquid sells the model at $0.10 input, $0.05 cached input and $1.00 output per 1M tokens. The obvious rival at that price is Claude Haiku 5.5: $0.10 input, $0.01 cache read, $0.125 cache write (5 minutes) and $0.50 output, for prompts up to 100,000 tokens. Over that line the whole request bills at $0.50 input, $0.05 cache read, $0.625 cache write and $2.50 output.

The session is a typical local-agent run in Hermes Agent or OpenCode:

• a 25,000-token prefix (system prompt and tool schemas)
• 30 turns, each adding 2,000 tokens of tool results and user input
• 1,200 output tokens per turn, thinking included, and the history accumulates
• every earlier token is a cache hit on the next turn, and everything new is written to cache

The prompt starts at 27,000 tokens and reaches 119,800 on turn 30. It crosses Haiku's 100K line on turn 24. Across the session that's 2,082,200 cache-read tokens, 119,800 fresh input tokens and 36,000 output tokens.

Haiku 5.5 is 26% cheaper even though seven turns pay its long-prompt prices. Without the 100K line, Haiku would cost $0.054, about a third of the Liquid bill. The gap comes from cache reads: they are two thirds of Liquid's bill, and Liquid charges $0.05 for them against Haiku's $0.01.

Liquid's blog doesn't list a separate cache-write price, so I billed fresh tokens at the $0.10 input rate. Cache misses hurt Haiku more: a missed token costs it $0.125 instead of $0.01, while on Liquid it goes from $0.05 to $0.10. Haiku's lead holds while at least 92% of the history hits the cache. At an 8.4% miss rate the two bills meet, and at 10% Haiku costs $0.170 against Liquid's $0.163. Log cached tokens per turn before you decide.

Run your own token mix in the API Cost Calculator, which now lists LFM2.5-24B-A2B at Liquid's rates. The API isn't where this model makes sense, though. Its case is that the session above costs nothing per token on a 16 GB card you already own, and your files never leave the machine.

On speed, Liquid measured 184 tokens per second decode on an Apple M5 Max and 114 on an AMD Ryzen AI Max+ 395, using Q4_K_M at a 4K-token input. At those rates the session's 36,000 output tokens take about 3.3 and 5.3 minutes of pure generation. Expect slower decode as the context grows past 100K.

Running it locally in Hermes Agent

Download the Q4_K_M file and serve it with llama.cpp:

huggingface-cli download LiquidAI/LFM2.5-24B-A2B-GGUF \
  LFM2.5-24B-A2B-Q4_K_M.gguf --local-dir .

# 16 GB card: full 128K context with a q8_0 KV cache (about 14.9 GiB)
llama-server -m LFM2.5-24B-A2B-Q4_K_M.gguf \
  --jinja -ngl 99 -fa on -c 131072 \
  --cache-type-k q8_0 --cache-type-v q8_0 --port 8080

--jinja applies the chat template embedded in the GGUF, which handles the <think> block and the tool-call tokens. On a 24 GB card, drop the two --cache-type flags.

Then point Hermes Agent at it. These are the settings from Liquid's model card:

hermes config set model.provider custom
hermes config set model.base_url http://localhost:8080/v1
hermes config set model.default LFM2.5-24B-A2B
hermes config set model.context_length 131072
hermes config set model.api_mode chat_completions
hermes config set agent.tool_use_enforcement true

Liquid's recommended sampling is temperature 0.1, top_k 50 and repetition penalty 1.05. Set them on the server or per request. If you write tool schemas by hand, run them through the JSON formatter before the first call.

Where it wins and where it doesn't

Liquid compared it with three larger MoE models. Against Qwen3.6-35B-A3B, which has about 50% more total and active parameters:

The split is clear. It leads on tool dispatch and instruction following, the work of picking a tool, filling its arguments and obeying the system prompt. It trails on knowledge (GPQA Diamond) and on fixing real code (SWE-Bench, 51 against 66.2). Liquid says so too: it doesn't recommend the model for knowledge-heavy tasks alone and suggests pairing it with retrieval or web search.

For a local agent that reads mail, files notes, runs scripts and calls APIs, that's a good fit. For a coding agent that has to fix bugs in a large repo, a hosted coding model will finish more tasks per session.

Four catches before you switch

You can't turn thinking off. LFM2.5-24B-A2B is a reasoning-only model, and its chat template opens every answer with <think>. Those tokens bill as output on the API and take decode time locally. If your agent averages 1,000 more thinking tokens a turn than our 1,200, the 30-turn session gains $0.03 on Liquid's API, and locally about 2.7 more minutes at 184 tokens per second.

Tool calls are Pythonic by default. The model writes a Python-style list such as [get_status(id="12345")] between <|tool_call_start|> and <|tool_call_end|>. The embedded template handles the format, but check that your server returns structured tool_calls and not raw text. Liquid's card says you can ask for JSON calls in the system prompt instead.

The license has a revenue line. The LFM Open License v1.0 allows commercial use only while you or your company stay under $10 million in annual revenue. Above that you need a separate agreement with Liquid. Qwen and Gemma models don't carry that condition.

It went looking for answers during training. Liquid's launch post says that during RL the model searched git history and sites like GitHub and Hugging Face for task answers, and once worked out it was in a sandbox. Liquid tightened the sandboxes, and the reported scores come from sealed environments. Give it the same kind of sandbox: least-privilege tools and no write access it doesn't need.

FAQ

How much VRAM does LFM2.5-24B-A2B need? The Q4_K_M weights take 13.53 GiB. With 32K of context the total is 14.15 GiB, and with the full 128K it's 16.03 GiB at FP16 cache or 14.86 GiB at q8_0, before about 1 GiB of runtime buffers. Plan for a 16 GB card.

Can it run on a 12 GB GPU? Not fully on the GPU. The smallest GGUF, QAD-Q4_0, is 12.65 GiB. You can offload part of the model to system RAM, which costs speed.

Is it cheaper than Claude Haiku 5.5 on the API? Not while your cache hit rate stays above about 92%. Our 30-turn session costs $0.152 on Liquid's API and $0.112 on Haiku 5.5, because Liquid charges $0.05 per 1M cached tokens against Haiku's $0.01. Locally, you pay only for power.

Does it work in Ollama and LM Studio? Liquid publishes official GGUF files for llama.cpp and lists LM Studio among supported runtimes. Ollama also runs on llama.cpp. Confirm that tool calls come back structured before you wire it into an agent.

Can I use it commercially? Yes, if your organization's annual revenue is under $10 million. Above that line, the LFM Open License v1.0 doesn't cover commercial use.

Conclusion

LFM2.5-24B-A2B is a 24B model built for one job: running a tool-calling agent on your own hardware. Its 10-of-40 attention layout keeps the KV cache at 20 KiB per token, so a Q4 build with the full 128K context fits a 16 GB card if you quantize the cache. It leads larger MoEs on tool use and instruction following and trails them on knowledge and real coding work. As a hosted model it costs more than Haiku 5.5 for a cached agent session, $0.152 against $0.112, so local is the reason to pick it. If you have a 16 GB card and run Hermes Agent or OpenCode, it's worth an afternoon of testing. Check the license first if your company is near $10 million in revenue.

Sources

• Hugging Face, LiquidAI/LFM2.5-24B-A2B model card: parameter counts, layer split, experts, context, vocabulary, sampling settings, chat template, tool-call format, Hermes Agent configuration, benchmark table, edge and GPU inference settings.
• Hugging Face, LiquidAI/LFM2.5-24B-A2B config.json and safetensors metadata: 40 layer types, 10 full-attention layers, 32 attention heads, 8 KV heads, hidden size 2,048, conv cache length 3, 23,971,585,280 parameters.
• Hugging Face, LiquidAI/LFM2.5-24B-A2B-GGUF file list: byte sizes of QAD-Q4_0, Q4_K_M, Q5_K_M, Q6_K, Q8_0 and BF16 files.
• Hugging Face, LiquidAI/LFM2.5-24B-A2B LICENSE: LFM Open License v1.0, $10 million annual revenue threshold.
• Liquid AI, "LFM2.5-24B-A2B: Built for Fast On-Device Agents" (liquid.ai/blog/lfm2-5-24b-a2b, 13 October 2026): release date, training changes, reward-hacking note, benchmarks, decode speeds, API prices.
• Anthropic, Claude pricing docs (platform.claude.com/docs/en/about-claude/pricing, read 15 October 2026): Haiku 5.5 rates under and over 100,000 prompt tokens.
• KV cache, GiB conversions, card-fit figures and session costs are calculated by ToolMintX from those sources. Compute buffers and runtime overhead are not included.