TL;DR: LiquidAI’s LFM2.5-230M is a 230-million-parameter edge model that decodes at 42 tokens/second on a Raspberry Pi 5 in under 1GB of RAM — fast enough for real-time tool-calling and data extraction on a board that idles at ~3 watts. It won’t reason or write code like a 7B model, so it’s a purpose-built agent front-end, not a chatbot. Buy a Pi for it only if you want an always-on, low-power appliance; for anything heavier, a GPU still wins.

	Raspberry Pi 5	Cheap discrete GPU (RTX 3060 12GB)	Phone / edge SoC
Best for	Always-on tiny agents, offline appliances	Real 7B–14B models at usable speed	On-device apps, robotics
LFM2.5-230M decode	~42 tok/s	200+ tok/s (overkill here)	~213 tok/s (Galaxy S25 Ultra)
Power under load	~7–12 W	~120–170 W (rig)	~3–5 W
The catch	230M quality ceiling; Pi price jumped in 2026	Idles at 30–60 W doing nothing	You don’t control the hardware

Honest take: A Raspberry Pi 5 running LFM2.5-230M is a genuinely good always-on edge box — a $45–$199 appliance that sips 7 watts and answers tool calls in under a second. But it is not a small version of your GPU rig. Run it for structured extraction, routing, and wake-word-to-action pipelines; keep a real GPU for anything that needs to think.

What LFM2.5-230M actually is

LiquidAI released LFM2.5-230M in late June 2026 as its smallest model yet — a 230-million-parameter model built on the LFM2 hybrid architecture, the same convolution-plus-attention design behind the larger LFM2.5-8B-A1B. It was pre-trained on 19 trillion tokens, including a context-extension phase, and ships with a 32K context window (the model card lists a 16K default that’s configurable to 32K).

The pitch is right in the tagline: built to run anywhere. LiquidAI shipped it day-one with llama.cpp, MLX, vLLM, SGLang, and ONNX support, so it runs on CPUs, NPUs, and GPUs without waiting on a community port. And at this size, “anywhere” is literal — the Q4_K_M GGUF is roughly 153 MB on disk and the whole thing runs in under 1GB of RAM.

One correction up front, because most launch coverage got it wrong: this model is not Apache 2.0. It ships under the LFM Open License v1.0 (lfm1.0), an Apache-derived license that allows free commercial use but caps that free grant for organizations above a revenue threshold. If you’re a solo builder or a small shop, you’re fine. If you’re shipping this inside a product at a large company, read the license before you commit — same catch we flagged on the 8B model.

The speed numbers that made it trend

LiquidAI published decode figures across three very different pieces of hardware, and the spread is the whole story:

• 239 tokens/second on an AMD CPU (desktop-class)
• 213 tokens/second on a Galaxy S25 Ultra (phone CPU)
• 42 tokens/second on a Raspberry Pi 5

For context, human reading speed is roughly 7–10 tokens/second. Even the slowest of these — the Pi 5 at 42 tok/s — generates text four to six times faster than you can read it. That’s the number that matters for an edge agent: first token comes back in well under a second, and the response streams faster than a human cares about.

Put the Pi figure next to what else runs on that board. Community benchmarks put a 1.1B model like TinyLlama at ~14 tok/s on a Pi 5, and 3B models drop to 4–7 tok/s. A 230M model hitting 42 tok/s isn’t magic — it’s just small, and small is exactly the point on a CPU-only board with no memory bandwidth to spare. Decode speed on any local model is bound by how many weights the processor has to read per token; a 230M model reads a fraction of what even a 1B model does.

The Pi price reality nobody mentions

Here’s where the popular framing — “an $80 Pi beats a $300 GPU” — falls apart in July 2026, and it’s the same story this site has been tracking all year.

The 2026 memory shortage that doubled DDR5 and SSD prices hit the Raspberry Pi too. As AI data centers vacuumed up LPDDR capacity, Raspberry Pi raised prices twice in three months. As of early July 2026:

Pi 5 variant	Price (Jul 2026)	Enough for LFM2.5-230M?
1GB	~$45	Tight but yes (model needs <1GB) — leave room for the OS
2GB / 4GB	~$50–$90	Yes — the sweet spot
8GB	~$199	Yes, but you’re paying for RAM you won’t use
16GB	~$205	Overkill for this model

