Liquid AI LFM2.5-230M: The 230M-Parameter Model Built to Run Anywhere

1. Introduction

Liquid AI has released LFM2.5-230M, their smallest model to date. At just 230 million parameters, it's designed for one thing: running anywhere. From cloud GPUs to a Raspberry Pi 5, from a Galaxy S25 Ultra to the onboard NVIDIA Jetson Orin in a Unitree G1 humanoid robot.

This isn't a toy model. Despite its tiny footprint, LFM2.5-230M competes with — and often beats — models more than twice its size across knowledge, instruction following, data extraction, and tool use benchmarks. It's built on Liquid AI's proprietary Liquid For Machine (LFM) architecture, which replaces the standard transformer attention mechanism with liquid neural networks that are dramatically more efficient at inference.

Both the base model (LFM2.5-230M-Base) and the post-trained version (LFM2.5-230M) are available today on Hugging Face. The models are fully open — you can download, fine-tune, and deploy them on any hardware.

2. Architecture — Liquid Neural Networks

The key to LFM2.5-230M's efficiency is its underlying architecture. Unlike standard transformers that use self-attention — which scales quadratically with sequence length and requires expensive KV cache management — Liquid AI uses liquid neural networks, a continuous-time recurrent architecture originally developed by Professor Wolfgang Maass at IST Austria.

Here's what makes liquid networks different:

• No attention mechanism — liquid networks use adaptive, continuous-time recurrent dynamics instead. This eliminates the quadratic compute cost of self-attention.
• Fixed memory footprint — unlike transformers that need to store KV cache for every token in the context window, liquid networks maintain a fixed-size hidden state. This means inference memory usage doesn't grow with sequence length.
• Adaptive computation — the network's internal dynamics adapt to the input, allowing it to process information more efficiently than a fixed compute graph.
• Linear scaling — inference cost scales linearly with sequence length, not quadratically.

The LFM2.5 architecture builds on Liquid AI's previous LFM2 generation, with improvements to training stability, context length (now 32K tokens), and post-training recipes. The result is a model that achieves competitive performance at a fraction of the parameter count of comparable transformer models.

3. Training & Fine-Tuning

LFM2.5-230M was trained through a multi-stage pipeline:

Pre-training

• 19 trillion tokens of pre-training data
• Included a 32K context extension phase — the model was trained to handle long context windows from the start
• Built on the LFM2 architecture with architectural improvements for stability and efficiency

Post-training (3 stages)

The post-training recipe is designed to balance out-of-the-box capability with developer flexibility:

1. Supervised fine-tuning with distillation from LFM2.5-350M — the smaller model learns from its larger sibling, inheriting capabilities without needing to train from scratch on the same scale.
2. Direct Preference Optimization (DPO) — aligns the model's outputs with human preferences, improving instruction following and reducing refusals.
3. Multi-domain Reinforcement Learning (RL) — further refines the model across diverse task domains, improving robustness and generalization.

The result is a model that's "surprisingly capable at tool use and data extraction tasks" despite its 230M parameter count — and one that remains flexible enough for developers to fine-tune for their own downstream applications.

4. Benchmarks

Liquid AI evaluated LFM2.5-230M across ten benchmarks covering core capabilities and applied tasks. Here's how it stacks up:

Core Capabilities

Applied Tasks

The key takeaway: LFM2.5-230M beats models more than 3× its parameter count (Granite 4.0-H-350M, Granite 4.0-350M) on most benchmarks, and competes closely with Qwen3.5-0.8B and Gemma 3 1B despite having only 230M parameters. It particularly excels at instruction following (IFEval: 71.71) and tool use (BFCLv3: 43.26).

5. On-Device Robotics Deployment

Perhaps the most compelling demonstration of LFM2.5-230M's capabilities is its deployment on a Unitree G1 humanoid robot, running entirely on-device on the robot's onboard NVIDIA Jetson Orin.

Here's how it works:

1. The model acts as a skill-selection layer — it takes a single natural-language instruction and decomposes it into a sequence of tool calls.
2. These tool calls invoke pre-trained low-level skills provided by NVIDIA's SONIC framework.
3. After a quick fine-tune for this task, the model turns free-form commands into structured, multi-step plans.

"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, and walk backward at 0.5 meters per second for 3 meters"

This gets translated into a structured plan chaining skills like timed walking at target velocity and a one-legged kneel. The behaviors are deliberately simple at this stage, but the signal is clear: a 230M-parameter model can be quickly fine-tuned and deployed on-device to serve as the natural-language control interface for a humanoid robot.

This is significant because it demonstrates the practical viability of running LLMs entirely on edge hardware — no cloud dependency, no latency from network roundtrips, no privacy concerns about sending robot sensor data to external servers.

6. Inference Speed: Everywhere

The headline numbers:

• 213 tokens/second on a Samsung Galaxy S25 Ultra
• 42 tokens/second on a Raspberry Pi 5

For context, 213 tok/s on a smartphone means the model generates text faster than most people can read it. And 42 tok/s on a $60 Raspberry Pi 5 means you can run a capable language model on hardware that costs less than a decent mechanical keyboard.

