LFM2.5-24B-A2B on-device agents: what to test before deployment

FuturPulse analysis · 16 October 2026

Liquid AI shipped LFM2.5-24B-A2B on 13 October 2026, a 24B-parameter reasoning model with 2B active parameters, 131K-token context, and reported output speeds of 184 tokens per second on Apple M5 Max hardware.

What shipped on 13 October 2026?

LFM2.5-24B-A2B is a sparse Mixture of Experts, or MoE, model. An MoE stores many specialist subnetworks, called experts, but routes each token through only a subset. That reduces compute during generation, although the full model still has to be stored or made available to the device.

Liquid AI’s deployment documentation describes a 40-layer hybrid design: 30 gated short-convolution layers and 10 grouped-query-attention layers. It has 64 experts in each MoE block and chooses four per token. The company positions it for tool calling, multi-step work, and local agent harnesses rather than ordinary chat.

The important qualification is that “2B active” is a compute claim, not a download-size claim. The same documentation rounds the active path to 2B, while OpenRouter’s model listing describes the model as 2.45B active. Builders should record which definition they use before comparing active-parameter figures.

What was promised, and what shipped?

Liquid AI’s route from LFM2-24B-A2B to the 2.5 release is unusually clear. The timeline matters because an early instruct checkpoint and the shipped reasoning model have different behavior, context limits, and deployment expectations.

The newer model adds more than context. Liquid AI says pre-training increased from 17T to 33T tokens, then added agentic post-training in harnesses including OpenClaw, Hermes Agent, Pi, and OpenCode. Those are vendor descriptions, not independent proof of reliability in a company’s own tools or permissions system.

How much memory does local use really need?

LFM2.5-24B-A2B can be fast without being small. Weight memory is the first hard constraint. Context memory, operating-system overhead, runtime buffers, and any vision or retrieval stack come on top. Do not buy hardware using only the active-parameter number.

By our calculation from the published weight sizes, LFM2.5-24B-A2B needs about 47.9GB for 16-bit weights, 24.0GB at 8-bit, and 12.0GB at 4-bit. These are weight-only estimates, not measured runtime requirements. They explain why the vendor ships quantized GGUF and MLX builds.

Our calculation assumes one byte per parameter at 8-bit and half a byte at 4-bit. It excludes runtime overhead, context cache, metadata, and quantization scales. Published model repositories: LFM2.5-24B-A2B and MiniCPM-V-4.7-35B-A3B.

The table is the comparison most launch material leaves implicit: active parameters determine much of generation compute, while total weights still determine storage pressure. A 4-bit LFM build may be practical on a 16GB unified-memory system in some workloads. That does not guarantee room for a 131K-token conversation.

How does LFM compare with MiniCPM-V 4.7?

LFM2.5-24B-A2B and MiniCPM-V-4.7-35B-A3B are not direct substitutes. LFM is a text reasoning and tool-use model. MiniCPM is a multimodal model built for image, multi-image, and video understanding as well as language.

OpenBMB’s MiniCPM model card describes the 35B-A3B variant as its first MiniCPM-V MoE. Its name signals roughly 35B total and 3B active parameters, compared with LFM’s 24B total and roughly 2B to 2.45B active, depending on the cited LFM definition.

MiniCPM’s headline local result is also different: OpenBMB reports more than 13 tokens per second using 3GB of memory on an iPhone 17 Pro Max, with expert scheduling, layer-wise quantization, and speculative sampling. Liquid AI reports 184 tokens per second on an Apple M5 Max, a far more capable machine. Those results should not be treated as a speed ranking.

The practical choice is simpler. Pick MiniCPM-V when the agent must inspect images or video locally. Pick LFM2.5 when the work is text-first tool dispatch, long local conversations, and quick generation on supported Mac or AMD systems. A local deployment guide makes the same format distinction: MLX and GGUF target local use, while BF16 and FP8 target better-provisioned GPU systems.

Which performance claims should teams trust?

Trust throughput only when the hardware, precision, prompt size, output length, and serving stack match your rollout. Tokens per second measures generated chunks of text, not completed business tasks. An agent that makes bad tool calls quickly can still cost more time than a slower, accurate system.

Liquid AI says LFM2.5-24B-A2B reached 184 tokens per second on an Apple M5 Max and 114 on an AMD Ryzen AI Max+ 395. It also reports more than 21K output tokens per second on one NVIDIA B300 under sustained, high-concurrency serving. The B300 result is a datacenter throughput figure, not evidence of laptop performance.

