Why a Tiny 230M AI Model Running on a Raspberry Pi Just Embarrassed the Giants

If you’ve been following AI news lately, you might assume the only way forward is building bigger data centers, chaining together thousands of GPUs, and waiting for the next trillion-parameter monolith to drop. For years, the industry has been trapped in a “bigger is always better” mindset.

But on June 25, 2026, Boston-based MIT spinout Liquid AI dropped a bombshell that completely challenges that narrative.

They released LFM2.5-230M—a ridiculously small 230-million-parameter foundation model that runs entirely offline on a Raspberry Pi 5. And the crazy part? On the specific tasks that actually matter for building automated AI agents, it is outperforming models four times its size from tech giants like Google and Alibaba.

We are officially entering the era where brute-force scale is no longer the only way to build useful AI. Here is a deep dive into why this tiny model is arguably the most exciting release of the month, how it pulls off these speeds, and what it means for developers.

The Specs: Small Footprint, Massive Context

Let’s get the baseline numbers out of the way. LFM2.5-230M was pre-trained on a massive 19 trillion tokens. Despite its tiny parameter count, it boasts a 32,000-token context window. For a model of this size, that is virtually unheard of—allowing it to ingest entire document manuals or continuous streams of robotic telemetry in a single prompt.

Because of its size, you can run this model at 4-bit quantization with a memory footprint sitting comfortably under 400MB. It doesn’t just run on edge hardware; it flies on it.

The resulting speeds are frankly absurd for local execution:

• Raspberry Pi 5: 42 tokens per second. (To put that in perspective, human reading speed is roughly 4-5 words per second. This is highly interactive speed on a $60 computer).
• Samsung Galaxy S25 Ultra: 213 tokens per second running purely on the Qualcomm Snapdragon Gen4 CPU.

The Secret Sauce: A True Hybrid Architecture

Most small models claim to be “edge-ready,” but they still choke your phone’s battery or lag out on embedded hardware when the context window fills up. This happens because most models are standard Transformers. As a Transformer ingests more tokens, its memory bloat (known as the KV cache) grows quadratically. On constrained RAM devices, that scaling behavior is a hard wall.

LFM2.5-230M is different. It is built on Liquid AI’s LFM2 hybrid framework, an edge-first architecture that ditches the pure Transformer approach.

Instead of relying entirely on memory-heavy attention mechanisms, the model uses 14 specialized layers:

1. 8 Double-Gated Short Convolution Blocks: These handle local sequence mixing. Because convolutions process data locally, they operate at an incredibly cheap O(1) per-step decode cost, keeping memory usage flat.
2. 6 Grouped-Query Attention (GQA) Blocks: These are sprinkled in purely to maintain long-range coherence across that massive 32K context window, without ballooning the RAM usage.

This hybrid approach gives you the best of both worlds: the strict memory control of a state-space model (like Mamba) combined with the long-context accuracy of a Transformer.

Beating the Big Guys at Tool Use and AI ETL

Liquid AI didn’t build this model to write poetry, generate Python scripts from scratch, or solve complex calculus. It is a hyper-specialist, laser-focused on agentic workflows: structured data extraction, function calling, and tool use.

Enterprises have traditionally relied on brittle Extract, Transform, Load (ETL) scripts to move data. If a PDF invoice changes its layout, the regex breaks. The industry wants “AI ETL”—using LLMs to dynamically parse messy text into clean JSON. But using massive models like Claude Opus or GPT-5 to parse routine receipts at $5.00 per million tokens is economically insane.

That is exactly the gap LFM2.5-230M fills. And the benchmarks prove that specialization wins:

• Tool Use (BFCLv3): It scored 43.26, easily beating IBM’s Granite 4.0-350M (39.58) and completely dominating Google’s 1-billion-parameter Gemma 3 1B IT (16.61).
• Data Extraction (CaseReportBench): It hit 22.51, embarrassing Alibaba’s much larger Qwen3.5-0.8B (13.83) and crushing Gemma 3 (2.28).
• Instruction Following (IFEval): It scored 71.71, again beating out Qwen3.5-0.8B (59.94) and Gemma 3 (63.49).

Caveat: Liquid AI is highly transparent about the model’s limitations. On general knowledge and reasoning benchmarks (like MMLU-Pro), larger models easily beat it. If you need a general-purpose chat assistant, look elsewhere. If you need to rigidly extract data into a JSON schema 10,000 times a day for free, you use this.

Robots, Pipelines, and True Privacy

Beyond parsing invoices, this model opens the door to true offline robotics and home automation.

To prove the point, Liquid AI showed off a demo where they fine-tuned LFM2.5-230M to act as the language “brain” for a Unitree G1 humanoid robot. Running entirely offline on the robot’s onboard NVIDIA Jetson Orin compute module, the model acted as a skill-selection layer.

It flawlessly translated messy, natural language commands—like “Hold still for 2 seconds, then walk forward at 1 meter per second for 3 meters, hold a forward one-leg kneel for 5 seconds”—into a precise sequence of low-level robotic API calls. No cloud latency. No Wi-Fi required. No sending camera feeds to a server.

Ready for Developers on Day One

The most frustrating part of new AI architecture releases is waiting for the ecosystem to support them. Liquid AI bypassed this completely. LFM2.5-230M is open-weight (under the lfm1.0 license) and available to download right now.

They shipped it with day-one support for the inference tools developers actually use in production:

• llama.cpp (GGUF): Perfect for edge CPUs and your Raspberry Pi.
• MLX: Fully optimized for Apple Silicon (MacBooks).
• vLLM & SGLang: For high-throughput GPU serving in enterprise environments.
• ONNX: For cross-platform inference across diverse edge accelerators.

If you have Ollama installed, you can pull it and run it locally in under a minute with a single terminal command.

The Verdict: Edge AI is Finally Practical

We are entering a phase where edge AI is moving from “cute tech demo” to “production-ready utility.” LFM2.5-230M proves that with smart architecture, aggressive distillation, and a narrow focus, a tiny model running locally on cheap hardware can absolutely dominate brute-force models.

You don’t always need to send data to a massive cloud model. Sometimes the best AI is the one running quietly in the background on the device right in front of you—blisteringly fast, completely private, and practically free to run.

If you are a developer building local agents, home automation pipelines, or smart robotic devices, this is the model you’ve been waiting for.