Liquid AI has shipped LFM2.5-230M, a tiny open-weight AI model designed to run on smartphones, robots, and edge devices without relying on cloud APIs. The 230-million-parameter model outperforms significantly larger competitors on specific tasks like data extraction and tool use, signaling a shift in how developers think about deploying AI beyond data centers.

What Makes a Model This Small Competitive?

The conventional wisdom in AI has long been that bigger is better. Larger models with billions or trillions of parameters tend to perform better across the board. But LFM2.5-230M challenges that assumption by focusing on a narrow, specific job: extracting data and executing tool calls on hardware with severe memory constraints.

The model achieves this through a hybrid architecture combining two types of neural network layers. Eight layers use double-gated LIV convolution blocks, while six use grouped-query attention (GQA) blocks. This design prioritizes fast inference on CPUs, the processors found in phones and edge devices, rather than the expensive GPUs typically required for AI workloads.

On instruction-following benchmarks, LFM2.5-230M scored 71.71 percent, beating Qwen3.5-0.8B at 59.94 percent and Gemma 3 1B at 63.49 percent. On data extraction tasks, it similarly outperformed both competitors. The secret: the model was trained using distillation from a larger 350-million-parameter version, inheriting knowledge about specific tasks without the size penalty.

Where Does This Model Actually Run?

Performance on paper means little without real-world speed. LFM2.5-230M processes text at 213 tokens per second on a Samsung Galaxy S25 Ultra smartphone and 42 tokens per second on a Raspberry Pi 5, a $60 single-board computer popular with hobbyists and embedded systems developers. Both speeds are fast enough for interactive use.

The model's footprint ranges from 293 to 375 megabytes depending on quantization level, a compression technique that reduces model size without drastically harming performance. This means the entire model fits comfortably on a phone's storage alongside other apps, or on a robot's onboard computer.

Liquid AI demonstrated the model running on a Unitree G1 humanoid robot, where it acted as a decision layer. The robot received natural language instructions, and the model converted them into sequences of tool calls that invoked low-level motor skills. The entire process happened on the robot's onboard NVIDIA Jetson Orin processor, with no connection to the cloud.

How to Deploy Local AI Models on Your Own Hardware

Running AI models locally eliminates per-query API costs and keeps sensitive data on your own devices. Here are the practical ways developers are using local models:

• Large-scale data extraction: Processing thousands of documents locally without paying per-token API fees. A company could parse 100,000 clinical reports into structured fields using a 4-bit quantized version of LFM2.5-230M, running on commodity CPUs with no cloud dependency.
• On-device agentic workflows: Building home automation hubs that convert speech into tool calls, or phone assistants that route requests to the correct function, all without sending data to external servers.
• Offline-first applications: Deploying AI agents on robots, drones, or field devices that operate in areas with poor or no internet connectivity, ensuring the system continues functioning regardless of network availability.

Developers can run LFM2.5-230M through multiple frameworks. The model ships with day-one support for llama.cpp, MLX, vLLM, SGLang, and ONNX, meaning it works across different hardware platforms and software stacks without requiring custom engineering.

What Are the Real Limitations?

Liquid AI is unusually transparent about what this model cannot do. It explicitly does not recommend LFM2.5-230M for reasoning-heavy workloads like advanced mathematics, code generation, or creative writing. On broad knowledge benchmarks like MMLU-Pro, the model scored 20.25 percent, significantly behind Qwen3.5-0.8B's 37.42 percent.

The model also struggles with some agentic tool-use tasks. On a telecommunications benchmark, it scored just 5.26 percent, indicating that while it excels at simple tool invocation, it falters on complex multi-step reasoning.

This honesty matters because it sets realistic expectations. The model is not a general-purpose replacement for Claude or GPT-4. It is a specialist tool, optimized for specific jobs on specific hardware. That specialization is precisely what makes it viable for edge deployment.

Why Does This Shift Matter for Developers?

The release of LFM2.5-230M reflects a broader industry trend: the recognition that not every AI task requires a trillion-parameter model running in a data center. As developers face mounting API costs from cloud-based AI services, local alternatives become increasingly attractive.

Running Claude Code, Anthropic's agentic coding tool, against cloud APIs can cost between $100 and $200 per day for heavy users. One developer reported burning through $175 in just four hours while refactoring a medium-sized codebase. Even conservative usage patterns involving periodic code reviews and debugging can exceed $500 per month.

By contrast, running a local model through Ollama, an open-source tool that serves models through a standard API interface, costs nothing after the initial hardware investment. A developer with a capable laptop or desktop can run inference indefinitely without per-token charges.

The trade-off is real: local models in the 7 billion to 16 billion parameter range do not match Claude Sonnet or Claude Opus in complex multi-file reasoning or nuanced architectural decisions. For straightforward tasks like boilerplate generation, refactoring, and test scaffolding, local models produce usable output on the first attempt for single-file edits. For tasks requiring deep contextual reasoning across thousands of lines of code, the quality gap remains significant.

Still, for developers working on privacy-sensitive codebases or operating under strict data residency requirements, local inference is not a trade-off at all. It is a requirement. LFM2.5-230M and similar models make that requirement technically and economically feasible.

What Comes Next for Edge AI?

The release of LFM2.5-230M is part of a larger shift toward smaller, more efficient models. As hardware becomes more capable and training techniques improve, the performance gap between edge models and cloud models continues to narrow. Liquid AI trained the model on 19 trillion tokens, including a 32,000-token context extension phase, then refined it through supervised fine-tuning, direct preference optimization, and multi-domain reinforcement learning.

The model supports a 32,768-token context window, meaning it can process roughly 25,000 words at once, sufficient for many real-world tasks. It also supports ten languages, including English, Chinese, Arabic, and Japanese, making it viable for global applications.

For developers and organizations tired of paying per-token API fees, managing cloud dependencies, or worrying about data residency, models like LFM2.5-230M represent a genuine alternative. The model is open-weight, meaning the weights are freely available on Hugging Face, and the license permits both research and commercial use.