LFM2.5-24B-A2B: run local agents or use the API
LFM2.5-24B-A2B is Liquid AI’s downloadable reasoning model for text and tool agents. It has 24B total parameters and activates about 2B per token. Use the Liquid API to start without managing weights, or serve the model locally when keeping the agent’s data on your hardware matters. The current API tariff is $0.05 per million input tokens, $0.025 for cached input and $0.70 for output.
Content reviewed:

Use this model
Online access and trials
- Liquid Playground
Availability and signup terms are set by the provider.
API docs and console
- Liquid Console
Provider account and usage billing apply.
Official model repository
- Open the official model card
Model card, downloads and license conditions.
Local tools and guides
- Ollama tags, sizes and exact model names
Follow the tool’s installation and hardware requirements.
Use cases
- Run a local agent that reads text, plans steps and calls your tools.
- Use hosted inference for a small trial before downloading and operating the model.
- Compare a complete agent task across reasoning models, including generated reasoning and retries.
Choose the API or the downloadable checkpoint
Liquid’s Console offers hosted inference; its Playground is another way to try the model. For self-hosting, use LiquidAI/LFM2.5-24B-A2B for the post-trained reasoning model. The separately named Base checkpoint is intended for customization. The model card lists a 131,072-token context window and 16 languages.
This is a text-generation model. Tool calling lets an application execute actions; the application still supplies the tools, permissions and stopping conditions. Start with a bounded task such as finding a fact in local notes, then check the returned answer and tool arguments.
LFM2.5-24B-A2B API pricing per task
As checked October 18, Liquid’s current pricing page lists LFM2.5-24B-A2B at USD $0.05 per million ordinary input tokens, $0.025 cached input and $0.70 output. Cache pricing applies to tokens the provider reports as cache hits; it is not a discount on every repeated prompt.
Assume a call bills 20,000 uncached input tokens and 1,000 output tokens. Input costs $0.001 and output costs $0.0007, for $0.0017 total. If 18,000 input tokens are cache hits and 2,000 are misses, the same output gives $0.00125. Ten identical uncached calls cost $0.017. These are arithmetic examples; use returned usage for your own agent loop.
The checkpoint is reasoning-only. Budget all billed output, rather than just the final answer, and count calls that are repeated or discarded. A cheaper individual request can still produce a more expensive completed task.
| Billed item | USD per 1M tokens |
|---|---|
| Uncached input | $0.05 |
| Cached input | $0.025 |
| Output | $0.70 |
Run the GGUF model with llama.cpp
Liquid publishes GGUF checkpoints for llama.cpp and compatible runners, and lists MLX, vLLM and SGLang paths. Choose the package for your machine and update to a runner that supports this exact checkpoint. The generic Liquid llama.cpp guide explains its server and command-line interfaces; benchmark numbers for a smaller LFM in that guide do not describe this 24B model.
For a first local session, use a modest context rather than allocating the full advertised window. The following server command selects Q4_K_M and a 4,096-token context. It downloads model weights and starts a local endpoint; it is a setup example, not a measured hardware recommendation.
llama-server -hf LiquidAI/LFM2.5-24B-A2B-GGUF:Q4_K_M -c 4096 --port 8080Use the explicit Ollama 24b tag
Ollama now lists lfm2.5:24b for this checkpoint. The tag selects the Q4_K_M package at approximately 15GB download size. The latest tag still points to the 8B model, so use the explicit 24b name when comparing this page’s model.
Install a current Ollama release, run the command below, then send a short text or tool task. The download size excludes context and runtime allocations; choose a context that fits your machine before expanding to the model’s full window.
ollama run lfm2.5:24bBudget memory for all 24B parameters
The 2B active figure describes computation per token. The rest of the model still has to be stored and made available to the runner. At a simple four-bit packing assumption, 24 billion weights alone contain about 12GB of numeric data; at two bytes per weight they contain about 48GB. Quantization metadata, mixed-precision tensors, runtime buffers, context state and the operating system add to that amount.
Inspect the actual download size and measure peak memory at your chosen context and concurrency. CPU offload can change where memory is held and how quickly the model responds. A 2B-active MoE should not be selected as though it were a 2B-weight dense model.
Read speed and agent results in their test conditions
Liquid reports 48.09 on LiveClaw and 27.69 on AutomationBench, alongside lower results than the compared Qwen model on WebArena and SWE-Bench Verified. These are publisher evaluations across different tasks, not a guarantee for your agent.
The model card’s device tests use llama.cpp, Q4_K_M and a 4K input context. Its B300 result is aggregate GPU output throughput under sustained concurrency, with SGLang 0.5.22, 1,024 input tokens and up to 256 output tokens in BF16. Compare single-user latency separately from concurrent serving throughput.
Check the tool loop as well as text generation
In an early LocalLLaMA report, Morphon described repeated tool-request formatting failures in PicoClaw, then an OpenClaw loop that repeatedly rebuilt a repository while failing to log into Forgejo. The same author reported fast text generation on consumer hardware. The post does not provide a controlled success-rate test. Before buying hardware for an agent, check a complete tool call and a stopping condition in your own harness; a responsive text stream does not establish that the task will finish.
Check the LFM Open License for commercial use
The weights use LFM Open License v1.0, which adds a commercial revenue condition to its Apache-derived terms. Liquid’s FAQ describes free commercial use for companies below $10 million in annual revenue; larger organizations need a separate arrangement. Review how the license defines the legal entity and threshold before distributing or deploying the weights. API charges and the downloadable-weight license are separate considerations.
Before you use it
- Local memory and speed depend on the exact weight format, context, runner and concurrency.
How to get started
Try one bounded task through the API, then compare the same task on your intended local runner. Record correctness, total billed output, latency and peak memory.
Sources
Sources (8)
- Current exact-SKU input/cache/output API tariff ↗
Source checked:
- Current exact-model documentation ↗
Source checked:
- Ollama explicit 24b tag and Q4_K_M package ↗
Source checked:
- Early first-person tool-loop report and corrections ↗
Source checked:
- Liquid AI October 13 model release ↗
Source checked:
- Official model card, formats and evaluation settings ↗
Source checked:
- llama.cpp deployment guide ↗
Source checked:
- LFM Open License ↗
Source checked: