Fine-Tune LFM2.5 1.2B with Ertas

LFM2.5 1.2B at a Glance

Overview

LFM2.5-1.2B-Instruct is the largest text model in Liquid AI's LFM2.5 family and the flagship of the January 5, 2026 launch. It carries 1.17B parameters across 16 layers, split 10 double-gated short-range convolution blocks to 6 grouped-query attention blocks, and was pre-trained on 28 trillion tokens with a large-scale multi-stage reinforcement learning pipeline on top.

The context window is 32,768 tokens and the vocabulary is 65,536, which is deliberately compact. At this parameter count the embedding and unembedding tables are a large share of the file, so a smaller vocabulary translates directly into a smaller download. That is a large part of why the Q4_K_M export lands at 731MB while a Gemma 3 1B, a smaller model on paper, exports at 810MB.

What the model is actually good at shows in the benchmark shape. It scores 86.23 on IFEval and 47.33 on IFBench, both instruction-following measures, against 73.68 and 21.33 for Qwen3-1.7B. On GPQA it takes 38.89 against 34.85, and on MMLU-Pro 44.35 against 42.91. Against Llama 3.2 1B, the closest comparison by size, the gaps are much larger: 86.23 to 52.37 on IFEval, 44.35 to 20.80 on MMLU-Pro.

Liquid recommends the model for agentic tasks, data extraction and RAG, and steers away from knowledge-intensive work and programming. That is a fair description of the profile. It follows instructions with unusual reliability for its size and knows less about the world than a cloud model, which makes it a good executor and a poor encyclopedia.

Three sibling checkpoints exist beyond the instruct model: LFM2.5-1.2B-Base for heavy fine-tuning, LFM2.5-1.2B-Thinking for reasoning with a lower recommended temperature of 0.05, and LFM2.5-1.2B-JP tuned for Japanese. The Ertas catalogue carries the instruct checkpoint, mirrored at `ErtasAI/LFM2.5-1.2B-Instruct`.

Key Features

Instruction following at 86.23 IFEval is the headline capability. For comparison, Granite-4.0-h-1b scores 80.08, Qwen3-1.7B 73.68, Gemma 3 1B 63.25 and Llama 3.2 1B 52.37. IFBench, which uses harder and less common constraints, separates them further: 47.33 for LFM2.5 against 24.93 for the next best. If your fine-tune has to emit a specific format on every single request, this is the axis that decides whether it works in production.

Tool calling is native. The model writes Pythonic function calls between `<|tool_call_start|>` and `<|tool_call_end|>` tokens by default, interprets the tool result, and returns a plain-text answer. You can switch it to JSON function calls through the system prompt if your runtime expects that shape. The chat template is ChatML-like, so most existing tooling reads it without special handling.

Memory footprint stays under a gigabyte across every target Liquid measured. On a Galaxy S25 Ultra it runs in 719MB against 1,306MB for Qwen3-1.7B on the same device, at 335 tokens per second of prefill and 70 of decode. On an AMD Ryzen AI 9 HX 370 it holds 856MB at 2,975 prefill and 116 decode. On a Qualcomm Dragonwing IQ9 IoT NPU it sits at 0.9GB with 2,143 prefill and 53 decode.

AIME25 at 14.00 is worth reading honestly. It beats Qwen3-1.7B at 9.33 and buries Llama 3.2 1B at 0.33, and it is still a low absolute score. Competition maths is not what a 1.2B on-device model is for. If you need reasoning depth at this size, the LFM2.5-1.2B-Thinking checkpoint is the variant Liquid built for it.

Fine-Tuning with Ertas

LFM2.5 1.2B fine-tunes on the T4 tier in Ertas Studio and sits under the Free plan's 5B parameter ceiling, so a full training run costs nothing to start. The weights are bf16-native, so there is no fp32 fallback penalty on Turing hardware.

The recipe that works for this size class is a learning rate between 3e-4 and 5e-4, batch size 4, gradient accumulation 2, and 8 to 16 epochs. A 1.2B model needs more passes over a small dataset than a 7B does before a behaviour holds, and it tolerates the higher rate without collapsing.

Exports come out as GGUF for llama.cpp, Ollama and LM Studio, or as safetensors LoRA adapters. Liquid's own Q4_K_M build measures 731MB; the Ertas export of a fine-tuned adapter merged into this base shipped at 697MB for [Chatty Valley](/blog/chatty-valley-on-device-ai-mod-stardew-valley), a Stardew Valley mod that replaces a villager's fixed dialogue with generated in-character replies running on the player's own CPU.

That build is the most detailed public account we have of fine-tuning this model, and two findings from it are worth carrying into your own run. The first is that the 1.2B holds a multi-turn conversation while the 350M in the same family starts answering questions nobody asked, and that difference only became visible by talking to it. Dash-free rate, jailbreak leak rate, sentence-length distribution and degeneration all came back clean on both sizes.

The second is about the agreement prior. Getting the model to refuse a false premise under sampled adversarial pressure turned out to be much harder than getting it to hold a voice. Supervised fine-tuning shaped that behaviour without removing it, and a 40-pair LoRA DPO round extended the same ceiling rather than breaking through it. Greedy evaluation could not see the problem at all. If your fine-tune needs the model to push back on something the user asserts, budget for that specifically and probe it with sampling.