The 8GB board — the one most guides recommend by reflex — is now around $199, up over 70% from its original MSRP, with the 16GB at ~$205. So the “$80 Pi” is gone at the 8GB tier. But the good news is that LFM2.5-230M runs in under 1GB of RAM, so you don’t need the 8GB board. A 2GB or 4GB Pi 5 (roughly $50–$90) is the correct buy, and it leaves the “cheap appliance” thesis intact — just don’t overspend on memory this model will never touch.

Where a Pi actually beats a GPU

The honest case for a Pi over a discrete GPU isn’t speed or quality — it’s watts and always-on economics.

A discrete GPU capable of real local AI — say an RTX 3060 12GB at ~$250–$300, or a used RTX 3090 — will crush a 230M model at 200+ tok/s. But that’s not the comparison that matters, because you’d never buy a $300 card to run a 230M model. The real comparison is total system power for a workload that has to run 24/7:

• Raspberry Pi 5: ~2.7–3 W idle, ~7–12 W under full load. Running an always-on edge agent, you’re looking at a couple of dollars a month in electricity.
• A GPU rig: even a modest tower idles at 30–60 W, and a used-3090 build idles closer to 100–120 W before it does any work. That’s 15–40× the standby draw of a Pi.

For an always-on job — a home-automation router, a wake-word-to-action pipeline, a webhook summarizer, a structured-data extractor sitting on a local document folder — the Pi wins on operating cost by a wide margin, and it does the job fast enough that you’d never notice the difference. A GPU that spends 23 hours a day idle is burning money to be ready for work a 7-watt board could have handled.

That’s the niche: not “cheaper AI,” but “always-on AI that doesn’t move your power bill.”

What 230M parameters can and can’t do

This is where honesty earns trust, so let’s be blunt about the ceiling.

LFM2.5-230M is built for agentic edge tasks, and its benchmark profile shows exactly that — it punches above its weight on the structured stuff and stays firmly in the small-model tier on open reasoning:

• Tool use (BFCLv3): scores above 43, putting it in the same tier as Granite 4.0-H-350M — genuinely usable function-calling.
• Data extraction (CaseReportBench): 22.51, beating Qwen3.5-0.8B (13.83) and LFM2-350M (11.67) — despite being 3–4× smaller than the Qwen model.
• Instruction following (IFEval): leads Gemma 3 1B and Qwen3.5-0.8B, again while being much smaller.
• Knowledge (MMLU-Pro): 20.25 — well behind Qwen3.5-0.8B’s 37.42.

Read that last line carefully. On broad knowledge and reasoning, a 230M model is not competitive with even a sub-1B model, let alone a 7B. What LiquidAI did was optimize hard for the jobs an edge agent actually does — follow a schema, call the right function, pull fields out of text — and accept a low knowledge ceiling as the trade.

So the use cases that make sense:

• Always-on home assistant routing — parse an intent, call the right tool, respond.
• Structured extraction — pull dates, amounts, names out of documents or emails into JSON.
• Wake-word-to-action pipelines — the reasoning layer between a trigger and an API call.
• Offline/air-gapped appliances — where any cloud dependency is a non-starter.

The use cases that don’t:

• Code generation — use a real coding model on a GPU; see our best local models by VRAM guide.
• Multi-step reasoning or long-form writing — the knowledge ceiling shows immediately.
• General chat — it’ll answer, but you’ll feel the 230M limits within a few turns.

How to run it on a Pi 5

The fastest path is Ollama with the official GGUF from HuggingFace:

# Install Ollama on Raspberry Pi OS (64-bit)
curl -fsSL https://ollama.com/install.sh | sh

# Pull and run the Q4_K_M GGUF (~153 MB)
ollama run hf.co/LiquidAI/LFM2.5-230M-GGUF:Q4_K_M

If you’d rather build llama.cpp directly for maximum control (and it’s typically 10–20% faster than Ollama on Pi hardware, and ~35% faster at prompt processing), clone and compile it, then point it at the same GGUF file. On a 64-bit Raspberry Pi OS with a Pi 5, a straight cmake build with the default ARM optimizations is enough — you don’t need any accelerator flags, because this is pure CPU inference.

Two practical notes for the Pi specifically:

