AI Models

Liquid LFM3: 1.7B Edge Agents, Six Models, and License Limits

A deployment-focused audit of Liquid AI's October 27 LFM3 release: tri-hybrid architecture, 256K context, official GGUF variants, vendor benchmarks, and the $10M license threshold.

Approximately 9 min read

On October 27, 2026, Liquid AI announced LFM3, a new family of six small open-weight models spanning text, vision, audio, combined multimodal input and structured decisions. The headline text model has 1.73 billion parameters and a 256K-token advertised context window. Liquid says it is faster and more capable than its larger LFM2.5 predecessor in selected evaluations.

The release is notable for an engineering reason beyond the usual model-size comparison: it combines an unusual tri-hybrid sequence architecture, multiple modality-specific descendants of one backbone, official GGUF files, and a tool-use interface aimed at small on-device agents. It also has a license condition that can matter more to a commercial deployment than any benchmark.

This article checks the public release artifacts and separates model-card specifications from performance claims. No LFM3 checkpoint was downloaded, run, fine-tuned or independently benchmarked for this article.

What actually shipped

The official LFM3 collection lists the pretrained LFM3-1.7B-Base and six task-oriented descendants. They are not six interchangeable chat checkpoints.

Checkpoint Input Output Intended role
LFM3-1.7B Text Text and tool calls Local assistant, constrained workflows, specialization
LFM3-VL-2B Text, image, video Text Visual question answering and perception
LFM3-Audio-2B Text, audio Text and speech Recognition, speech generation and voice interaction
LFM3-Omni-2B Text, image, video, audio Text and speech Combined audio-visual assistants
d1-2B Text, image, video Structured decisions Classification and calibrated choices
d1-Omni-2B Text, image, video, audio Structured decisions Decision tasks with speech or audio context

The table reflects the publisher’s family-level technical explanation, not independent tests of every modality. The decision models are a different product shape: they return answers to a defined set of questions rather than generating a free-form paragraph. Treating their single-forward-pass outputs as equivalent to a conversational LLM would be a category error.

For readers evaluating one small local model today, LFM3-1.7B is the most straightforward entry point. The base checkpoint is for substantial continued training or post-training, not an instruction-following replacement for the post-trained model.

Why the 24-layer architecture matters

The text model card specifies 24 layers: 13 gated short-convolution layers, five sliding-window attention layers and six global-attention layers. This is the concrete meaning of tri-hybrid here. It is not an all-attention transformer and not a purely recurrent model.

Short convolutions can update local representations without maintaining the same full-history attention state as a global attention layer. Sliding-window attention bounds which earlier positions are attended to directly, while the six global-attention layers provide paths to longer-range information. The precise runtime memory behavior still depends on implementation, batching, cache representation and context length. The presence of convolutional layers does not mean a 256K-token prompt has negligible prefill cost.

Liquid reports a 128,000-token vocabulary, support for 16 languages, and 22 trillion tokens of pretraining for the backbone. The base model card says the final 3.5 trillion tokens were curated mid-training data emphasizing agent traces and tool calls, while extending context length. These are vendor-supplied training details, not independently audited data provenance.

A useful comparison with an ordinary transformer must hold model task, tokenization, quantization, prompt length, output length and backend constant. Parameter count alone is not a proxy for wall-clock latency or quality. In particular, changing the tokenizer changes the number of tokens used to represent the same document, which can distort both speed and context comparisons.

The 1 GB claim has a narrow meaning

Liquid says the text model needs roughly 1 GB at four-bit precision. The official GGUF repository makes this concrete: its Q4_0 file is about 1.05 GB and Q4_K_M about 1.1 GB, while BF16 is roughly 3.47 GB. These are artifact sizes, not guarantees of total runtime RAM.

A running process also needs space for execution buffers, caches, temporary tensors, the tokenizer, runtime bookkeeping and any offloaded or multimodal components. The 256K advertised context is a maximum model capability, not a promise that every phone can sustain that context with 1 GB of total memory. A realistic deployment must measure peak resident memory and time to first token at its intended context length.

The text model’s large context also should not be confused with reliable retrieval across that entire window. Before using it for long documents or agent histories, test whether it can identify facts at the beginning, middle and end of the context; whether it follows instructions from the correct turn; and whether it preserves tool-call state across a long session.

Official GGUF exists, but runtime compatibility is version-specific

The LFM3-1.7B-GGUF model card publishes Q4_0, Q4_K_M and other quantizations. Its example invocation is:

llama-cli -hf LiquidAI/LFM3-1.7B-GGUF:Q4_K_M --temp 0.1 --top-k 50 --repeat-penalty 1.1

This is an upstream-documented command, not a command tested for this article. The model card explicitly requires an LFM3-compatible llama.cpp build. A machine running an older llama.cpp release can have a valid GGUF file yet fail to load the architecture or process the chat template correctly.

The repository also labels a separate Q4_0 file as quantization-aware-distilled (QAD). Do not assume every Q4_0 file was produced by straightforward post-training quantization. For a fair comparison, pin the exact GGUF filename, model revision, quantization recipe and backend build.

The publisher lists support across Transformers, vLLM, SGLang, MLX and other paths. That is a starting point, not proof that every current stable package supports every LFM3 variant. In particular, the vendor’s FP8 model card says SGLang support for that variant was still under review at launch. Check the exact model/runtime pair before promising production readiness.

