How Much To Run AI
Open weights

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:

LFM2.5 has 24B total weights and 2B active parameters per token; API routes price input, cached input and output separately.
Model size and API billing are separate parts of the budget.

Use this model

Online access and trials

API docs and console

Official model repository

Local tools and guides

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 itemUSD 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.

Start a local OpenAI-compatible endpoint
llama-server -hf LiquidAI/LFM2.5-24B-A2B-GGUF:Q4_K_M -c 4096 --port 8080

Use 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.

Download and run the Ollama 24B model
ollama run lfm2.5:24b

Budget 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)

Calculators