Use Cases

On-device assistants are the primary use case. At 719MB on a flagship phone with 70 tokens per second of decode, a fine-tuned 1.2B answers in a conversational rhythm with no network round-trip and no per-request cost. Liquid names agentic tasks, data extraction and RAG as its recommended trio, and the instruction-following scores support all three.

Tool-calling agents that run locally are the strongest fit. Native Pythonic function calls, a 32,768-token context for tool definitions and results, and 86.23 IFEval means the model reliably produces a call your runtime can parse. Pair it with retrieval so the facts come from your index and the model handles the orchestration.

Character and game AI is the pattern Chatty Valley demonstrates. A narrow persona, a few hundred training rows, and a 697MB download a player will actually accept. The size matters here for a specific reason: character work needs conversational coherence across a dozen turns, and that is the capability the 350M loses first.

Document processing and structured extraction works well when the source text is in the prompt. High instruction-following with moderate world knowledge is exactly the profile you want for turning a contract, a form or an email into structured fields.

Where to look elsewhere: knowledge-intensive question answering, code generation, and competition maths. Liquid says so directly, and MMLU-Pro at 44.35 with AIME25 at 14.00 is the evidence. For those, a 7B or 8B base from the catalogue is the better starting point.

Hardware Requirements

Inference, as measured by Liquid AI. Samsung Galaxy S25 Ultra with Snapdragon Gen4: 335 tokens per second prefill, 70 decode, 719MB memory. AMD Ryzen AI 9 HX 370 CPU: 2,975 prefill, 116 decode, 856MB. Qualcomm Dragonwing IQ9 IoT NPU: 2,143 prefill, 53 decode, 0.9GB. Every one of those targets stays under a gigabyte.

Export sizes from Liquid's published GGUF builds: 696MB at Q4_0, 731MB at Q4_K_M, 843MB at Q5_K_M, 963MB at Q6_K, 1.25GB at Q8_0, and 2.34GB at BF16. Q4_K_M is the default worth shipping unless you have measured a quality reason to go higher.

For fine-tuning on Ertas, the T4 tier handles this model, which is the entry tier and the one the Free plan uses. No A10G is required.

For local fine-tuning outside Ertas, QLoRA on a 1.2B wants 8GB of VRAM or more, which puts it within reach of an RTX 3060 12GB or better. Training-step throughput is fast enough at this size that dataset iteration, rather than GPU time, is the thing that takes the week.

Frequently Asked Questions

What is LFM2.5 1.2B?

LFM2.5-1.2B-Instruct is Liquid AI's flagship on-device language model, released on January 5, 2026. It has 1.17B parameters across 16 layers, mixing 10 double-gated convolution blocks with 6 grouped-query attention blocks, a 32,768-token context window, and was pre-trained on 28 trillion tokens. It runs in under 1GB of memory on phones, CPUs and NPUs.

How does LFM2.5 1.2B compare to Qwen3-1.7B and Llama 3.2 1B?

On Liquid AI's published benchmarks, LFM2.5-1.2B-Instruct scores 86.23 on IFEval against 73.68 for Qwen3-1.7B and 52.37 for Llama 3.2 1B. On IFBench it scores 47.33 against 21.33 and 15.93. On MMLU-Pro, 44.35 against 42.91 and 20.80. On GPQA, 38.89 against 34.85 and 16.57. It also runs in 719MB on a Galaxy S25 Ultra where Qwen3-1.7B needs 1,306MB.

How big is a fine-tuned LFM2.5 1.2B export?

Around 731MB at Q4_K_M, based on Liquid AI's published GGUF build. An Ertas export of a fine-tuned 1.2B for the Chatty Valley Stardew Valley mod shipped at 697MB. At Q8_0 the file is roughly 1.25GB and at BF16 it is 2.34GB.

Should I use LFM2.5 1.2B or LFM2.5 350M?

Pick the 1.2B when the model has to hold a conversation across several turns or run an agent loop. Pick the 350M when each request stands alone, such as extraction, classification or a single tool call, and the smaller 229MB download matters.

We ran this bake-off directly while building Chatty Valley. A fine-tuned 350M held the character's voice and formatting beautifully and then lost the thread of a casual multi-turn conversation, producing fluent in-character replies to questions that had not been asked. Every automated metric said the 350M was fine. Only a scripted conversational probe caught it.

Can I fine-tune LFM2.5 1.2B for free on Ertas?

Yes. At 1.17B parameters it is well under the Free plan's 5B ceiling and it trains on the T4 GPU tier. For sub-2B bases the recommended recipe is a learning rate of 3e-4 to 5e-4, batch size 4, gradient accumulation 2, and 8 to 16 epochs.

Does LFM2.5 1.2B support tool calling?

Yes, natively. It writes Pythonic function calls between dedicated `<|tool_call_start|>` and `<|tool_call_end|>` tokens, executes against the returned tool result, and answers in plain text. You can switch it to JSON-formatted calls through the system prompt. The chat template is ChatML-like.