Open Models · Evidence reviewed 21 November 2026
A small model becomes interesting when someone can run it on an ordinary device, inspect the implementation and measure what it actually accomplishes. Liquid AI’s LFM3 family now offers enough public evidence to make that investigation worthwhile: six specialised models, several substantial Rust implementations, and working examples that extend from desktop computers to a Raspberry Pi and a standalone headset.
The evidence also resists a convenient slogan. “Runs locally” does not establish acceptable response time, dependable answers or compatibility with every ageing laptop. This profile examines which parts of the promise have been demonstrated, which depend on particular software, and how to choose a useful first experiment.

One common foundation, six different purposes
Released on 27 October 2026, the family derives from LFM3-1.7B-Base. The six application models should not be confused with that additional base checkpoint. Four generate language or speech; two answer structured questions about a supplied state. Those decision models can process textual information as well as media: describing them simply as vision classifiers would conceal an important part of their design. Liquid AI’s family announcement.
| Model | Approximate parameters | Inputs and outputs | Published context | Appropriate starting point |
|---|---|---|---|---|
| LFM3-1.7B | 1.73 billion | Text → text | 256K tokens | Local language assistance, structured responses and tool selection. |
| LFM3-VL-2B | 1.92 billion | Text, images and video → text | 128K tokens | Questions about images and visually grounded descriptions. |
| LFM3-Audio-2B | About 2 billion | Text and audio → text and speech | 32K tokens | Transcription, speech synthesis and supported voice interaction. |
| LFM3-Omni-2B | 2.17 billion | Text, images, video and audio → text and speech | 32K tokens | One local assistant receiving several kinds of information. |
| d1-2B | 1.92 billion | State and typed questions, optionally images/video → structured answers and probabilities | 128K tokens | Fixed categories, estimates and other explicitly defined questions. |
| d1-Omni-2B | 2.17 billion | Multimodal state and questions, including audio → structured answers and probabilities | 128K tokens | Bounded decisions requiring visual or acoustic information. |
These are model capabilities and configuration limits, not guarantees that every application exposes them. “K” denotes the published token capacity, not an equivalent number of pages. Each model name links to its publisher’s documentation. On smaller screens, scroll tables horizontally to read every column.
The shared architecture combines thirteen short-convolution layers, five attention layers with a 256-token sliding window, and six layers of global attention. Liquid AI reports 22 trillion pre-training tokens, including a final 3.5 trillion-token stage emphasising higher-quality material and agentic tasks. The mixture makes the computational argument for local inference plausible, but global attention still creates memory costs as context grows. The architecture does not make a 256K conversation inexpensive merely because the weights are small. Architecture and training account; inspectable text-model configuration.
Openness, provenance and the limits of inspection
The downloadable weights, configuration files and inference implementations permit substantial inspection. They do not constitute a complete reproduction package for the original training process. This review did not locate a separate LFM3 technical paper in the release materials examined; the earlier LFM2 technical report provides historical context, not experimental validation of LFM3.
The weights use the LFM Open License v1.0, a custom licence with a commercial revenue threshold and specified exceptions. They should therefore be described as open weights under a custom licence, rather than universally unrestricted open-source AI. An Apache or MIT licence on a Rust implementation does not replace the conditions governing the model it loads. Organisations should examine the actual terms, including the US$10 million annual-revenue provision, before deciding that a proposed deployment is covered.
Liquid AI announced a US$250 million Series A financing round in December 2024 to support its broader development programme. That announcement describes the company’s resources; it is not a disclosure of the cost, accelerator count or energy consumption of LFM3 training. Those quantities cannot be reconstructed from the funding figure. Company financing announcement.
What has actually been measured?
Three kinds of evidence deserve separate treatment: evaluations from the model publisher, tests from the authors of an alternative implementation, and reports from external users. The latter two can expose practical limitations that a model card misses. They are still not automatically neutral comparisons, independently replicated findings or demonstrations of production reliability.
| Evaluation | LFM3-1.7B | Qwen3.5-9B in the same table | Reading the result |
|---|---|---|---|
| BFCL V4 | 71.39 | 62.83 | A promising tool-use result; application-level success still requires testing. |
| GPQA Diamond | 63.37 | 80.40 | Compact size does not remove the gap in difficult knowledge and reasoning tasks. |
| SWE-bench Verified, OpenCode | 43.40 | 51.20 | The agent and evaluation settings form part of the result. |
| RULER 128K | 65.56 | 87.11 | A supported context length does not ensure dependable retrieval throughout it. |
Source: pinned text-model card and evaluation settings. These are publisher results using BF16 serving, not measurements of a four-bit laptop installation. Their numerical scales and tasks differ; the table is not a general intelligence ranking.
Small computers: successful execution can still be slow
A Raspberry Pi 4 implementation provides unusually concrete evidence: paired timings, a stated protocol and checks against llama.cpp. With Q4_K_M weights and a 512-token context, its two short workloads produced approximately 3.2 output tokens per second, compared with about 2.9 for llama.cpp. Peak process memory was approximately 1,051 MiB, and first-token latency about 3.8 seconds. A separate six-prompt comparison matched 768 greedy token IDs. This supports a narrow claim of functioning, inspectable local text inference; it does not establish broad task accuracy or comfortable long-document use. The implementation is C/assembly, providing a useful reference outside Rust. Code, protocol and recorded comparisons.
An external Raspberry Pi 5 test used a 16 GB device, Q4_K_M, four CPU threads, a 4,096-token context and disabled reasoning. It reports 10.3 output tokens per second, 55.8 prompt tokens per second, 7.4 seconds to first text, 33.7 seconds per task and 2,285 MiB peak memory. Speed tests used ten repetitions; task timings used six fixed prompts, each repeated three times. The benchmark publishes the model hash and runtime revision. The measured process memory does not include the rest of the computer, and 16 GB is the tested configuration rather than a proven minimum. Complete Pi 5 result.
These examples make the practical distinction clear. A model may respond acceptably to a short classification request while remaining frustrating for a long interactive explanation. Count the time until a useful, correct answer arrives; output speed alone hides prompt processing and any preceding reasoning.
A headset demonstrates both feasibility and engineering effort
A public Quest 3S experiment uses LFM3-Omni Q8_0 with a modified llama.cpp build. Its author reports speech synthesis improving from 0.56 to 1.17 times real-time speed while connected to power, and from 0.33 to 1.02 on battery. Reported peak CPU memory falls from 4,174 to 992 MB, but that number excludes GPU memory. First launch remains approximately 20 seconds after optimisation. Published patches and English/Italian samples make the work inspectable. Some changes preserve intermediate outputs exactly; others alter quantisation or synthesis behaviour and rely on narrower quality checks. This demonstrates a viable particular installation, not universal real-time voice support immediately after downloading the model. Quest 3S experiment and samples.
Rust: five implementations worth examining
Rust is significant here because several projects implement the model’s computation, packaging or execution constraints directly. Merely placing a Rust interface around an unrelated inference service would provide much less evidence. Nevertheless, a Rust application can legitimately depend on GPU shaders, vendor drivers or low-level libraries written in another language. The meaningful questions concern the code that performs the computation, the supported modalities and the fidelity of its results.
| Project | Principal interest | LFM3 scope examined | Main qualification |
|---|---|---|---|
| Cortiq / CMF | Native inference, compact packaging and several accelerator routes | Text, vision, audio, Omni and decision-model documentation | Command-line and server interfaces expose different features. |
| Fusor LFM3 application | CPU inference in a browser through Rust and WebAssembly | All six models | Experimental application; model capabilities exceed its current interface. |
| Kinetic | Local GGUF inference on x86-64 desktops and laptops | Text LFM3 | Beta; mixed CPU/GPU execution has a documented correctness issue. |
| RavenRS / Candle | Embedding inference in a native Rust application | Custom LFM3 language-model implementation and audio work | Not evidence of complete six-model support in standard Candle. |
| Cera | CPU inference and a specialised Qualcomm NPU route | Text LFM3 | Device-specific validation; other models’ accelerator support cannot be transferred to LFM3. |
Cortiq: an unusually broad native route
Cortiq packages converted weights and associated model components into CMF files. For Omni, documented files occupy 2.78 GB with an eight-bit language model or 1.95 GB with a four-bit language model; other components remain at higher precision. Its version 0.8.50 measurements on an Apple M4 with Metal report 79 text tokens per second, 1.7 seconds for a short photo description including loading, and 3.4 seconds to synthesise approximately seven seconds of speech. These are implementation-author measurements. The server supports multimodal input with textual output, but does not expose all command-line speech functions. Omni packaging, measurements and limitations.
The decision-model conversions are particularly informative. For d1-2B, the author reports matching all 19 categorical answers in four test requests, while probability differences increase with stronger quantisation. For d1-Omni, the corresponding small test matches 22 of 22 answers at eight bits and 21 of 22 at four bits. A near-tied choice changes in the latter case. These checks are useful conversion evidence, but cannot establish calibration for an unfamiliar application. d1 conversion tests; d1-Omni conversion tests.
The implementation’s engine source and reference-comparison utilities make it possible to investigate discrepancies beyond reading a speed table. A serious evaluation should retain the exact converted artifact and compare the same inputs against the reference implementation, including probabilities and generated speech where relevant. Matching a description on one image is insufficient evidence for faithful behaviour across a collection.
Fusor: local inference inside a browser
The Fusor application compiles Rust inference to WebAssembly and runs on the CPU. Its authors report 97 text tokens per second on an Apple M4 Pro using eight threads in headless Chrome. That is the browser used by the published experiment, not a measurement across browsers. The timing represents a single run rather than a robust repeated estimate. Downloads are roughly 2–2.5 GB per model. The application is explicitly experimental: video and live transcription are among its unsupported functions, and conversation processing has practical limits below the model cards’ maximum contexts. Application, timings and current limitations.
The underlying fusor-ai library is the more substantial technical contribution: inspectable tensor operations, native and WebAssembly execution, and model-specific implementations. Its design separates computation from the surrounding application. A restricted inference module does not, by itself, prove that the web page, downloads, storage and every dependency are free of network activity. Those surrounding components remain part of any privacy assessment.
The published parity test requires exact prompt-token agreement and first-token agreement, then applies a threshold of at least 90% next-token agreement under teacher forcing. In that procedure, reference tokens are supplied instead of allowing every generated mistake to influence subsequent steps. Consequently, 90% agreement is neither 90% task accuracy nor a guarantee that complete answers will match. This distinction is essential when choosing the implementation for structured extraction or repeated decisions.
Building the browser application requires a Rust toolchain, Node.js and model conversion; distributing an already prepared model has different requirements. The documented build starts from full-precision originals, so its disk and memory demands should not be inferred from the final browser download size. Build instructions.
Kinetic: relevant laptop measurements, with a material beta limitation
Kinetic’s Q4_K_M comparison on a Ryzen 5 6600H laptop reports 31.1 text tokens per second on CPU against 26.8 for llama.cpp. With its RTX 3060 laptop GPU, the figures are 198.4 and 194.3. Much larger advertised gains concern repeated editing workloads, not ordinary generation. The current 0.1 release also documents divergent answers on later requests when a model is split between CPU and GPU. A proposed correction in development is not equivalent to a verified release. For reproducibility-sensitive work, this issue must be resolved or avoided and tested explicitly. Version status, conditions and comparison.
The LFM3 implementation is worth examining for its treatment of the hybrid architecture. For application selection, however, arithmetic throughput must be considered alongside state handling: a fast first request is insufficient if an identical later request can behave differently for implementation reasons.
RavenRS and Candle: integration requires model-specific work
RavenRS documents its own LFM3 implementation using Candle operations because the required architecture was not available through Candle’s model registry in that integration. It reports approximately 4 GB peak memory and 27 correct tool choices out of 32 test cases. Those are small author-reported checks, not a standard benchmark or a minimum specification. Its audio component includes synthesis work, while broader speech functionality remains incomplete. Versioned documentation; model implementation.
This route is particularly relevant to an application that needs control over loading, cancellation, memory release and the lifetime of a local model. Such integration concerns often matter more than a short maximum-speed demonstration. They should be tested together with the application’s ordinary workload, rather than with every other process closed and an unrealistically short prompt.
Cera: Rust reaches the NPU, with specialised dependencies
Cera documents LFM3 text inference on a Galaxy S25 Ultra through Qualcomm Hexagon: approximately 28 tokens per second with Q8_0 and 42 with Q4_0. Its validation includes comparisons against CPU results, but the documentation still identifies deeper per-step checks at long sequence lengths as unfinished. The route combines a Rust host with FastRPC and compiled DSP-side libraries; it is not evidence that every computation executes as pure Rust. Device measurements, architecture and remaining validation.
An NPU is therefore a specific deployment option, not an automatic speed advantage or a prerequisite for local LFM3. A reader should match the exact model, device, driver and execution path. Support for another architecture on the same software does not establish support for every LFM3 variant.
What is the minimum useful computer?
No single minimum has been demonstrated for the whole family. The smallest successful text experiment cannot be extended to simultaneous vision, audio and speech synthesis. Likewise, a file occupying about one gigabyte is not a one-gigabyte application: the process needs intermediate tensors, context storage and runtime resources, while the operating system and other applications need additional memory.
| Use | What is known | Practical starting profile | Status |
|---|---|---|---|
| Short text on a small board | Pi 4 execution around 3.2 tokens/s and 1,051 MiB process memory; limited context. | Use the published exact configuration. Expect patient, bounded interactions. | Documented narrow experiment, not a universal hardware minimum. |
| Everyday CPU-only text | Pi 5 and Ryzen laptop measurements show useful but markedly different response rates. | 8 GB system RAM, a supported modern instruction set, SSD storage and initially 2K–4K context. | Conservative editorial starting point; not measured here. |
| Images, short audio and Omni | Native and browser implementations work; media adds processing and memory costs. | Prefer 16 GB RAM. Begin with one image or short clip, one request and a bounded answer. | Provisional usability recommendation, not a certified minimum. |
| GPU-assisted local inference | Supported GPU paths can accelerate particular models and stages. | A compatible GPU with 6–8 GB VRAM is a reasonable trial profile, with sufficient host RAM. | No throughput claim for an untested card; drivers and context remain decisive. |
| Full-precision decision-model reference | At FP32, 1.92B/2.17B parameters imply roughly 7.68/8.68 GB for weights alone. | Start with at least 16 GB host RAM and small inputs; measure actual peak use. | Arithmetic lower bound plus provisional capacity planning, not a measured requirement. |
| Older laptop with 4 GB RAM | No general evidence reviewed establishes comfortable use across this family. | Consider only a tightly constrained text trial if software and available memory permit. | Insufficient evidence for a general recommendation. |
The observed Pi figures come from the linked experiments above. The proposed 8 GB, 16 GB and 6–8 GB profiles are explicitly editorial recommendations, not manufacturer requirements. GB and GiB differ; preserve the unit used by a measurement when comparing it with another result.
For any installation, record memory available before loading, peak process memory, GPU allocation where relevant, time to first useful output, total completion time and correctness. Repeat the test after several requests and with the laptop on battery. A configuration that works once while cold may encounter thermal limits, memory accumulation or a slower power mode during ordinary use.
The same care applies to storage. A prepared quantised model, a full-precision checkpoint, an audio codec and a vision projector can have separate files. Reserve space for the complete required set and check hashes. Building converters or all six models is a different undertaking from running one downloaded variant.
Why context and simultaneous requests change the calculation
The text configuration has six global-attention layers, four key/value heads and a head dimension of 128. Assuming an ordinary FP16 key/value cache, those global layers alone require 6 × 2 × 4 × 128 × context × 2 bytes: approximately 48 MiB at 4,096 tokens and 3 GiB at 262,144 tokens. These are calculated storage requirements for that cache representation, not measured process peaks. They exclude weights, convolution state, sliding-window caches and temporary buffers. A runtime that compresses, reallocates or otherwise represents the cache differently will have different requirements. Configuration used for the calculation.
This is a useful question to ask of a Rust implementation: does it retain only the necessary sliding-window history, how does it preserve convolution state, and what additional memory does each simultaneous request allocate? The language alone answers none of these questions. Measure the intended workload, especially when moving from a single interactive session to an application serving several requests.
Useful first applications and where to find examples
Choose a task whose success can be checked without trusting the model’s self-description. The following applications are proposed starting experiments, not claims of already validated deployments in every domain.
| Need | Candidate | Example route | What to check |
|---|---|---|---|
| Summarise a short local document or route a request | LFM3-1.7B | llama.cpp with the published GGUF; Kinetic for a separately validated Rust comparison. | Unsupported assertions, omitted conditions, correct tool selection and response time. |
| Describe a photograph or ask about a visible document | LFM3-VL-2B | Cortiq vision examples. | Small print, numbers, rotated pages, invented objects and image-resolution effects. |
| Transcribe a short recording or read text aloud | LFM3-Audio-2B | Publisher’s task-specific examples; Fusor application for a browser trial. | Word errors, language, names, noise, voice mode and complete end-to-end latency. |
| Ask a spoken question about an image | LFM3-Omni-2B | Cortiq multimodal examples. | Whether the answer uses the correct visual evidence and whether speech remains intelligible. |
| Choose among fixed document categories | d1-2B | Structured-question examples. | Class-specific errors, uncertain cases, probability calibration and changed document formats. |
| Make a bounded classification using sound and an image | d1-Omni-2B | Official input and question formats. | Missing modalities, misleading background sound and differences between spoken and written questions. |
Two small, auditable examples
For an initial image trial, Cortiq documents the following invocation. It presupposes a compatible installed runtime and the named model file. Replace the image with a non-sensitive test photograph and compare the description against what is actually visible. These commands are illustrative; they were not executed for this review.
cortiq run lfm3-omni-2b-q8_2f.cmf --image photo.jpg --prompt "Describe this image."
For a decision-model trial, prepare a small synthetic record and a question file using the project’s documented schema. Ask for an explicitly defined category and include an “insufficient information” option where the application permits it. The documented file-based interface is:
cortiq system-one d1-2b-q8_2f.cmf --state @record.json --questions @questions.json
Keep a manually checked answer sheet separate from the inputs. Include misleading wording, absent fields and cases near a category boundary. The important outcome is not simply whether valid JSON appears: it is whether the answer is correct, whether uncertainty is useful, and whether the same behaviour survives quantisation and repeated requests. The d1 documentation provides the supported question types and examples.
For a controlled comparison, change one element at a time: model, quantisation, runtime or hardware. Preserve the prompt, media, decoding settings and expected answer. Record at least several repetitions, both the first load and subsequent requests, and unsuccessful attempts. This modest discipline makes a personal installation report much more useful to the next reader.
Limitations and failure reports
Multilingual audio is task-dependent
The audio model documents 18 spoken languages, but voice chat and live transcription are English-only modes; offline transcription and text-to-speech have different coverage. Sampling also differs between audio input and output. A language list therefore cannot be read as a promise that every speech workflow works equally well in all those languages. Audio tasks and limitations.
An Omni user reports pronunciation problems in interleaved non-English speech, while a separate synthesis mode performs better in a small comparison. The assessment used the same model to transcribe its own output, and a subsequent discussion raises a possible language-parameter issue. This is a valuable failure report to investigate, not a conclusive attribution to the weights or a reliable population error rate. User experiment and discussion.
Fast audio components do not guarantee fast conversation
LiquidCodec’s reported speed of 87 times real time on one Apple M4 Max CPU thread refers to the codec. It does not include the entire language-model and speech-generation process. Conversation latency also includes recording, recognition, prompt processing, answer generation and playback preparation. Codec speed and a component’s first-output latency should not be substituted for an end-to-end measurement. LiquidCodec technical announcement.
Video understanding can fail at temporal coverage
A detailed Omni issue describes a 62.5-second video with 124 sampled frames and a generated timeline ending near 29 seconds, despite mentioning speech from the closing seconds. The reporter describes attempts with llama.cpp and Transformers, with configuration changes after memory exhaustion. The public discussion does not provide enough evidence to treat this as an independently replicated, controlled comparison. It nevertheless identifies a concrete test that prospective users should perform: place identifiable events near the beginning, middle and end, and verify that the model preserves their order and timing. Video coverage report.
Decision probabilities require validation in the intended setting
The d1 models evaluate typed questions in one forward pass instead of generating a conventional answer token by token. That interface can be useful for routing and constrained classification. It does not make a probability trustworthy under distribution shift. The d1-Omni documentation explicitly discusses weaker behaviour with longer spoken passages and differences between textual and spoken questions; its chance-adjusted “effective accuracy” is not ordinary percentage correct. d1 design and evaluation; d1-Omni limitations.
Fast published decision timings also have specific conditions. The d1-2B card reports warm, compiled execution, including approximately 18.6 milliseconds for one question on an Apple M5 Pro. Compilation, input preparation and the initial run are separate costs. Such a result cannot be promised on an older CPU or treated as the elapsed time of an entire application.
Precision, language and task scope remain consequential
Lower precision may make an installation possible while changing a marginal decision. An identical generated sentence on a few examples does not establish equivalent probabilities, equal speech quality or preservation of long-context behaviour. Conversely, a numerical difference need not invalidate an application if its consequences have been measured against the application’s requirements.
The publisher cautions against complex reasoning and agentic coding with the small text model. The vision model also has limitations in complex reasoning and multi-turn interaction. These are substantive boundaries for choosing a task, not footnotes to be removed from an otherwise favourable recommendation. Text-model limitations; Vision-model limitations.
Three recommendations for a first installation
For a generalist local assistant: LFM3-Omni-2B
Choose Omni when the same application needs text, images and short audio. Cortiq is a substantial native Rust route to investigate; Fusor is attractive for an experimental browser-based interface. Begin with short inputs, one request at a time and manually verifiable tasks. Prefer an eight-bit artifact when capacity permits and compare any smaller version before adopting it. This recommendation concerns breadth of interaction, not superiority in unrestricted reasoning or every supported language. Omni’s documented non-reasoning interface should also be respected. Omni model card.
For an LLM devoted to text: LFM3-1.7B
Choose the text model for summarisation of supplied material, constrained extraction and simple local assistance. It offers the clearest path to a small download and CPU-only testing. A four-bit GGUF with a deliberately modest initial context is a sensible experiment on limited hardware. Compare answer quality before seeking maximum speed. Use a Rust implementation only after checking the exact release and repeated-request behaviour; Kinetic’s documented beta issue makes an unqualified recommendation premature.
For image understanding: LFM3-VL-2B
Choose VL when the task is to describe, question or extract information from images and speech is unnecessary. Cortiq’s vision examples provide a practical Rust starting point. Evaluate your own photographs, scans and difficult text, preserving original resolution alongside any resized input. This is an image-understanding model, not an image generator. If the requirement is a fixed set of categories or typed decisions rather than a prose answer, evaluate d1-2B as a separate alternative and test its probabilities against labelled examples.
LFM3’s value lies in making these choices experimentally accessible. A useful installation report should therefore name the exact model, software revision, device, input and failure conditions. The family deserves attention because readers can now investigate those details themselves; the available evidence supports that investigation more strongly than it supports sweeping promises about any computer or any task.
Evidence scope and reproducibility
Reviewed on 21 November 2026. Official model documentation and configurations were pinned to the revisions linked in this article. Implementation snapshots: Cortiq b32616b8cab7; Fusor application 353cd426d427; fusor-ai 33b1c2036997; Kinetic 9b4844fd0bc7; RavenRS c5dd07683286; Cera 903809ea12b9. Measurements retain their original reported software versions where those differ from the documentation snapshot. Repository availability, code inspection and a published result were assessed separately from independent execution. No model weights were downloaded and no models were run for this profile. Reported device results remain attributable to their linked authors. Links to changing project pages are provided for installation guidance; pinned sources preserve the basis of this assessment.
Explore the Open Models collection · The Bible of AI (BAI)
Liked this post? Follow this blog to get more.