Fine-Tune LFM2.5 230M with Ertas

LFM2.5 230M at a Glance

Overview

LFM2.5-230M is the smallest model in Liquid AI's LFM2.5 family and the smallest base in the Ertas catalogue. Released on June 25, 2026, it runs 14 layers split 8 double-gated short-range convolution blocks to 6 grouped-query attention blocks, two convolution blocks fewer than its larger siblings, and was pre-trained on 19 trillion tokens including a dedicated 32K context-extension phase.

It was built by distillation rather than by training from scratch at this size. Liquid ran supervised fine-tuning with distillation from LFM2.5-350M, then direct preference optimisation, then multi-domain reinforcement learning. That pipeline is why a 230M model lands within a point of its 350M teacher on function calling: BFCLv3 at 43.26 against 44.11, and BFCLv4 at 21.03 against 21.86.

Against other models near its size the results hold up. On IFEval it scores 71.71 against 63.49 for Gemma 3 1B IT and 59.94 for Qwen3.5-0.8B, both substantially larger. On IFBench, 38.40 against 20.33 and 22.87. On BFCLv3, 43.26 against 16.61 for Gemma 3 1B IT. On CaseReportBench, 22.51 against 2.28.

The language coverage is the widest in the family at ten: English, Arabic, Chinese, French, German, Italian, Japanese, Korean, Portuguese and Spanish. The context window is 32,768 tokens, the same as the 350M and 1.2B, and the vocabulary is 65,536.

Quantised to Q4_K_M the model exports at 153MB. That number is the whole point of this model. It is small enough to download inside a web page, small enough to bundle in a mobile app without a size conversation, and small enough to sit on a Raspberry Pi alongside whatever else that Pi is doing. Liquid recommends it for data extraction and lightweight on-device agentic pipelines, and steers away from reasoning-heavy work: advanced maths, code generation and creative writing. The Ertas catalogue carries it mirrored at `ErtasAI/LFM2.5-230M`.

Key Features

Holding 43.26 on BFCLv3 at 230M parameters is the headline. Its 350M teacher scores 44.11 and Granite 4.0-H-350M scores 43.07, so the distillation carried nearly all of the function-calling capability down a size class. Gemma 3 1B IT, roughly four times the parameters, scores 16.61 on the same benchmark.

Instruction following survives the shrink better than world knowledge does. IFEval at 71.71 and IFBench at 38.40 are both close to the 350M's 76.96 and 40.69. MMLU-Pro at 20.25 and GPQA Diamond at 25.41 are where the size shows, and Qwen3.5-0.8B takes MMLU-Pro at 37.42. That split is the useful thing to understand about this model: it does what you tell it and knows comparatively little, so put the facts in the prompt.

The deployment numbers are what no other model in the catalogue can match. On a Samsung Galaxy S25 Ultra it runs in 375MB at 1,158 tokens per second of prefill and 213 of decode. On a Raspberry Pi 5, quantised to 4-bit at 2K context, it runs in 293MB at 523 prefill and 42 decode. On an H100 it answers a 512-token prompt in about 50ms at concurrency 1 and about 205ms at concurrency 64.