For Python loading, the main model card includes examples with trust_remote_code enabled. That option is an explicit code-execution trust decision, not just a compatibility flag. Review and pin the repository revision before enabling remote model code in a sensitive environment.

Tool calling: a model response is not an authorized action

Liquid positions LFM3-1.7B for local agents and deferred tool discovery. Its card documents XML-like tool-call formatting and a flow in which the application executes the selected tool and appends the result back to the conversation. The model does not acquire permission to execute tools merely because it can generate a syntactically valid call.

A deployment should independently validate the selected tool name, argument schema, caller authorization and output handling. If a tool returns an error or an untrusted document, that result must not silently become higher-priority instructions. Long context and deferred tool definitions make this separation especially important.

The model card is unusually candid about scope: the 1.7B text model is not recommended for agentic coding or complex multi-step reasoning. That warning matters when marketing examples suggest broad autonomous workflows. A small specialist can be effective at classification, extraction, simple routing and bounded tool use while still failing at open-ended plans.

A practical acceptance test should include malformed arguments, non-existent tools, conflicting tool results, adversarial retrieved text, schema-constrained JSON, and multi-turn state recovery. Report valid-call rate and correct final outcomes separately; a model that emits parsable XML can still choose the wrong action.

The benchmark claims need matched controls

Liquid’s text-model card reports strong scores against other small models on agent and browsing evaluations. It also claims large edge-inference advantages at 32K context. The card specifies a Q4_0 GGUF comparison, batch size one, 32,768 tokens of context, 100 generated tokens and GPU offload on an AMD Ryzen AI Max+ 395, Apple M5 Max and iPhone 17 Pro. These conditions are more informative than a single tokens-per-second headline.

But the results are vendor-reported, not independently reproduced here. The model card notes that LFM3 used a llama.cpp build with LFM3 support, while comparison models used llama.cpp release b11744. That difference is a potential confounder. So are tokenizer differences, device-specific kernels, cache behavior, and whether the benchmark’s 32K input represents a realistic agent history.

A sound reproduction would run the same physical input texts through every model, report both characters and model-specific tokens, pin each runtime commit, measure prefill and decode separately, and repeat cold and warm runs. For agents, compare correct completed tasks per unit time rather than only raw decode throughput. For edge devices, measure total process memory and sustained power or thermal throttling.

The model card’s high-concurrency B300 throughput projection is a different workload class from single-user phone inference. Do not extrapolate one to the other. A model that shines at 1,024 concurrent requests may not have the best interactive latency for one user, and vice versa.

The commercial license is not Apache 2.0

All these models are listed under LFM Open License v1.0. Liquid’s official license text is based on Apache 2.0 but adds a commercial-use condition. It defines the threshold as annual revenue of US$10 million or more for the relevant legal entity. At or above that threshold, commercial use is not licensed under the free agreement; a separate commercial license is required.

The vendor says qualifying nonprofit and noncommercial research uses are exempt from the threshold. Its terms also permit proprietary fine-tunes without a copyleft obligation, subject to the license conditions and attribution requirements.

This is open-weight, not an unqualified Apache-2.0 or OSI-style open-source grant. The distinction matters for enterprises, startups approaching the threshold, SaaS providers and distributors of fine-tuned weights. Review the full agreement and the legal-entity definition rather than relying on a model-card badge. The license discussion here is a summary of the published terms, not legal advice.

The release announcement’s availability claim should likewise be read carefully: weights are available to download, while managed API pricing, service guarantees and deployment options are separate commercial questions. A free local model artifact does not imply a free hosted endpoint.

Which LFM3 variant deserves a pilot?

For structured extraction and bounded agent routing, start with LFM3-1.7B and a small labeled evaluation set. Prefer the official Q4_K_M GGUF for a low-footprint local smoke test, but keep the BF16 checkpoint as a quality reference if hardware permits.

For video or visual inspection, use LFM3-VL-2B rather than forcing images through a text-only checkpoint. For voice, evaluate LFM3-Audio-2B’s end-to-end recognition and speech generation, including latency and accent robustness. For combined audio and video, the Omni variant is more relevant, but also has more complex memory and pipeline requirements.

For decisions that should return probabilities rather than prose, compare d1-2B or d1-Omni-2B against a simple classifier or rule system. Calibrate thresholds on your own labeled distribution. A vendor claim of calibrated confidence does not establish calibration for a new domain.

In every case, preserve a baseline, log the exact artifact revision and runtime build, and decide in advance which failure rate is acceptable. No model should be declared production-ready on the basis of its launch charts alone.

Verdict: a meaningful family, with measurable boundaries

LFM3 merits a Model Spotlight because it is a genuine new model family with published weights, a distinctive architecture, multiple modality-specific checkpoints and first-party quantized artifacts. Its most credible use case is specialized, bounded intelligence close to the data source, not a universal replacement for larger reasoning models.

Three things should determine adoption: whether the specific variant passes a task-level evaluation, whether the chosen runtime and memory budget actually work on the target device, and whether the legal entity is entitled to the intended commercial use. Those are testable questions. Launch-day benchmark rankings are only hypotheses until reproduced.

Primary references

Sources and further reading