The Heresy Index weighs the resulting model's corruption by the process (KL Divergence & PIQA, Manual Response Eval) and its abolition of doctrine (Refusals) for a final verdict in classification.
Index Entry
Classification
Analysis
Absolute
Absolute Heresy
Near zero overt and secondary refusals with minimal to no model damage
Tainted
Tainted Heresy
Some residual secondary refusals and/or moderate model damage
Impotent
Impotent Heresy
Lingering overt refusals and high model damage
Note: This is an arbitrary and subjective classification inspired by Warhammer 40K, indended to serve as a signpost towards the model's performance.
LFM2.5-2.6B is part of LFM2.5, a family of hybrid models designed for on-device deployment. It builds on the LFM2 architecture with a 128K context window and agentic post-training.
Best-in-class agent: Competitive with models 4x larger on tool use, instruction following, and multi-step agentic tasks.
Agentic reinforcement learning: Trained inside the most popular agentic harnesses to improve compatibility.
Efficient inference: 220 tok/s on an Apple M5 Max and 113 tok/s on an AMD Ryzen CPU, in under 2.5 GB of memory.
Find more information about LFM2.5-2.6B in our blog post.
[!NOTE]
💻 Demos: Try LFM2.5-2.6B's agentic capabilities in a Hugging Face space without any setup:
Research Agent in your browser: helps you research a specific question and generates a summary
MLX format for Apple Silicon. Optimized for fast inference on Mac devices using the MLX framework.
We recommend using it for agentic workloads, tool use, data extraction, RAG, and long-context workflows. It is not recommended for agentic coding and knowledge-heavy tasks.
<|startoftext|><|im_start|>system
You are a helpful assistant trained by Liquid AI.<|im_end|>
<|im_start|>user
What is C. elegans?<|im_end|>
<|im_start|>assistant
[!TIP]
💡 Note: LFM2.5-2.6B is a pure reasoning models that always thinks before it answers. It adds a <think> tag directly in the chat template when starting an assistant answer.
Tool Use
LFM2.5 supports function calling in four steps:
Function definition: Provide the list of tools as a JSON object in the system prompt, or use tokenizer.apply_chat_template() with tools=....
Function call: By default, LFM2.5 writes Pythonic function calls (a Python list between <|tool_call_start|> and <|tool_call_end|> special tokens), as the assistant answer. You can override this behavior by asking the model to output JSON function calls in the system prompt.
Function execution: Execute the call and return the result with the tool role.
Final answer: LFM2.5 interprets the tool output and returns a plain-text answer addressing the original prompt.
<|startoftext|><|im_start|>system
List of tools: [{"name": "get_candidate_status", "description": "Retrieves the current status of a candidate in the recruitment process", "parameters": {"type": "object", "properties": {"candidate_id": {"type": "string", "description": "Unique identifier for the candidate"}}, "required": ["candidate_id"]}}]<|im_end|>
<|im_start|>user
What is the current status of candidate ID 12345?<|im_end|>
<|im_start|>assistant
<|tool_call_start|>[get_candidate_status(candidate_id="12345")]<|tool_call_end|>Checking the current status of candidate ID 12345.<|im_end|>
<|im_start|>tool
[{"candidate_id": "12345", "status": "Interview Scheduled", "position": "Clinical Research Associate", "date": "2023-11-20"}]<|im_end|>
<|im_start|>assistant
The candidate with ID 12345 is currently in the "Interview Scheduled" stage for the position of Clinical Research Associate, with an interview date set for 2023-11-20.<|im_end|>
Training
LFM2.5-2.6B is pre-trained on ~34T tokens, with a mid-training phase that extends the context window to 128K. Post-training then turns the base model into an agent in four stages: supervised fine-tuning (two rounds), per-domain teacher specialization, multi-domain on-policy distillation, and agentic reinforcement learning.
In particular, agentic reinforcement learning allows us to directly train the model inside popular agentic harnesses. It exposes the model to their tools, system prompts, and interaction patterns, helping it work reliably across agent environments.
🏃 Inference
LFM2.5 is supported by many inference frameworks. See the Inference documentation for the full list.
We compared LFM2.5-2.6B with relevant sub-10B models on a diverse suite of benchmarks.
Benchmark
LFM2.5-2.6B (2.6B)
gemma-4-E2B-it (5.1B)
gemma-4-E4B-it (8B)
Qwen3.5-4B (4.7B)
Qwen3.5-9B (9.7B)
AA Omniscience
-29.50
-74.47
-49.03
-54.30
-50.43
AIME25
51.87
26.33
34.27
49.33
56.07
LiveCodeBenchv6
59.41
54.92
63.77
60.85
69.86
IFBench
59.17
34.08
39.24
48.40
56.47
Multi-IF
80.07
69.44
77.35
55.67
62.55
IFStruct
85.49
64.85
76.65
36.25
78.50
BFCLv4
56.88
36.98
46.39
50.56
60.13
ToolSandbox
77.83
52.40
65.00
75.55
76.44
τ³-Bench Banking
5.67
3.35
4.12
5.45
5.15
Claw-Eval average (EN)
62.85
53.14
58.02
62.28
66.53
PinchBench
68.22
44.24
55.09
71.26
71.45
BrowseComp+ (OpenClaw)
26.89
8.31
15.90
24.46
27.23
CPU Inference
Due to its efficient LFM2 architecture, LFM2.5-2.6B is the fastest model we tested, with decode speeds of 220 tokens/s on an M5 Max and 113 tokens/s on a Ryzen AI Max+ 395. At 30 tokens/s, it allows you to run capable agents even on a phone.
GPU Inference
LFM2.5-2.6B is the fastest model in its size class, reaching almost 15K output tokens per second at high concurrency, roughly 1.3B tokens per day on a single H100.
