Liquid AI’s New LFM2.5-2.6B Model Brings Agentic AI to the Raspberry Pi

The idea that a useful artificial intelligence agent could run on a device smaller than a smartphone, with no internet connection, and costing less than a hundred dollars, has moved from theoretical possibility to commercial reality. Earlier this week, Liquid AI, a startup founded in 2023 by former MIT computer scientists, released LFM2.5-2.6B, an open-weight language model designed specifically for agentic workloads that can operate entirely on local hardware. The model runs on everything from a smartphone to a Raspberry Pi, bypassing cloud inference entirely and opening the door for edge AI applications in regulated industries and environments where connectivity is limited or data privacy is paramount.

What LFM2.5-2.6B Is Designed to Do

LFM2.5-2.6B packs 2.6 billion parameters and supports a 128,000-token context window, with native tool-calling capabilities built directly into the architecture. The name itself encodes the model’s identity: the “2.5” refers to the generation of the architecture, while “2.6B” denotes the parameter count. This is not a general-purpose chatbot meant to compete with frontier models like GPT-4 or Claude. Instead, Liquid AI positions it as a specialized engine for high-volume, well-defined agentic tasks that run locally: tool calling, document management, calendar and workflow automation, and always-on background routines. It is particularly suited for connectivity-limited environments like vehicles and robotics, as well as for enterprises that handle sensitive information and cannot afford to send data to the cloud.

“I do also believe that the best models will be in the cloud, and there’s no problem with that,” Maxime Labonne, Liquid AI’s head of post-training, told VentureBeat. “We want to make models for another type of user, and the best way of describing it is: you should use [edge AI] when you can’t use a cloud model.”

Performance That Fits in Your Pocket

Labonne emphasized that the LFM2 architecture was explicitly designed around real-world CPU performance rather than GPU benchmarks. “I think the best example is a Raspberry Pi,” he said. “We have a lot of demos that show that actually, it works pretty fast on the Raspberry Pi.” Company-reported measurements back up that claim: decoding throughput reaches approximately 220 tokens per second on an Apple M5 Max and 113 tokens per second on an AMD Ryzen AI Maxaaaa+ 395, while consuming less than 2.5 GB of memory. On a smartphone, the model achieves around 30 tokens per second, and users can test it directly through Apollo, Liquid AI’s mobile app. At the other end of the deployment spectrum, when running on a single Nvidia H100 GPU under sustained concurrent load, Liquid reports nearly 15,000 output tokens per second — roughly 1.3 billion tokens per day on one card. These figures are vendor benchmarks and have not been independently verified.

For Labonne, these numbers are not just performance bragging points but hard constraints that determine what can actually be deployed. “What we want to show is that it’s a really good trade-off, because you get the level of quality that you get with much bigger models, but in a tiny, tiny form factor,” he said. “You can deploy it in target devices where you are not able to deploy the other ones at all.”

Trained for Agents, Not Chatbots

The model’s training regimen reflects a fundamental shift in how AI is consumed. “Models are not consumed in chatbots anymore. They’re really consumed through agentic harnesses, like OpenClaw, like Hermes Agent,” Labonne said. “We wanted to make sure that this model is not just good at math or at code, but it’s good at using tools.” LFM2.5-2.6B was pretrained on approximately 34 trillion tokens, with a vocabulary doubled to 128K tokens to better support non-Latin scripts. A dedicated mid-training phase extended the context window to 128K tokens, enabling long-running agent workflows.

The post-training pipeline is a four-stage process: supervised fine-tuning, teacher specialization (training separate expert models for instruction following, math, code, and tool use), multi-domain on-policy distillation (MOPD) to merge those experts’ capabilities back into a single student model, and finally agentic reinforcement learning. During that final stage, the model was trained directly inside production agent harnesses — including Hermes Agent and OpenClaw — on realistic productivity tasks involving research, coding, document management, tool invocation, and workflow automation. This exposed the model to those harnesses’ actual tools, system prompts, and interaction patterns.

Labonne described the pipeline overhaul as yielding a “happy accident”: gains that extended well beyond the agentic targets. “Through these new training techniques, we also got a lot better at everything. We got better at math, at instruction following. We’ve never been good at code, actually — and with this, we even got really good at code,” he said.

Building the Model and the Harness Together

Rather than relying solely on existing frameworks, Liquid AI built its own agent harness and demonstrated the model running inside it on a phone, planning and calling tools entirely on-device. “This is a harness running on a phone, and I don’t know if there’s any other harness running on a phone,” Labonne said. The company had two reasons for this: no phone-native harness existed, and Liquid wanted a different interaction model. Existing harnesses wait for a prompt; Liquid envisions assistants that act on their own. “We want proactive agents. We want agents that run in the background, check what you’re doing, check your calendar, and based on this context, do tasks,” he said. “That doesn’t exist today, really.”

