LFM3 1.7B

LFM3-1.7B is a text model for local agents and specialized applications, based on our new tri-hybrid architecture.

• Agentic training: post-trained for agentic harnesses such as Hermes Agent, Pi, and OpenClaw, with a 256K-token context window.
• Designed for the edge: at 4-bit precision, it takes about 1 GB of memory, so it fits on any phone or laptop.
• Made to be specialized: adapt the model to your domains, formats, and tools via quick single-GPU fine-tuning.

Find more information about the LFM3 family in our release blog post.

Model details

The LFM3 family includes base, text, vision, audio, omni, and decision models.

LFM3-1.7B is designed for local agents, tool calling, structured outputs, and domain-specific fine-tuning. Use retrieval or search for knowledge-heavy tasks. It is not recommended for agentic coding or complex multi-step reasoning due to its small size.

Inference

Choose a checkpoint variant for your inference framework and hardware.

Sampling parameters:

• General (chat, tool use, agents, coding): temperature=0.1,top_k=50, repetition_penalty=1.1
• Math & STEM (math, science): temperature=1.0, top_p=0.95, top_k=20

Transformers quick start:

from transformers import pipeline

generator = pipeline(
    "text-generation",
    model="LiquidAI/LFM3-1.7B",
    trust_remote_code=True,
)

messages = [{"role": "user", "content": "What is C. elegans?"}]
output = generator(
    messages,
    do_sample=True,
    temperature=0.1,
    top_k=50,
    repetition_penalty=1.1,
    max_new_tokens=2048,
)
print(output[0]["generated_text"][-1]["content"])

For local agent setup, see the Agent Harnesses guide.

LFM3 uses this ChatML format, generated from the checkpoint's chat template:

<|startoftext|><|im_start|>system
You are a helpful assistant trained by Liquid AI.<|im_end|>
<|im_start|>user
Explain how a heat pump works.<|im_end|>
<|im_start|>assistant
<think>

Use tokenizer.apply_chat_template() with add_generation_prompt=True to format messages automatically.

Reasoning is enabled by default. You can set enable_thinking=False to disable thinking traces, but this behavior can be inconsistent, especially for reasoning-heavy tasks.

Reasoning from turns before the latest user message is removed unless preserve_thinking=True.

Pass function schemas through tools=... to apply_chat_template(). The template formats tool definitions and results automatically. Generated calls use XML:

<tool_call>
<function=get_weather>
<parameter=city>
Paris
</parameter>
</function>
</tool_call>

Execute the call in your application. Add the parsed assistant call to history as a tool_calls entry, then append the result as a tool message. Keep passing the tool schemas on subsequent requests and preserve the assistant's content and reasoning from the current tool-use turn.

function.arguments must be a Python mapping. Decode JSON strings with json.loads() before applying the template.

LFM3 supports deferred tools. Set defer_loading=True to keep tool definitions out of the prompt until your harness's search tool returns their names as tool_reference parts. The chat template then inserts their definitions into <additional_tools>.

tools = [
    search_tool,
    {"type": "function", "defer_loading": True, "function": get_weather_schema},
]
messages.append({
    "role": "tool",
    "tool_call_id": call_id,
    "content": [
        {"type": "text", "text": "Found 1 tool."},
        {"type": "tool_reference", "name": "get_weather"},
    ],
})

Your harness implements and runs the search. Keep the full tools list, including deferred tools, on every request. In the system prompt, tell the model when to search:

Works with vLLM, SGLang, and LFM3-compatible llama.cpp builds. For llama.cpp, use a GGUF with the current chat template or load it with --chat-template-file.

See Deferred tools and tool search for the full guide.

Fine-tuning

LFM3-1.7B is designed for easy customization for a given domain, task, or application via TRL.

Performance

Benchmarks

LFM3-1.7B can power agentic applications that used to need 9B parameters.

Edge inference

At 32K context, LFM3-1.7B prefills at least 2.5x faster and decodes at least 1.8x faster than every compared model on all three devices, while using the least memory.

GPU inference

At 1,024 concurrent requests, LFM3-1.7B can produce 3.6 billion tokens/day on one NVIDIA B300.

Training

Pre-training: two stages build LFM3-1.7B-Base on 22T tokens in total.

• Main pre-training: compared with LFM2, the mix adds more scientific papers, repository-level code, math, and a wider range of knowledge sources.
• Mid-training: the last 3.5T tokens use curated, higher-quality data with a larger share of agentic traces and tool calls. This stage also extends the context window to 256K tokens.

Post-training: four stages develop conversation, reasoning, and tool-use capabilities.

• Supervised fine-tuning (SFT): 1.75T tokens across various tasks, including chat, reasoning, tool calling, and agentic traces.
• Mixed reinforcement learning: many domains trained at once, from math and code to SQL and structured outputs. A length penalty in the reward keeps answers concise.
• Multi-domain on-policy distillation (MOPD): six specialist RL teachers (code, math, tool use, long context, agentic work, and enterprise workflows) are distilled back into a single model.
• Agentic RL: tasks from web browsing to office work are run inside real agent harnesses, preparing the model for deployment.

Citation

@article{liquidAI2026LFM3,
  author  = {Liquid AI},
  title   = {Introducing LFM3: Every Modality for Specialized Intelligence},
  journal = {Liquid AI Blog},
  year    = {2026},
  note    = {www.liquid.ai/blog/lfm3},
}

For questions and feedback, join Discord. For custom deployment and fine-tuning support, contact Liquid AI.