LFM2.5-24B-A2B on the Qtum Router: an agent model at $0.03 per million output tokens

LFM2.5-24B-A2B, the agent model Liquid AI released on 13 October, is now live on the Qtum AI Router — and the headline is the price: 10 credits per million input tokens and 30 per million output. That is $0.01 and $0.03.

It is not coming to you through a reseller. We run it on our own GPUs, which is how it lands at a tenth of the price of Liquid's own API on input and a thirty-third on output.

Credits, live from the models page. 1,000 credits = USD 1. Liquid's price is from its launch post.

What LFM2.5-24B-A2B is

Liquid AI builds models on its own architecture rather than on a stock transformer. LFM2.5-24B-A2B is the largest model in its LFM2.5 family, and Liquid's own one-line pitch is that it is built for fast on-device agents: a model meant to reason, call tools and keep going through a multi-step task without needing a datacentre.

The name tells you most of it. 24B is the total parameter count. A2B is the part that matters for speed: about 2.45 billion parameters are active per token.

Two design choices make that work:

• A hybrid backbone. Of its 40 layers, 30 are double-gated short convolution blocks and only 10 use grouped-query attention. Convolutions are cheap and local; the few attention layers carry the long-range work. The result keeps a full 131,072-token context without paying attention's cost on every layer.
• A sparse mixture of experts. Each MoE block holds 64 experts and routes every token to just 4 of them. The model knows as much as a 24B network, but each token pays for roughly a tenth of it. That is the picture on this post's cover: sixty-four cells, four lit.

It is also reasoning-only. Unlike its predecessor LFM2-24B-A2B, it always thinks before it answers, and it was post-trained with reinforcement learning inside real agent harnesses — OpenClaw, Hermes Agent, Pi and OpenCode — rather than only on static benchmarks. It reads and writes 16 languages, including English, Chinese, Japanese, Korean, Arabic, Spanish, French, German and Russian. It is text in, text out.

Where it is strong, and where it is not

Liquid compares it with three larger mixture-of-experts models. The headline rows from Liquid's launch post:

The pattern is clear. It leads on tool use, automation and following instructions exactly. It is ahead of a model with half again as many parameters on most agent benchmarks. It trails on hard science questions and real-world coding. Liquid says so itself: it recommends the model for agents that need to reason, call tools, and run reliably, and says it is not meant for knowledge-heavy tasks on its own — pair it with retrieval or search.

Our own testing agrees. On structured jobs — classifying a support ticket, pulling fields out of a sentence, planning and making a tool call — it was quick and exact. When we asked it open-ended factual questions about databases, it answered fluently and sometimes wrongly. Give it the facts and the tools, and let it do the work.

These are Liquid's own numbers, published on launch day from its own vLLM evaluations. Nobody outside Liquid has reproduced them yet.

Where the saving actually lands

Take one ordinary agent turn: 20,000 tokens of context in, 2,000 tokens out.

A thousand of those turns cost 260 credits — 26 cents.

Count those 2,000 output tokens carefully, because this model will use them. Its reasoning is billed as output like everyone else's, and it reasons on every request: in our tests a two-sentence answer could follow more than a thousand tokens of thinking. Cheap output is exactly what a model like this needs, and at $0.03 per million that thinking stops being something you budget for.

It is not the cheapest model on the Router. The three Gonka Network models run at a flat 6 credits per million. They are general-purpose models on shared decentralized compute. LFM2.5-24B-A2B is a specialist trained for agent loops, served from dedicated hardware. Use whichever fits the job — they share one key.

How we serve it

We run Liquid's official 4-bit build (Q4_K_M) on llama.cpp, across GPUs we operate ourselves, and each request gets the model's full 131K context to itself.

On that setup a single request generates at about 210 output tokens per second. The first token of a streamed reply arrived in under 0.2 seconds in our tests. Liquid's benchmark figures come from its own evaluations, not from the 4-bit build we serve, so expect it to land a little below them on the hardest tasks. That is the trade we chose for its speed and price.

Calling it