This speed is possible because of the liquid neural network architecture's fixed memory footprint and linear scaling. Unlike transformers that need to load and manage increasingly large KV caches as context grows, LFM2.5-230M maintains a constant memory state regardless of sequence length.

7. How It Compares

Let's put LFM2.5-230M in perspective against other small models:

• vs Granite 4.0-H-350M (350M) — LFM2.5-230M beats it on GPQA Diamond (25.41 vs 22.32), IFEval (71.71 vs 61.27), IFBench (38.40 vs 17.22), Multi-IF (37.70 vs 28.70), CaseReportBench (22.51 vs 12.44), BFCLv3 (43.26 vs 43.07), BFCLv4 (21.03 vs 13.28), and τ²-Bench Retail (13.68 vs 6.14). That's 8 out of 10 benchmarks — with 36% fewer parameters.
• vs Qwen3.5-0.8B (800M) — Qwen wins on MMLU-Pro (37.42 vs 20.25) and GPQA Diamond (27.41 vs 25.41), but LFM2.5-230M dominates on IFEval (71.71 vs 59.94), BFCLv3 (43.26 vs 35.08), BFCLv4 (21.03 vs 18.70), and τ²-Bench Retail (13.68 vs 6.14). With 71% fewer parameters.
• vs Gemma 3 1B IT (1B) — LFM2.5-230M beats it on GPQA Diamond (25.41 vs 23.89), IFEval (71.71 vs 63.49), BFCLv3 (43.26 vs 16.61), and τ²-Bench Retail (13.68 vs no data). With 77% fewer parameters.

The pattern is clear: LFM2.5-230M is particularly strong at instruction following and tool use — the exact capabilities that matter most for agentic workflows.

8. Use Cases & Who This Is For

LFM2.5-230M isn't trying to replace frontier models. It's designed for specific use cases where efficiency, low latency, and on-device deployment matter more than raw capability:

Agentic Workflows

Tool use and function calling are core strengths. The model excels at BFCLv3 (43.26) and BFCLv4 (21.03), making it ideal for agents that need to call APIs, extract structured data, or orchestrate multi-step workflows.

Edge Deployment

Runs on Raspberry Pi 5, smartphones, and embedded Jetson boards. Perfect for IoT devices, edge computing, and any scenario where sending data to the cloud isn't an option.

Robotics

The Unitree G1 deployment demonstrates the model's viability as an on-device natural-language control interface for robots. No cloud latency, no privacy concerns.

Data Extraction

CaseReportBench score of 22.51 — the best among models in this category — makes it strong for extracting structured data from unstructured text.

Fine-Tuning Base

The base model (LFM2.5-230M-Base) is available for developers who want to fine-tune on their own data. The lightweight post-training recipe preserves flexibility for downstream specialization.

9. Limitations

Being honest about what LFM2.5-230M isn't good at:

• Knowledge depth — GPQA Diamond of 25.41 and MMLU-Pro of 20.25 are decent for the size, but these are still well below frontier model performance. Don't use this as a general knowledge source.
• τ²-Bench Telecom — 5.26 is the weakest benchmark score, suggesting the model struggles with telecom-specific tool use tasks.
• Complex reasoning — at 230M parameters, the model simply doesn't have the capacity for multi-step reasoning chains that larger models handle well.
• Long-form generation — the model is optimized for tool use and data extraction, not creative writing or long-form content generation.

This is a specialized tool, not a general-purpose model. Use it where its strengths align with your use case.

10. Getting Started

Both models are available on Hugging Face:

• LFM2.5-230M (post-trained) — Hugging Face collection
• LFM2.5-230M-Base (pre-trained) — same collection

Liquid AI provides documentation on how to run and fine-tune the models locally. The models support the standard Hugging Face Transformers API, so you can load them with:

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("LiquidAI/LFM2.5-230M")
tokenizer = AutoTokenizer.from_pretrained("LiquidAI/LFM2.5-230M")

For fine-tuning, the base model is the recommended starting point. Liquid AI's docs include examples for supervised fine-tuning, DPO, and RL-based approaches.

Conclusion

LFM2.5-230M is a proof of concept that liquid neural networks can deliver competitive performance at a fraction of the parameter count of transformer models. At 230M parameters, it runs on hardware that most people would never consider for AI inference — and does so at speeds that are genuinely useful.

The robotics deployment is the most exciting signal here. A 230M-parameter model serving as the natural-language control interface for a humanoid robot, running entirely on-device, is a vision of edge AI that most people thought would require much larger models.

For developers building agentic workflows, edge deployments, or robotics applications, LFM2.5-230M is worth exploring. It's not a replacement for larger models — but for the right use case, it's dramatically more efficient.

References

1. ^[1] LFM2.5-230M: Built to Run Anywhere — Liquid AI Blog
2. ^[2] Liquid AI LFM2.5-230M — Hugging Face Collection
3. ^[3] Liquid AI Documentation
4. ^[4] LFM2.5-230M on Unitree G1 — YouTube Short
5. ^[5] Ornith-1.0-9B on a single 3090 — club-3090 Discussion #478