Innhold Show
LFM2.5-24B-A2B is built for anyone who wants fast, private AI agents running on their own hardware instead of sending every task to an external API. The model has 24 billion parameters in total, but activates only 2.45 billion for each token. That makes sustained agent work on local hardware far more realistic than the headline size first suggests.
This is not a model designed to know a bit of everything and win every benchmark. Liquid AI has focused it on reasoning, tool calls and multistep tasks in agent frameworks including Hermes Agent, OpenClaw, Pi and OpenCode. It can be served locally through runtimes such as llama.cpp, MLX, vLLM and SGLang.
I think that is a sensible priority. A local agent does not necessarily need every fact stored in its weights. It needs to understand the instruction, choose the right tool, interpret the result and stay on course across several steps. LFM2.5-24B-A2B looks genuinely promising for that job, with one important caveat: the speed figures and evaluation results currently come from Liquid AI itself.
What is LFM2.5-24B-A2B?
LFM2.5-24B-A2B is a text reasoning model built with a mixture-of-experts architecture. According to the official model card, it has 24 billion total parameters, 2.45 billion active parameters, 40 layers and a context window of 131,072 tokens.
The A2B name is a rounded description of how much of the model works on each token. Every MoE block contains 64 experts, but only four are routed into the computation at a time. You still need the model weights available, so this is not a two-billion-parameter model in the ordinary sense. The advantage is that a much smaller part of the network performs computation for each token.
The model always runs in reasoning mode and produces an explicit thinking section before the final answer. Its context window has grown from 32,000 tokens in the previous version to 131,072, while the vocabulary has doubled from 65,000 to 128,000 tokens. Liquid AI lists support for 16 languages, but Norwegian is not among them. That does not prove the model cannot handle Norwegian, and it certainly does not prove that it can handle Norwegian well. The quality has not been tested for Norwegian customer conversations, dialects or documents.
Why is it a good fit for local AI agents?
The model has been trained for multistep work, tool calls and interaction with agent frameworks. Liquid AI used agentic trajectories during training and post-training, with the final stage including reinforcement learning inside OpenClaw, Hermes Agent, Pi and OpenCode. That is more relevant to an agent than being good at completing isolated questions in a chat window.
Tool use follows a clear sequence. The agent receives function definitions, creates a tool call, receives the result under the tool role and uses that result to formulate its final response. The default format resembles Python function calls, while the system prompt can request JSON. That last detail matters if your framework expects a particular format and would otherwise sit there staring blankly at a perfectly valid answer.
The model can sit behind a local OpenAI-compatible endpoint. An existing agent framework can then connect to a local address instead of an external model provider. Liquid AI provides configurations for several popular frameworks, and the model card includes examples for Hermes Agent, OpenClaw and Pi.
The privacy benefit is straightforward: prompts, documents and tool results can stay on the machine or inside your own network. But a local model does not make the entire agent private by magic. If you connect it to web search, cloud services, external databases or other APIs, data can still leave the machine through those tools. The model is local. Every other part of the workflow must be assessed separately.
How fast is LFM2.5-24B-A2B?
Liquid AI reports 184 tokens per second on an Apple M5 Max and 114 tokens per second on an AMD Ryzen AI Max+ 395. The company ran those tests with llama.cpp, Q4_K_M quantization and a 4,000-token prompt. It claims the model was up to 1.7 times faster than comparable MoE models in the same test.
On an NVIDIA B300, Liquid AI reports more than 21,000 output tokens per second at high concurrency. That figure describes total throughput with many requests in flight at once, not the speed one person will see from one prompt. The server test used BF16 weights, SGLang 0.5.22, 1,024 input tokens and up to 256 output tokens.
Those figures answer two entirely different questions. Single-stream speed matters most for an agent on a local Mac or PC. Aggregate throughput matters more for a server handling many agents at the same time. Do not put 21,000 tokens per second into the budget for an ordinary workstation and act surprised when physics meets marketing.
Real speed will also depend on quantization, memory bandwidth, context length, backend and how much reasoning the model performs. An agent that thinks for a long time and makes five tool calls can take longer to finish than a model that gives a short direct answer, even if its raw token generation is faster.
Is it good enough for tools and coding?
In Liquid AI’s own evaluations, the model leads or matches competitors on five of eight tool-use and agent benchmarks. It scores 80.71 on ToolSandbox and 65.01 on BFCLv4. On LiveClaw, it reaches 48.09 compared with 38.19 for Qwen3.6-35B-A3B. The results suggest that activating a relatively small part of the model does not prevent it from following instructions and handling tools.
The picture is less impressive everywhere else. The Qwen model performs better on WebArena Verified, while larger models keep an advantage on knowledge-heavy tasks and coding. On SWE-bench Verified with OpenCode, LFM2.5-24B-A2B scores 51.0 and Qwen3.6-35B-A3B scores 66.2. That is not a disaster. It is a fairly clear map of what this model was built to do.
I would not choose it as the only brain in a workflow where large code changes or broad factual knowledge are the main job. It is far more compelling as a local agent model for well-defined tasks, fixed tools and controlled data sources. Liquid AI itself recommends adding RAG or web search for knowledge-heavy work.
Benchmarks are not your workload anyway. The useful test is whether the agent selects the right tool, sends the right arguments, detects errors and completes the whole job without forcing you to rescue it halfway through. Measure approved outcomes and failure rates, not just tokens per second.
What do you need to run it locally?
Liquid AI provides the original model for Transformers, vLLM and SGLang, an FP8 build for high GPU throughput, GGUF quantizations for llama.cpp and compatible tools, a 4-bit MLX build for Apple Silicon, and ONNX versions for broader hardware support. The model card links the official variants.
There is no single universal memory requirement, and giving one would be misleading. Memory use depends on the format, quantization, backend and how much of the context window you actually use. Activating only 2.45 billion parameters per token does not mean that only those weights need to be available. Choose the build for your machine instead of treating A2B as a memory specification.
Direct use with Transformers requires transformers>=5.0.0. The basic installation command is pip install -U transformers, after which the model can be loaded as LiquidAI/LFM2.5-24B-A2B. Flash Attention 2 can be enabled on a compatible GPU, but it is optional and not a requirement for loading the model.
For agent use, serving the model behind an OpenAI-compatible API is the cleanest approach. The port depends on the backend: llama.cpp and MLX commonly use 8080, vLLM uses 8000, SGLang uses 30000, and LM Studio uses 1234. Point the agent framework to the correct base_url, use LFM2.5-24B-A2B as the model name and configure the 131,072-token context window.
What are the important limitations?
This is a text model. It does not accept images, audio or video as input. Liquid AI also does not recommend it as a standalone solution for knowledge-heavy work, and Norwegian is not among the 16 languages the company lists. The model reasons before every answer as well. That can help with agent tasks but may spend unnecessary tokens on very simple requests.
The weights are available under Liquid AI’s LFM1.0 license. Open weights do not automatically mean a conventional open-source license without additional terms. If you plan to build the model into a product or use it commercially, read the current license and its documented conditions and thresholds before investing in the integration. A loose summary is not good enough for that decision.
The results are also vendor measurements. Liquid AI documents the evaluation settings in useful detail, but independent testing would give a firmer picture. Compare the model with whatever you already use on the same tasks, with the same tools, permissions and stopping criteria.
There is a more practical limitation too. A 131,072-token context window tempts people to throw absolutely everything into the prompt. That can increase memory use, reduce speed and make the agent less precise. Clean context, accurate tool descriptions and targeted retrieval often beat one enormous unsorted prompt.
Who should try LFM2.5-24B-A2B?
The model is most compelling for developers and smaller businesses that want to keep data local, have clearly defined tools for an agent to use and want low computation per reasoning token. It is also a natural experiment for anyone already using llama.cpp, MLX, LM Studio, vLLM or SGLang and looking to connect a local model to an existing agent framework.
Start with the right quantization for your machine. Then connect the model to one limited toolset and one task whose result you can check. Log tool calls, failures, completion time and how often the result can actually be approved. That is when you find out whether the model is fast in the way that matters.
If the workflow needs fresh or extensive factual knowledge, add search or RAG from the start. If heavy coding is the main task, compare it with a stronger coding model before deciding. LFM2.5-24B-A2B does not look like the new king of everything. It looks like an unusually focused tool for local agents, and that may be much more valuable.
I like this direction. Local models become genuinely useful when they can do work instead of merely answering inside a chat window. LFM2.5-24B-A2B combines a low active parameter count, long context and practical agent-framework support in a way that deserves a proper test on your own hardware. Just keep the measuring tape close. Vendor numbers are the beginning of the evaluation, not the end.
Frequently asked questions
Can LFM2.5-24B-A2B run without internet access?
Yes. The model itself can be downloaded and run locally through llama.cpp, MLX, Transformers, vLLM or SGLang. The agent will still need internet access if you give it tools that use web search, external APIs, cloud services or remote databases.
Is LFM2.5-24B-A2B really a two-billion-parameter model?
No. It contains 24 billion parameters in total but activates 2.45 billion for each token. The full model still has to be available in memory or storage, while the mixture-of-experts routing reduces how much computation is used during generation.
Can I use LFM2.5-24B-A2B with LM Studio?
Yes. Liquid AI lists LM Studio as a supported way to run the model locally, and the GGUF builds target llama.cpp and compatible applications. Check that your current application version and chosen quantization support the model before downloading it.
Is LFM2.5-24B-A2B a good choice for Norwegian?
That has not been established. Norwegian is not among the 16 languages Liquid AI lists, and the available evidence does not include tests of Norwegian comprehension, dialects, tool calls or writing quality. A language list or an English benchmark would not answer that question.