1. Cooling matters. The Pi 5 throttles when it gets hot, and sustained inference will heat it up. An active cooler keeps decode speed stable — without one, expect your 42 tok/s to sag as the board thermal-throttles.
2. Use a fast microSD or, better, an NVMe HAT. Model load time comes off storage, and while a 153 MB model loads quickly anywhere, an SSD makes the whole appliance feel snappier on cold start. If you’re chasing every last token/sec on the Pi, our SSD-for-local-AI guide covers why storage bandwidth shows up in load times.

For a full FOSS-first walkthrough of the LFM2.5 family across llama.cpp, MLX, and vLLM, see the companion setup guide on aifoss.dev.

When to skip the Pi entirely

If you don’t have an always-on requirement, the Pi loses its main advantage. A phone SoC runs this model 5× faster (213 tok/s on a Galaxy S25 Ultra), and if you already own any GPU, running LFM2.5-230M on it is free performance you’re not using. The Pi earns its place specifically when three things are all true: the workload runs continuously, power draw is a real cost or constraint, and a 230M model is genuinely enough for the task. Miss any one of those and you’re better off elsewhere.

If your actual goal is “cheap local AI that can also handle real work,” the honest answer isn’t a Pi at all — it’s a used GPU. A used RTX 3090 at ~$1,050 (936 GB/s of bandwidth) runs 7B models at ~95 tok/s and steps up to models a Pi can’t dream of. If you need cloud burst for occasional heavy jobs, RunPod rents datacenter GPUs by the hour without the 24/7 idle draw of owning one. The Pi is an appliance, not a workstation — buy it as one.

FAQ

Can a Raspberry Pi 5 run larger models than 230M? Yes, but slowly. A 1B model runs around 10–15 tok/s on a Pi 5 with a good quant, and 3B models drop to 4–7 tok/s. Anything above ~3B is impractical for interactive use on Pi hardware — the CPU-only memory bandwidth is the wall.

Do I need the 8GB Raspberry Pi 5 for LFM2.5-230M? No. The Q4_K_M build runs in under 1GB of RAM, so a 2GB or 4GB Pi 5 (roughly $50–$90 in July 2026) is the sensible pick. The 8GB board at ~$199 is buying memory this model won’t use.

Is LFM2.5-230M open source / Apache 2.0? Not Apache 2.0. It ships under the LFM Open License v1.0, an Apache-derived license that allows free commercial use with a revenue-based cap on that free grant. Solo and small-team use is unrestricted; large organizations should read the terms.

How does 42 tok/s on a Pi compare to a GPU? A GPU is far faster — a cheap RTX 3060 would push this model past 200 tok/s — but that misses the point. Nobody buys a $300 GPU to run a 230M model. The Pi’s advantage is power: ~7 W under load versus 100+ W idle for a GPU rig, which only matters for always-on workloads.

What can I actually build with a 230M model? Tool-calling agents, structured data extraction (text → JSON), instruction-following routers, and wake-word-to-action pipelines. It excels at these and beats models 3–4× its size on tool-use and extraction benchmarks. It’s weak on general knowledge and reasoning — don’t use it for code or long-form writing.

Sources

1. LiquidAI — LFM2.5-230M: Built to Run Anywhere (official blog)
2. LiquidAI/LFM2.5-230M — Hugging Face model card
3. LiquidAI/LFM2.5-230M-GGUF — Hugging Face (quant sizes)
4. MarkTechPost — Liquid AI Ships LFM2.5-230M with llama.cpp, MLX, vLLM, SGLang, ONNX Support
5. VentureBeat — Liquid AI’s smallest model yet beats models 4× its size at data extraction
6. Tom’s Hardware — Raspberry Pi 5 price increases as AI shortage bites, 16GB now $205
7. raspberry.tips — Raspberry Pi Power Consumption 2026 (Pi 5 idle/load watts)
8. TinyWeights.dev — Running LLMs on Raspberry Pi 5: real benchmarks

Recommended Gear

• Raspberry Pi 5 — the always-on edge board for LFM2.5-230M (a 2GB/4GB variant is plenty)
• RTX 3060 12GB — the entry point if you want real 7B–14B models instead
• RTX 3090 — the used-market value pick for serious local inference

Prices and availability as of July 2026 and move weekly — verify current pricing before buying. Benchmark figures are from LiquidAI’s published results and community testing; independent Raspberry Pi 5 numbers for LFM2.5-230M were limited at publication.