Co-designing the harness and model also lets the software compensate for the model’s weak spots. “Everything that the model is bad at, the harness should help the model with — provide as much assistance as possible to make it more reliable,” Labonne said. “End users don’t care if it’s the model or the harness. What they want is that the task is achieved at the end of the day.” The model nevertheless works out of the box with established harnesses including Hermes Agent, OpenClaw, and Pi, served behind any OpenAI-compatible endpoint.

Swap the Harness, Not the Model

For enterprise deployment, Labonne argues the release marks a shift in what small models can be used for. Until now, local models made economic sense mainly as narrowly fine-tuned specialists — trained to do one thing at cloud-model quality, much faster and cheaper. Agentic capability changes that calculus, because the same model can be repurposed by changing the tools around it rather than the model itself. “You can have a calendar assistant, and you can reuse the same model and make a meeting assistant that will record what everybody said and summarize it — a bit like Granola, for example,” he said. “You don’t change the model; you just change the harness. You just change the tools around it. This gives much more generalizability, and it’s a lot easier to do and a lot cheaper as well.”

Labonne still recommends fine-tuning for production deployments whenever feasible: “If you don’t fine-tune it, you leave some quality on the table. If you fine-tune it well, it’s going to match the performance of GPT and Claude — really, if your task is not the most complex task in the world.” He added that the barrier to entry has collapsed: “The bar to be able to do fine-tuning now is super low. It’s very accessible to everyone.”

How LFM2.5-2.6B Stacks Up Against DeepSeek, Gemma, and Qwen

Liquid AI released its own benchmark comparisons pitting LFM2.5-2.6B against models most likely to compete for the same edge deployments: Google’s Gemma 4 E2B (5.1B parameters) and E4B (8B), and Alibaba’s Qwen3.5-4B (4.7B) and Qwen3.5-9B (9.7B). A separate test by local AI client platform Atomic Chat found that LFM2.5-2.6B completed 35 tool calls to check weather and local time in six cities, convert one budget into six currencies, and check four hotels and book for a date — 3.7 times faster than DeepSeek-V4-Flash (284B parameters), the model that has skyrocketed to the top of OpenRouter since its release last week.

Gemma 4’s small models are multimodal generalists, accepting image and audio input alongside text, using a Per-Layer Embeddings design that keeps only a fraction of their weights active per token — which is why Google markets them by “effective” size (2.3B and 4.4B) despite total footprints of 5.1B and 8B. Alibaba’s Qwen3.5 small series, released in March, is natively multimodal from 4B up and leans on scaled reinforcement learning to chase frontier-style reasoning. Alibaba touts the 9B model as matching or beating OpenAI’s far larger GPT-oss-120B on reasoning benchmarks.

LFM2.5-2.6B takes a narrower path: it is text-only, dense, and specialized for agentic work, with Liquid AI shipping separate vision and audio variants of the LFM family rather than folding everything into one checkpoint. Where Qwen’s post-training reinforcement learning targets reasoning, Liquid’s targets tool use inside real agent harnesses. The result, per Liquid’s published numbers, is that the smallest model in the comparison leads every instruction-following benchmark (IFBench, Multi-IF, IFStruct) and nearly every tool-use benchmark — 77.83 on ToolSandbox versus 76.44 for Qwen3.5-9B, a model nearly four times its size — trailing only that 9B model on BFCLv4.

On agentic evaluations, LFM2.5-2.6B beats both Gemma models across the board and essentially ties the Qwens: 26.89 on BrowseComp+ versus 27.23 for Qwen3.5-9B. It also posts the best score on AA Omniscience, a knowledge benchmark that penalizes hallucination. The Qwen models keep the edge where their training focus lies: math (Qwen3.5-9B leads AIME25) and coding, where larger models retain an advantage on LiveCodeBench — though Labonne noted the gap is smaller than the parameter counts would suggest. “With LiveCodeBench v6, we might not be the best among these models, but we’re also by far the smallest. Showing that we’re competitive with them is already quite a win for me,” he said.

The Licensing Puzzle: Open Weights, Commercial Restrictions

One differentiator works against Liquid AI’s adoption curve: licensing. Gemma 4 and Qwen3.5 ship under the permissive Apache 2.0 license — a change Google made specifically to court enterprises. DeepSeek-V4-Flash ships under a similarly permissive MIT License. Meanwhile, Liquid AI’s LFM Open License v1.0 permits use, modification, and redistribution — including commercial use — for organizations with less than $10 million in annual revenue. Commercial use by larger companies requires a separate arrangement with Liquid AI; qualified nonprofits are exempt from the threshold for non-commercial and research purposes.

Labonne framed the structure as a way to sustain model development: “The models are really the moats, so we need to be sensible in the way that we license them; otherwise, we cannot make money, so we can’t make more models.” He characterized the threshold as a light-touch mechanism in practice. Asked how the company would even know if a large enterprise quietly deployed the open weights, he was candid: “I think this is a question for our legal team, but personally, I don’t know. And even