Liquid AI LFM3: small open models for on-device AI explained

LFM3 is a family of small open-weight models from Liquid AI, released on October 27, 2026, built to run on phones, laptops and other edge devices. The text model, LFM3-1.7B, has 1.73B parameters and a 256K-token context window, and fits in about 1 GB of memory at 4-bit precision. The first release has six models covering text, vision, audio, a combined "omni" model and two decision models, all on Hugging Face under the LFM Open License v1.0.

What makes LFM3 worth a look is the architecture. Most of its layers are not attention layers at all, and that changes how much memory a long context costs. Here is what is in the family, how the model works, and how to run it.

What is in the LFM3 family?

Every model in the first release is around 2B parameters and branches from the same base model, LFM3-1.7B-Base.

The text model is post-trained for agentic harnesses, meaning it is tuned to follow instructions, call tools and work inside a loop that feeds results back to it. It is a reasoning model by default: it writes its thinking inside <think> tags before the answer. The vision model adds video input, which earlier Liquid vision models did not take.

Be clear about the target. The model card says LFM3-1.7B is not recommended for agentic coding or complex multi-step reasoning. It is meant for fast, local, focused tasks: extraction, classification, tool calls, summaries, assistants that have to run without a network.

How does the LFM3 architecture work?

LFM3-1.7B has 24 layers of three kinds:

• 13 gated short-convolution layers. A convolution layer mixes each token with a small fixed window of its neighbours, here 7 tokens (LFM2 used 3). "Gated" means a learned multiplier controls how much of that mix passes through. These layers keep no per-token cache that grows with the input.
• 5 sliding-window attention layers. Sliding-window attention lets a layer look back only at the most recent tokens, here 256, instead of the whole context.
• 6 global attention layers. These see the full context and are what let the model connect a question on page 200 to a fact on page 3.

The reason this matters is the KV cache, the keys and values an attention layer stores for every token it has seen so it does not recompute them. In a standard transformer every layer has one, and it grows linearly with context. In LFM3 only the 6 global layers keep a full-length cache. The sliding-window layers cap theirs at 256 tokens, and the convolution layers barely need one.

Liquid reports that a 128K context needs about 1.6 GB of KV cache with LFM3-1.7B, against several gigabytes for comparable small transformers. On a phone with 8 or 12 GB of shared memory, that difference decides whether a long document fits at all.

Other details from the release: a 128,000-token vocabulary, head-wise gated attention, partial rotary position embeddings in the global layers, and 22T tokens of pretraining. The context was extended in stages, first to 32K, then 128K, then 256K.

What are the d1 decision models?

The d1 models do not generate free text. You give them an input and a list of questions, and they answer all of them in a single forward pass, each answer with a calibrated probability. A calibrated probability is one you can trust as a number: if the model says 0.9 across many cases, it should be right about 90% of the time.

Liquid describes typed answer kinds:

• yes/no, multiple choice and scores
• Point: bounding boxes, with a count
• Read: text, numbers or dates, with the exact source span, or "not found"
• Estimate: a number with a likely range
• Pick: every option that applies, each with its own probability

This is a different contract from a chat model. You are not parsing prose and hoping it followed your JSON instructions. You ask fixed questions and get typed answers plus a confidence you can threshold on. It is the same idea behind Cloudflare's Clef decision models: use a small model to make routing and checking decisions quickly, and save the big model for work that needs it.

Use d1-2B for text and images, and d1-Omni-2B when the input includes audio.

How do you run LFM3 locally?

The weights are on Hugging Face under the LiquidAI organisation, with ready builds for most runtimes:

With Transformers, the repository uses custom code, so you have to opt in:

from transformers import pipeline

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

messages = [{"role": "user", "content": "Summarise this ticket in one line: ..."}]
print(generator(messages, max_new_tokens=256)[0]["generated_text"])

To serve an OpenAI-compatible endpoint on a GPU:

vllm serve "LiquidAI/LFM3-1.7B"

For llama.cpp, the model card says you need a build with LFM3 support, so update before you try the GGUF files. The model is also available through Liquid's own API and Playground, and through launch partners including OpenRouter and Vercel.

A few practical notes from the model card:

• Recommended sampling for general use is low temperature (0.1, top_k 50, repetition penalty 1.1). For math and STEM it suggests temperature 1.0, top_p 0.95, top_k 20.
• Thinking is on by default. You can pass enable_thinking=False, but the card warns this can be inconsistent, so test it on your own prompts.
• Tool calls use an XML-style format inside <tool_call> tags, not JSON. If your agent framework expects JSON tool calls, check that its parser handles this template.

When should you use LFM3?

Reach for it when the model has to run where the data is: on-device assistants, offline apps, browser or desktop tools, or a cheap first pass in a server pipeline. A 1 GB model with a small KV cache can sit next to your app without taking over the machine. If you are comparing small open models for agent work, JetBrains Mellum2.1 takes a different route, using a mixture-of-experts design aimed at coding.

Skip it as your main model for long, multi-step coding or hard reasoning; the model card says as much. And read the LFM Open License text before shipping it in a commercial product, since it is Liquid's own license rather than a standard one like Apache 2.0.

Key takeaways

• LFM3 is a family of six roughly 2B open-weight models from Liquid AI: text, vision, audio, omni and two decision models.
• Only 6 of the text model's 24 layers use full attention, which keeps the KV cache small even at long context.
• LFM3-1.7B supports 256K tokens and fits in about 1 GB at 4-bit.
• The d1 models return typed answers with calibrated probabilities instead of free text.
• Builds exist for Transformers, vLLM, SGLang, llama.cpp, MLX and ONNX.

FAQ

Is LFM3 open source?

The weights are open and downloadable from Hugging Face, under the LFM Open License v1.0. That is a custom license, so check its terms for your use case rather than assuming it behaves like Apache 2.0 or MIT.

Can LFM3 run on a phone?

That is its main target. The text model takes about 1 GB at 4-bit precision, and Liquid lists phones, a Raspberry Pi 5, laptops and NPUs among the devices it benchmarked.

What is the difference between LFM3-Omni-2B and d1-Omni-2B?

LFM3-Omni-2B is a generative model that takes text, images, video and audio and replies in text or speech. d1-Omni-2B is built on it but answers a fixed list of questions with typed values and probabilities, which makes it better suited to fast classification and extraction.