Same key, same endpoint, same OpenAI-compatible format as every other model in the catalogue. Liquid recommends a low temperature, so the examples use 0.1.

curl https://router.qtum.ai/v1/chat/completions \
  -H "Authorization: Bearer $QTUM_ROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "lfm2.5-24b-a2b",
    "messages": [{"role": "user", "content": "Classify this ticket as billing, bug or feature request, and say why in one line: \"I was charged twice for the October invoice.\""}],
    "temperature": 0.1,
    "max_tokens": 8192
  }'

The reply carries the answer in message.content and the model's thinking in a separate message.reasoning_content field, so you can log it, show it, or ignore it.

Tool calling uses the standard tools / tool_calls format. Liquid's model natively writes its calls in its own syntax; you never see that, because they come back as ordinary OpenAI tool_calls with JSON arguments:

import json, os
from openai import OpenAI

client = OpenAI(base_url="https://router.qtum.ai/v1", api_key=os.environ["QTUM_ROUTER_API_KEY"])

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up the shipping status of an order",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]
messages = [{"role": "user", "content": "Where is my order A-1042?"}]

resp = client.chat.completions.create(
    model="lfm2.5-24b-a2b", messages=messages, tools=tools, temperature=0.1,
)
call = resp.choices[0].message.tool_calls[0]
print(call.function.name, call.function.arguments)   # get_order_status {"order_id":"A-1042"}

# Run the tool yourself, then hand the result back.
messages += [resp.choices[0].message, {
    "role": "tool", "tool_call_id": call.id,
    "content": json.dumps({"status": "shipped", "eta": "Oct 27"}),
}]
final = client.chat.completions.create(
    model="lfm2.5-24b-a2b", messages=messages, tools=tools, temperature=0.1,
)
print(final.choices[0].message.content)

When streaming, the thinking and the answer arrive as separate deltas, and the last chunk carries the usage with an empty choices list. Handle that one case and the rest is the usual loop:

stream = client.chat.completions.create(
    model="lfm2.5-24b-a2b",
    messages=[{
        "role": "user",
        "content": 'Return JSON with keys payee, amount, currency, date: '
                   '"Paid Acme Corp $1,240.50 on 3 Oct 2026 for the Q4 hosting renewal."',
    }],
    temperature=0.1,
    stream=True,
)
for chunk in stream:
    if not chunk.choices:            # the last chunk carries only usage
        print("\n", chunk.usage)
        continue
    delta = chunk.choices[0].delta
    if getattr(delta, "reasoning_content", None):
        pass                         # the model's thinking, streamed separately
    if delta.content:
        print(delta.content, end="", flush=True)

Billing is settled from the token counts the model reports, not from an estimate, and a request that fails costs nothing. Agents that already speak to the Router — see the OpenClaw guide — switch to it by changing one model string, and OpenClaw is one of the harnesses Liquid trained it in.

What to know before you move a workload

A cheap model you have to debug is not cheap, so here is what to expect:

• Text only. A request carrying an image, audio or video is refused up front with a 400 and costs nothing. Send those to a multimodal model on the same key.
• Leave room for the thinking. If you omit max_tokens, the Router sets 8,192. If you set it yourself, do not set it tight: reasoning counts against the limit, and a model that runs out mid-thought returns a finished chain of reasoning and an empty answer.
• It is a dedicated pool, not a hyperscaler. Capacity is deliberately sized, so at peak a request may wait briefly for a free slot, and past a short queue it comes back as 429 straight away rather than hanging. Retry with backoff and you will rarely notice. For batch work, run a few requests in parallel rather than hundreds.
• Bring the facts. It is an agent and an instruction-follower, not an encyclopedia. Retrieval, search or a tool should supply the facts.

Try it on something real

Take an agent loop or an extraction job you already run on a bigger model, point it at lfm2.5-24b-a2b, and compare the output and the bill. A hundred turns of 20k in and 2k out comes to 26 credits — under three cents.

Create an API key → · Models and pricing → · Integration guide →

Prices are live as of publication; the models page is always authoritative. Model architecture and benchmark figures are from Liquid AI's model card and launch post.