News · 2026-08-04

Liquid Shipped a 2.6B Tool-Calling Model and Told You Not to Code With It

Liquid AI released LFM2.5-2.6B on August 4, a roughly 2.7-billion-parameter model with a 128,000-token context whose architecture rations attention hard: 22 of its 30 layers are short convolutions and only eight are grouped-query attention. Liquid built it for tool calling and multi-step agent environments, and its own model card recommends against using it for agentic coding or knowledge-heavy work. That combination - narrow competence bought with architectural sacrifice - is the honest shape of the small-model story.

Key facts

• About 2.7B parameters, 128k context, 22 short-convolution layers plus 8 grouped-query-attention layers.
• Post-trained inside real agent harnesses via supervised tuning, specialist-teacher distillation and reinforcement learning; it always enters a reasoning mode before answering.
• Liquid claims roughly 30 generated tokens per second on a phone, without naming the phone, quantisation, runtime or prompt length.
• Primary sources: the model card, the release post and the technical report.

What the architecture actually buys

Attention is the expensive part of a transformer. Every token looks at every other token, which is exactly what makes long context both powerful and costly - and it is why the key-value cache balloons as a conversation grows. Convolutions are the cheap alternative: each layer mixes a token with its near neighbours, using a fixed small window, with no cache to grow.

Liquid's technical report describes an edge-constrained architecture search that landed on leaving most token mixing local and cache-friendly, then spending its attention budget on eight layers that handle genuine long-range interaction. Grouped-query attention trims further by sharing key and value heads across query heads.

The analogy is an office where most people only talk to the desks next to them, and a handful of coordinators carry messages across the floor. It is dramatically cheaper than everyone emailing everyone. It also means a fact on the far side of the building takes a specific path to reach you - which is why "supports 128k context" and "reliably retrieves anything from 128k of context" are different claims.

Tool calling, precisely

Worth being clear about what tool calling means here, because it is routinely misunderstood: the model does not execute anything. It emits a structured function call as text, the surrounding harness runs it, and the result comes back for a final answer. That is the whole tool use and function calling protocol.

For a compact model this matters more than usual. LFM2.5 is buying compatibility with an agent wrapper, not replacing the wrapper's code, permissions, browser or sandbox. An early community test reported consistent tool calls but a failure on a multilingual file-retrieval task - one anecdote, not a benchmark, and posted by a new branded account with its own product to promote.

The other small-model story of the day, corrected

Alongside this, a claim circulated that Gemma 4 now runs in 500 megabytes. It does not, in the sense people took it. The artifact is Gemma Gem, a third-party Chrome extension that packages the existing Gemma 4 E2B checkpoint in ONNX format with 4-bit weights so WebGPU can run it in the browser. The 500MB is the cached download on disk.

This is the single most useful lesson in today's small-model pile, so it is worth stating flatly: fits in storage is not fits in memory, and loads in a browser is not runs comfortably on any laptop. Quantization reduces the precision of stored weights. It does not erase the key-value cache, the activations, the browser's own overhead, or the model's tool loop. The Gemma Gem project says so itself, estimating materially larger GPU and system-memory requirements and noting those estimates have not been benchmarked on real devices.

The extension is genuinely interesting for another reason: it grants its local agent page-reading, clicking, typing, screenshot and JavaScript tools. That is real capability, and it is entirely separate from model intelligence - a distinction the agent harness literature keeps making the hard way.

Why it matters

Two audience narratives are colliding this week - open models getting cheaper, and AI moving onto ordinary hardware - and today's releases sit at their intersection. But the credible through-line is not a run of miracles. It is that builders are trading away some combination of generality, precision, long-context efficiency, runtime portability or test disclosure to move useful agent behaviour closer to the device.

Liquid is unusually candid about which trade it made. A card that says "do not use this for coding" is more informative than a benchmark table. It tells you the model was optimised for a shape of work, and that shape does not include the thing most people would try first.

The honest caveat

Every performance number attached to this release is Liquid's. The phone claim in particular is under-specified to the point of being unusable: without the handset, the quantisation, the runtime and the prompt length, 30 tokens per second is a number without a unit test. Liquid's earlier LFM2 report did publish a full protocol on a named phone with a named quantisation, which makes the omission here conspicuous rather than sinister - but it still means nobody outside Liquid can reproduce it. The defensible line is that Liquid demonstrated a local phone agent, and has not yet made that a reproducible phone benchmark.

Primary source, verified: read the paper →

Ground Truth. (2026, August 4). Liquid Shipped a 2.6B Tool-Calling Model and Told You Not to Code With It. Ground Truth. https://groundtruth.day/news/liquids-2-6b-tool-calling-model-tells-you-not-to-code-with-it.html

@misc{groundtruth:liquids-2-6b-tool-calling-model-tells-you-not-to-code-with-it,
  title  = {Liquid Shipped a 2.6B Tool-Calling Model and Told You Not to Code With It},
  author = {{Ground Truth}},
  year   = {2026},
  month  = {aug},
  url    = {https://groundtruth.day/news/liquids-2-6b-tool-calling-model-tells-you-not-to-code-with-it.html}
}

Topics: small-models · on-device · edge-ai · tool-use · liquid-ai · open-weights · quantization