LiquidAI launches LFM3, a 2B parameter multimodal model family

LiquidAI has released LFM3, a new generation of Liquid Foundation Models designed to run on a single 2B parameter backbone. The suite covers text, vision, audio, omni, and decision tasks. Developers can fine-tune these models on local hardware and deploy them directly to the edge.

LFM3 introduces four specific improvements over the previous LFM2 family:

• Efficiency gains: A new tri-hybrid architecture and training recipe allow LFM3-1.7B to outperform LFM2.5-2.6B while using 35% fewer parameters.
• Unified backbone: Six 2B-class models branch from a single base, including the first omni model and video input for the vision model.
• Edge optimisation: The text model fits in roughly 1 GB at 4-bit precision, while new in-house vision and audio encoders speed up processing. The 256K context window enables on-device agent operations.
• Specialisation: Every model fine-tunes on a single GPU, allowing adaptation to specific data, terminology, and deployment environments.

Architecture changes for agentic use cases

LFM2 proved that mixing short convolutions with attention could run fast on devices without losing quality. For LFM3, the team used a hardware-in-the-loop architecture search to redesign the model for agentic workflows. This requires higher capability per parameter and fast inference over long contexts. The search covered 14 device and backend combinations, ranging from phones and a Raspberry Pi 5 to laptops, cloud CPUs, GPUs, and the Qualcomm Hexagon NPU.

LFM3-1.7B-Base contains 24 layers and incorporates four main structural changes:

• Tri-hybrid layer mix: The model uses 13 gated short convolutions, 5 sliding-window attention (SWA) layers with a 256-token window, and 6 global attention layers. The convolution kernel size increased from 3 in LFM2 to 7.
• Head-wise gated attention: A sigmoid gate scales each head’s output, allowing heads to switch off when unnecessary. This helps suppress activation outliers that can harm quantization.
• Partial RoPE: Global attention layers rotate only the highest-frequency half of each head, ensuring the other half matches on content regardless of distance. SWA layers retain full RoPE.
• Sandwich norm: Each block normalizes both its input and output to keep activations well-scaled.

The results show improved performance at long context lengths. Per parameter, LFM3-1.7B matches LFM2-1.2B on short prompts across edge devices. With 8K tokens in context, it is approximately 25% faster. The base model was pre-trained on 22T tokens using the same 128K vocabulary as LFM2.5-8B-A1B. The final 3.5T tokens come from a mid-training stage on curated data with a larger share of agentic traces and tool calls, which extends the context window to 256K tokens.

One backbone, six models

Every LFM3 model branches from LFM3-1.7B-Base. Instead of running one large general-purpose model, users select the variant that fits their inputs, customise it, and run it on-device.

The vision and audio models also receive two new in-house encoders:

• Vision encoder: This combines convolution and attention and uses 3x less compute than the SigLIP2 encoder in previous LFM VL models. The 164M-parameter encoder matches Qwen3.5-2B’s vision encoder in accuracy while requiring 2.2x fewer FLOPs (both measured with the same LFM2.5-230M language backbone). For video, it embeds each pair of sampled frames into one temporal slice, halving the temporal sequence length.
• Audio encoder and LiquidCodec: The audio encoder mixes sliding-window attention and short convolutions and is fully causal, allowing the model to prefill while you speak, with time to first token as low as 50 ms. LiquidCodec, the new audio tokenizer, turns generated tokens into speech at about 87x real time on a single CPU thread on an Apple M4 Max and supports streaming decoding.

Using the LFM3 models

Each model runs in transformers. The code snippets below come from the model cards, which also list other inference engines.

LFM3-1.7B

Use LFM3-1.7B for local agents, tool calling, structured outputs, or as a base for domain-specific fine-tuning. It is post-trained to run in agentic harnesses such as Hermes Agent, Pi, and OpenClaw. It outperforms its predecessor, LFM2.5-2.6B, with 35% fewer parameters. The biggest gains appear on agentic tasks: on WebArena-Verified, it scores 38.42 against 3.02, and it beats Qwen3.5-9B on long tasks in browsers and business apps. Further details are available in the LFM3-1.7B model card.

To run LFM3-1.7B, install the latest version of transformers:

pip install -U transformers

Then load and run the model:

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-VL-2B

Use LFM3-VL-2B for on-device visual understanding. It is the first LFM vision model to accept video as input; it reasons step by step before answering and identifies objects and their placement, a strong foundation for robotics. Compared with LFM2.5-VL-3B, it has fewer parameters (1.9B against 3.1B) yet raises the average across 62 vision benchmarks from 57.6 to 71.4, on par with Gemma 4 12B, a model more than six times larger. Details are in the LFM3-VL-2B model card.

To run LFM3-VL-2B, install transformers>=5.21.0 with its vision dependencies:

pip install "transformers>=5.21.0" torch torchvision pillow

Then load and run the model:

import torch
from transformers import AutoModelForImageTextToText, AutoProcessor

model_id = "LiquidAI/LFM3-VL-2B"

model = AutoModelForImageTextToText.from_pretrained(model_id, dtype=torch.bfloat16, device_map="auto", trust_remote_code=True)
processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://placecats.com/300/200"},
            {"type": "text", "text": "Describe this image."},
        ],
    }
]

inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
).to(model.device)

with torch.inference_mode():
    output_ids = model.generate(
        **inputs,
        do_sample=True,
        temperature=0.1,
        top_k=50,
        repetition_penalty=1.1,
        max_new_tokens=16384,  # generate() needs an explicit limit; reasoning can be long
    )

generated_ids = output_ids[:, inputs["input_ids"].shape[1]:]
print(processor.batch_decode(generated_ids, skip_special_tokens=True)[0])

See the LFM3-VL-2B model card for tool calling, tool search, and on-device inference with llama.cpp.

LFM3-Audio-2B

Use LFM3-Audio-2B for voice chat, speech recognition, speech synthesis, or translation across 18 languages on a laptop or edge device. It accepts text or audio as input and responds with text, speech, or both, and can turn spoken requests into tool calls. Compared with LFM2.5-Audio-1.5B, it uses a new in-house audio encoder and speech codec, speaks with higher quality (UTMOSv2 3.83 against 3.22), and adds audio understanding, general-purpose audio reasoning, and tool