Browser deployment is genuinely practical at this size. Exported to ONNX and quantised to q4, the model loads through transformers.js and runs on WebGPU with a WASM fallback, which means an AI feature with no server and no per-request cost. Corporate Goblin at [playground.ertas.ai](https://playground.ertas.ai) is exactly that: a LoRA fine-tune of this base, merged and exported to q4 ONNX, running entirely on the visitor's own machine.

Fine-Tuning with Ertas

LFM2.5 230M fine-tunes on the T4 tier in Ertas Studio and is the cheapest model in the catalogue to train. It is bf16-native, so it trains at bf16 directly. The Free plan covers it comfortably.

The recipe for this size is a learning rate between 3e-4 and 5e-4, batch size 4, gradient accumulation 2, and 8 to 16 epochs. At 230M parameters a run over a few hundred rows finishes quickly enough that the training step stops being the thing you wait for, and dataset quality becomes the only variable that matters.

Exports come out as GGUF for llama.cpp, Ollama and LM Studio, or as safetensors LoRA adapters. A Q4_K_M export lands around 153MB. For browser deployment, the adapter can be merged and converted to q4 ONNX for transformers.js.

Corporate Goblin is our own worked example. It is a LoRA fine-tune of LFM2.5-230M trained to answer every prompt in a single fixed persona, refusing normal answers and deflecting in character instead. It runs in the browser at [playground.ertas.ai](https://playground.ertas.ai) with nothing leaving the visitor's device. The lesson it carries is that a 230M model holds a tight persona far better than the parameter count suggests, provided the task is narrow and the dataset is consistent about it.

The constraint to plan around is conversational memory. A model this small is at its best when each request stands alone. If your fine-tune needs the model to track state across several turns, write a scripted multi-turn probe early and run it against a real conversation rather than trusting single-turn metrics. In our testing on the same family, the automated axes stayed clean on a size that could not actually hold a thread, and only conversation exposed it.

Use Cases

Browser-based AI is the use case this model unlocks. At 153MB quantised it is a plausible first-load download, and through transformers.js on WebGPU it runs entirely client-side. That removes the server, the per-request cost, and the privacy conversation in one move, which changes what is worth building.

Large-scale data extraction is Liquid's own first recommendation. Each document is an independent request, the answer comes from the text, and the model's job is to produce a consistent shape. At H100 latencies of roughly 50ms for a 512-token prompt, running this across a large corpus is cheap enough to be uninteresting as a line item.

Lightweight on-device agents work at this size because function calling survived the distillation. BFCLv3 at 43.26 with native Pythonic call formatting means a local agent can pick the right tool from a modest toolset, which is often all an embedded assistant needs to do.

Embedded and IoT deployment is realistic. 293MB on a Raspberry Pi 5 with 42 tokens per second of decode covers a wide class of hardware, from smart-home devices to industrial sensors to kiosks, where a 1B model would be uncomfortable.

Always-on mobile features suit the footprint too. Background classification, on-device search ranking, autocomplete and content categorisation can run continuously at 375MB in a way that a larger model's memory and battery cost would rule out.

Where to look elsewhere: multi-turn conversation, code generation, maths, creative writing and anything needing world knowledge. Liquid says so directly and MMLU-Pro at 20.25 is the number behind it. For conversational work in the same family, [LFM2.5 1.2B](/models/lfm2-5-1-2b) is the size that holds a thread.

Hardware Requirements

Inference, as measured by Liquid AI. Samsung Galaxy S25 Ultra with Snapdragon Gen4: 1,158 tokens per second prefill, 213 decode, 375MB memory. Raspberry Pi 5, 4-bit quantised at 2K context: 523 prefill, 42 decode, 293MB. On a single H100 serving batched requests of 512 input and 32 output tokens, p50 latency is roughly 50ms at concurrency 1 and roughly 205ms at concurrency 64.

Export sizes from Liquid's published GGUF builds: 149MB at Q4_0, 153MB at Q4_K_M, 172MB at Q5_K_M, 191MB at Q6_K, 247MB at Q8_0, and 462MB at BF16. At this size the jump from Q4_K_M to Q6_K costs only 38MB, so it is worth testing whether the extra quality is free in practice.

For fine-tuning on Ertas, the T4 tier handles this model with room to spare. It is the entry tier and the one the Free plan uses.

For local fine-tuning outside Ertas, QLoRA on a 230M fits on essentially any modern consumer GPU, including 6GB cards, and many recent laptops. Training runs at this size complete in minutes rather than hours.

Frequently Asked Questions

What is LFM2.5 230M?

LFM2.5-230M is Liquid AI's smallest on-device language model, released on June 25, 2026. It has 230 million parameters across 14 layers, mixing 8 double-gated convolution blocks with 6 grouped-query attention blocks, and a 32,768-token context window. It was pre-trained on 19 trillion tokens, then distilled from LFM2.5-350M and refined with direct preference optimisation and multi-domain reinforcement learning.

Can a 230M model really do function calling?

Yes. LFM2.5-230M scores 43.26 on BFCLv3 and 21.03 on BFCLv4 in Liquid AI's published results. Its 350M teacher scores 44.11 and 21.86, so the distillation preserved almost all of the capability. For comparison, Gemma 3 1B IT scores 16.61 on BFCLv3 with roughly four times the parameters.

How big is a fine-tuned LFM2.5 230M export?

Around 153MB at Q4_K_M, based on Liquid AI's published GGUF build. Q5_K_M is 172MB, Q6_K is 191MB and Q8_0 is 247MB. It is the smallest export Ertas produces from any catalogue base.

Can LFM2.5 230M run in a web browser?

Yes. Exported to ONNX and quantised to q4, it runs client-side through transformers.js on WebGPU with a WASM fallback. Corporate Goblin at playground.ertas.ai is a LoRA fine-tune of this base doing exactly that, with no server involved and nothing typed by the visitor leaving their device.

What is LFM2.5 230M not suitable for?

Liquid AI does not recommend it for reasoning-heavy workloads: advanced maths, code generation and creative writing. Multi-turn conversation is the other limit worth planning around, since a model this size is at its best when each request stands alone. MMLU-Pro at 20.25 against Qwen3.5-0.8B's 37.42 shows the world-knowledge gap directly, so pair it with retrieval rather than asking it to recall facts.

Is LFM2.5 230M free to fine-tune on Ertas?

Yes. At 230 million parameters it is the smallest and cheapest base in the catalogue, it trains on the T4 GPU tier, and it sits far under the Free plan's 5B parameter ceiling.