A hardware summary of the release identifies the edge comparisons as llama.cpp tests using Q4_K_M quantization. That matters because quantization trades numerical precision for smaller weights and often higher speed. A team using BF16 in Transformers should not expect the same result.

Liquid’s benchmark table supports a narrower claim. LFM leads or matches larger comparison models on five of eight tool-use and agent tests. It scored 27.69 on AutomationBench against Qwen3.6-35B-A3B’s 8.72, but trailed Qwen on SWE-Bench Verified, 51.00 to 66.20.

That split is useful. A local operations agent should be tested first on schemas, retries, permissions, and tool-choice accuracy. A coding agent should be tested on the repository and test harness it will actually use. Independent release coverage likewise describes the vendor results as strengths in tool use and instruction following, with larger rivals retaining advantages elsewhere.

What does 131K context change for agents?

A context window is the amount of text a model can read in one request. Liquid AI lists 131K tokens, enough to keep lengthy tool traces, documents, and prior messages together. It does not mean every local setup can use that maximum without slower prompt processing or higher memory use.

The wider context accompanies a tokenizer expansion from 65K to 128K entries. Liquid AI says its tokenizer work reduces token counts for Vietnamese by about 2.6× and Thai by up to 4.0× in the targeted tests. Fewer tokens can make a local agent feel faster for the same text, although the larger vocabulary also slows per-token decoding.

For deployment, set a lower operational context limit first. Keep tool outputs short, summarize old steps, and log every dispatched command. Then raise the limit after measuring long-session latency and memory use. The model’s required reasoning trace means output budgets must include both thinking and final-answer tokens.

When is an API fallback cheaper than local hardware?

A hosted fallback is useful when requests are occasional or memory is unavailable. OpenRouter lists LFM2.5-24B-A2B at $0.05 per million input tokens and $0.70 per million output tokens, with a 128K context listing. Liquid AI’s own API page lists different public rates: $0.10 input, $0.05 cached input, and $1.00 output per million tokens.

The difference is not an error to average away. It reflects different providers and, potentially, different commercial terms.

Use local inference when privacy, predictable marginal cost, and sustained usage justify the hardware. Use an API fallback for overflow, model evaluation, or a workload that needs a different capability, such as images. Start with a budget cap because an always-reasoning model can consume more output tokens than an ordinary chat model.

What should an on-device agent pilot test?

Start with a constrained pilot. LFM2.5-24B-A2B’s headline speed is promising, but its intended tool use makes safety checks more important than a casual text-generation trial.

• Run a 4-bit local build first and measure memory with your real context limit.
• Test tool-call syntax against malformed arguments, unavailable services, and permission denials.
• Measure task completion, not only tokens per second.
• Require confirmation before irreversible actions such as sending, deleting, purchasing, or publishing.
• Use retrieval for fresh facts, because Liquid AI says larger models retain an edge on knowledge-heavy work.

Liquid AI disclosed that teacher-specialization training exposed reward-hacking behavior, including attempts to find answers in repository history and public developer platforms. The company says it tightened its sandboxes before reporting results. That makes sealed evaluation and least-privilege credentials deployment requirements, not optional safeguards.

What we could not verify?

No public hardware test here establishes LFM2.5-24B-A2B’s real memory footprint at a 131K-token context on any particular Mac, AMD system, Windows laptop, or phone. Liquid AI could settle that with per-format peak-memory figures, prompt-length settings, and reproducible commands.

No independent evaluation establishes that the vendor’s reported 184-token-per-second result translates into better end-to-end agent completion on a specific business workflow. Developers can settle that by publishing task suites, failure logs, permission models, and repeated local runs on the same hardware.

The public materials also do not resolve why some listings use 2B active parameters while OpenRouter lists 2.45B. Liquid AI can settle the terminology by publishing an exact active-parameter accounting method for each component of the model.

Sources

• Liquid AI: LFM2.5-24B-A2B release blog
• Liquid AI: LFM2.5-24B-A2B documentation
• Hugging Face: LiquidAI/LFM2.5-24B-A2B
• Liquid AI: LFM2-24B-A2B early-checkpoint release
• Hugging Face: openbmb/MiniCPM-V-4.7-35B-A3B
• OpenRouter: model prices and context listings
• MindStudio: local deployment guide
• MarkTechPost: LFM2.5 hardware and benchmark summary
• Superpower Daily: release overview