Liquid AI Releases LFM3: Six 2B-Class Models Covering Full Edge Multimodality

Liquid AI has released its third-generation Liquid Foundation Models—LFM3—on Product Hunt, unveiling six 2B-class models at once. The company says they can run on edge devices such as phones, laptops, and robots. The models use open weights, share a single backbone, and span text, vision, audio, omni-modal, and decision models. The smallest is a 1.7B text model that is about 1 GB in size after 4-bit quantization, supports a 256K context, and can be fine-tuned on a single GPU.

One Backbone, Six Modalities

The most noteworthy design of LFM3 is the "shared backbone." According to the official description, the text, vision, audio, omni, and decision models are not isolated systems trained independently; they are built on the same underlying structure. This approach is uncommon among edge models, and its direct benefit is more consistent behavior across the model family. Downstream teams combining multiple modalities do not need to separately adapt to several vastly different network architectures.

All six models in the first batch are 2B-class, a size range that is currently the sweet spot for edge deployment: large enough to handle real tasks, yet small enough to run on consumer-grade hardware. Liquid AI explicitly positions them for phones, laptops, and robots, indicating that the target is not cloud inference but localized, low-latency scenarios where data does not leave the device.

Shared backbone means that models for multiple different modalities reuse the same underlying network parameters or structure, rather than training an independent model from scratch for each modality. A common approach is to attach different data through modality-specific input/output adapters (such as vision patch embedding or audio encoders) on top of a base Transformer, so that most parameters are shared across modalities. The benefits include a smaller total parameter count, easier multimodal alignment, and consistent interfaces for downstream combination. The challenge is that data distributions and computational requirements differ greatly across modalities; sharing too much may degrade performance in some modality, so a trade-off is needed between sharing and specialization.

Engineering of the 1.7B Text Model: 1 GB and 256K Context

The most concrete numbers among the six models come from the 1.7B text model: about 1 GB in size under 4-bit quantization, with a 256K context length. These two metrics only make sense when considered together. A 256K context usually implies considerable KV cache overhead. Keeping total usage in the 1 GB range suggests that the model has been specifically designed in both architecture and quantization strategy, rather than simply compressing a general-purpose model and stuffing it into a phone.

For application developers, the 1 GB threshold means the model can be distributed alongside an app, or leave enough memory headroom for other features on mid-to-low-end devices. The 256K context opens up localized possibilities for tasks such as long-document processing, long-conversation memory, and codebase retrieval—capabilities that previously relied largely on cloud-based large models.

4-bit quantization compresses model weights from the commonly used 16-bit floating point to a 4-bit integer representation, reducing storage and memory usage to about one quarter. For a 1.7B-parameter model, the theoretical size under 4-bit is about 0.85 GB, and with overhead such as embedding layers and quantization scaling factors it approaches 1 GB. Quantization introduces precision loss, typically mitigated through grouped quantization, calibration data, and similar methods. KV cache stores the key-value pairs of historical tokens during autoregressive inference; the longer the context, the larger the usage. With a 256K context, the KV cache can reach several GB, so strategies such as quantization, paged attention, or sparsification are needed to keep total usage within an acceptable range for edge devices.

Single-GPU Fine-Tuning Lowers the Customization Barrier

Another key point mentioned officially is that the models "can be fine-tuned on one GPU," meaning fine-tuning can be completed on a single GPU. For edge models, this information is no less important than the model size itself. What enterprise customers really care about is whether they can use their own data to turn a general model into a specialized one, and fine-tuning cost directly determines the barrier to doing so. Single-GPU fine-tuning means small and medium teams, and even individual developers, can participate in customization without relying on large-scale training clusters.

The weights are already available on Hugging Face and released as open weights. Combined with single-GPU fine-tuning capability, LFM3 effectively connects the entire chain of "download—fine-tune—deploy to edge," which is especially attractive for scenarios requiring private deployment, such as robotics, automotive, and industrial equipment.

Open weights means the model parameters can be downloaded publicly, but the training code, data, or complete training pipeline may not be open, which differs from fully open-source models. Users can perform local inference, fine-tuning, and quantized deployment, but must comply with the license terms on the model card (such as whether commercial use is allowed and whether attribution is required). Single-GPU fine-tuning usually relies on parameter-efficient fine-tuning techniques (such as LoRA), training only a small number of additional parameters and greatly reducing VRAM requirements. A 1.7B model with LoRA fine-tuning on a 4-bit quantized base can be completed on a single consumer-grade GPU (such as one with 24 GB of VRAM).

Competitive Position in Edge Multimodality

The release of LFM3 continues Liquid AI's consistent approach: rather than building the largest and strongest general model, it concentrates resources on efficient architectures and edge deployment. Six 2B-class models covering five modalities at once, plus open weights and single-GPU fine-tuning, form a relatively complete edge solution.

One note: the currently public information focuses on model specifications and deployment conditions. The company has not yet provided comparable data on the specific capability boundaries of each modality, actual inference speed, or performance on different hardware. On Product Hunt, the product received 104 votes and ranked 5th for the day. Discussion interest is moderate, but there are only 3 comments, so community feedback is still limited. For teams that actually need to select and deploy models, the weights are already open, and running benchmarks firsthand is more informative than reading spec sheets.

FAQ

Can LFM3 be used commercially? The weights are released as open weights on Hugging Face. Specific license terms should be checked in the model card, as different models may be subject to different agreements.

Is the 1 GB size after compression? It is the size after 4-bit quantization for the 1.7B text model. Full-precision versions will be significantly larger.

Can the 256K context be fully used on all devices? Long contexts bring additional memory and compute overhead. The actual usable length depends on device memory and the degree of optimization in the inference framework.

One-line Summary

Liquid AI releases six 2B-class LFM3 models with a shared backbone, covering multiple modalities and supporting edge deployment and single-GPU fine-tuning.

Paragraph Summary

Liquid AI released the third-generation Liquid Foundation Models (LFM3) on Product Hunt. The first six 2B-class models use a shared backbone design and cover text, vision, audio, omni-modal, and decision models, targeting edge devices such as phones, laptops, and robots. The smallest 1.7B text model is about 1 GB in size under 4-bit quantization, supports a 256K context, and can be fine-tuned on a single GPU. The weights are released in open form on Hugging Face, connecting the chain of download, fine-tuning, and edge deployment. However, the company has not yet published comparable data on capability boundaries across modalities, inference speed, or performance on different hardware, and community feedback is still limited. Actual model selection still requires running benchmarks independently.