Small Enough to Run Locally, Smart Enough to Go Multimodal

Small Enough to Run Locally, Smart Enough to Go Multimodal

Artificial intelligence has spent years moving in one direction. Models have become larger, computing requirements have increased, and infrastructure has grown more expensive. Every new generation has reinforced the idea that better intelligence requires more parameters, bigger data centres, and greater access to cloud resources. But that approach creates a practical problem. The more capable AI becomes, the harder it can be to deploy affordably, privately, and reliably across everyday devices.

Liquid AI takes a different approach with its LFM3 family. Announced on October 27, 2026, LFM3 is a collection of compact, open-weight models designed to support text, vision, audio, multimodal interaction, and structured decision-making. Its central idea is not simply to make AI smaller. It is to make smaller models useful enough to perform specialised tasks without constantly depending on large remote systems. [1]

The distinction matters. A model that fits on a device but struggles with real tasks is not especially useful. A model that performs well but requires expensive infrastructure may be impractical for many developers. The real challenge is balancing capability, latency, memory, and deployment cost. LFM3 offers an interesting case study in how that balance might be achieved.

When Model Size Stops Telling the Whole Story

Parameter count has become one of the most familiar ways to describe an AI model. A model with billions of parameters can learn complex patterns, represent relationships across large amounts of information, and support a wide range of applications. However, parameter count alone does not tell us how efficiently a model uses its capacity or how well it performs a particular task.

Two models of similar size can behave very differently because of differences in architecture, training data, optimisation, and post-training. Likewise, a compact model trained for a particular workflow can sometimes outperform a much larger general-purpose model on that workflow.

This is the principle behind specialised intelligence. Instead of expecting one model to excel at everything, developers can begin with a capable foundation model and adapt it to a narrower domain, such as document processing, customer support, visual inspection, or voice-based assistance.

Liquid AI positions LFM3 around this idea. According to the company’s official LFM3 announcement, LFM3-1.7B outperforms its earlier LFM2.5-2.6B model on its evaluations despite using approximately 35% fewer parameters.  [1] That is a company-reported comparison rather than proof that smaller models universally outperform larger ones, but it illustrates the engineering direction. The goal is to improve the capability delivered by each parameter rather than relying entirely on additional scale.

The practical implications extend beyond benchmark scores. A compact model may require less memory, consume fewer computing resources, and respond more quickly on supported hardware. It may also be easier to customise for a specific application, allowing teams to build systems around their own data and requirements.

The important question is therefore not simply how small a model can become. It is how much useful work it can perform within a realistic deployment budget.

The Architecture Behind LFM3

LFM3 builds on Liquid AI’s earlier work with hybrid neural network architectures. Traditional transformer models rely heavily on attention mechanisms, which help a model determine how different parts of an input relate to one another. Attention is powerful, but processing long sequences can create significant computational and memory demands.

As described in the company’s technical overview of LFM3, the architecture combines three types of sequence-processing layers. These are gated short convolutions, sliding-window attention, and global attention. Its text backbone contains 24 layers distributed across these three mechanisms. [2]

Model architecture
Inside LFM3-1.7B
A 24-layer hybrid backbone combines three sequence-processing mechanisms.
13
Gated short convolutions
Process local patterns efficiently.
5
Sliding-window attention
Connect information within a limited context.
6
Global attention
Connect information across longer sequences.
Layer distribution shown for the LFM3-1.7B text backbone.

Figure 1. LFM3 combines gated short convolutions, sliding-window attention, and global attention within a hybrid text architecture. [2]

Short convolutions can efficiently process nearby information, while sliding-window attention allows the model to examine a bounded region of tokens. Global attention provides broader connections when information from distant parts of a sequence needs to interact. Combining these mechanisms gives the architecture different ways to process information instead of making every layer perform the same kind of computation.

Efficiency is not achieved by removing complexity everywhere. It comes from deciding where that complexity is actually needed.

The balance is important. Removing global attention entirely could restrict the model’s ability to connect distant information, while relying exclusively on full attention could increase computational costs. A hybrid architecture attempts to retain useful long-range reasoning without paying the full cost at every layer.

LFM3 also introduces head-wise gated attention. In a conventional attention layer, multiple attention heads learn different relationships within the input. LFM3 applies a gate to each head’s output, allowing the model to reduce the contribution of a head when it is not useful. The design is intended to improve control over activations and support more stable, efficient inference.

The architecture was developed using hardware-in-the-loop evaluation. Rather than optimising only for abstract computational metrics, Liquid AI reports evaluating combinations of devices and backends, including phones, laptops, a Raspberry Pi 5, CPUs, GPUs, and specialised neural processing hardware. [1]

That approach reflects a broader engineering reality. The fastest architecture in theory is not always the fastest architecture on a particular device. Memory bandwidth, processor design, supported operations, and inference software all influence actual performance.

LFM3’s design therefore treats deployment hardware as part of the optimisation problem, not merely as a place where the finished model will eventually run.

Six Models, One Shared Foundation

LFM3 is not a single model intended to handle every possible input. Its first release contains six models derived from a shared foundation, with different variants designed for different forms of interaction. The official technical overview explains how these models extend the same underlying architecture to different modalities and tasks. [2]

The text model, LFM3-1.7B, is designed for language-based tasks and agent workflows. It can serve as a foundation for local assistants, research tools, and applications that interact with external software.

The LFM3 Model Family at a Glance

Different configurations target different input types and task requirements.

Model Primary Focus Potential Applications
LFM3-1.7B Text Local assistants and agent workflows
LFM3-VL-2B Vision and language Image and document understanding
LFM3-Audio-2B Audio Speech interaction and transcription
LFM3-Omni-2B Vision, audio, and language Multimodal assistants
d1-2B Structured decisions Classification and visual inspection
d1-Omni-2B Multimodal decisions Structured workflows using multiple input types

Application examples are illustrative. Confirm each model’s exact name, availability, and supported capabilities against the official model documentation before publication.

Figure 2. The LFM3 family includes configurations designed for text, vision, audio, and multimodal tasks.

LFM3-VL-2B extends the family into vision and language. It is designed for tasks involving visual information, including image understanding, document analysis, and video interpretation.

LFM3-Audio-2B focuses on audio-related tasks such as transcription and speech interaction. This capability can support applications in which spoken language is the primary input or output.

LFM3-Omni-2B brings together vision, audio, and language. Such a model can provide a foundation for applications that need to interpret different types of input rather than processing each modality in isolation. [2]

The family also includes d1-2B and d1-Omni-2B. These models focus on structured decision-making using text and other modalities. Instead of always generating a paragraph, they are designed for tasks that require outputs such as classifications, selections, numerical estimates, or locations within an image.

The shared foundation matters because developers do not necessarily need to start from an entirely unrelated model for every application. They can select the variant suited to their inputs and outputs, then specialise it for their own environment.

These capabilities should not be confused with every model having identical functionality. The variants are specialised, and their input formats, output capabilities, and performance characteristics differ.

The decision models introduce another distinction. Many AI systems generate a paragraph describing what they think is happening. That is useful for conversation, but unnecessary when an application needs a structured result. A document-processing system might need to identify an invoice, extract a date, assign a category, and report whether a required field is missing.

A decision-oriented model can return structured answers in a format that other software can process. LFM3’s d1 variants are designed around this kind of task.

For software developers, this changes how model outputs can be integrated into applications. Instead of parsing a long natural-language response and hoping it follows the expected format, a system can work with explicitly structured results. Reliability still needs to be evaluated for each task, but the output design is better aligned with many production workflows.

What the Benchmarks Actually Tell Us

Benchmark results are useful when they help explain what a model can do. They become less useful when individual scores are treated as universal measures of intelligence.

Liquid AI reports evaluations across agentic tasks, function calling, coding, knowledge, and long-context workloads for LFM3-1.7B. The results are available in the company’s LFM3 announcement and the model’s technical documentation. They suggest that the model is competitive in several areas despite its compact size, particularly in tasks involving instructions, tool use, and certain browser or business-application workflows. [1]

However, the results are not uniformly better across every category. The company’s own comparisons show larger models retaining advantages on some coding and knowledge-intensive evaluations. [1] This distinction is important because real applications rarely consist of a single benchmark task.

Consider an AI agent that must search for information, open a document, extract details, and update a record. Its success depends on more than whether it can generate a good answer. It must follow instructions, select the right tools, preserve relevant context, and recover when an action fails.

A model that performs well at function calling may be especially useful in this workflow, even if another model scores higher on a general knowledge examination. Conversely, an application involving complex programming or advanced scientific reasoning may benefit more from a larger model.

The most useful evaluation therefore combines several dimensions. Task success rate establishes whether the model completes the intended workflow. Tool-use accuracy measures whether it selects and invokes the correct tools. Latency indicates how long users wait for a response. Memory consumption helps determine whether the model fits within the device’s available resources. Token usage measures how much generated output a task requires. Recovery behaviour shows whether the model can handle errors and incomplete actions.

These measurements should be considered together. A model that completes a task accurately but takes too long may not suit a real-time application. Another that responds quickly but frequently chooses the wrong action may create more work than it saves.

It is also necessary to distinguish vendor evaluations from independent testing. Benchmark scores depend on the test set, model configuration, inference framework, prompting strategy, and evaluation procedure. Comparisons are strongest when models are tested under consistent conditions and the methodology is clearly documented.

LFM3’s results are best interpreted as evidence that compact models can be competitive in selected workloads, not as evidence that model size has stopped mattering.

Can Intelligence Really Run on the Edge?

One of LFM3’s most important design goals is local deployment. In a conventional cloud-based AI application, a device sends a request to a remote server, the model processes it, and the response travels back. This approach can provide access to powerful hardware, but it also introduces network dependencies, recurring infrastructure costs, and potential data-handling concerns.

An on-device model moves at least part of that processing closer to the user. For supported workloads, this can reduce the need to transmit every request to a remote service.

According to the LFM3-1.7B model card, the text model can fit in approximately 1 GB at four-bit quantisation. [3] Quantisation represents model parameters using lower-precision numerical values, reducing the memory required to store them. The trade-off is that lower precision can affect model quality, depending on the model, quantisation method, and task.

A simplified way to express the relationship is:

Memory Estimation
Model memory ≈ Parameter count × Bytes per parameter
How to read it:
The approximate storage required for model weights depends on the number of parameters and the number of bytes used to represent each parameter.

Formula 1. A simplified estimate of model weight storage based on parameter count and numerical precision.

At four bits per parameter, the raw parameter storage is approximately half a byte per parameter. For a 1.7-billion-parameter model, that gives roughly 0.85 billion bytes of raw parameter data before accounting for additional implementation and runtime requirements.

How Quantization Changes Weight Storage

Estimated raw weight storage for a model with 1.7 billion parameters, using three illustrative parameter precisions.

4-bit
0.85 GB
8-bit
1.70 GB
16-bit
3.40 GB
Key takeaway:
Lower-precision weights can reduce storage requirements, although actual savings depend on the model format and implementation.

Estimates use 1.7 billion parameters multiplied by 0.5, 1, or 2 bytes per parameter. Values use decimal GB and represent raw weight storage only, not total RAM usage or downloadable file size.

Figure 3. Estimated raw weight storage for a 1.7-billion-parameter model at 4-bit, 8-bit, and 16-bit precision.

The actual memory footprint is not determined by weights alone. Inference also requires working memory, intermediate activations, and, in models using attention, a key-value cache that stores information from previously processed tokens. Longer contexts can therefore increase memory use even when the model’s parameter count remains unchanged.

This is especially relevant to LFM3’s 256K-token context window. A large context allows the text model to process substantial amounts of information within a single interaction, but the maximum supported context should not be interpreted as a guarantee that every long-context task will be equally accurate or inexpensive. [3]

Hardware also matters. A model may technically fit in memory yet run too slowly for an interactive application. Performance depends on the processor, memory bandwidth, quantisation format, inference engine, context length, and the amount of concurrent work.

Liquid AI reports that LFM3-1.7B delivers faster decoding than comparison models on the devices it tested. Those results are useful indicators, but they should not be generalised to every phone or laptop. Developers need to benchmark the model on the hardware and software configuration they actually intend to deploy. [1]

Local execution also changes the privacy equation, but it does not automatically guarantee privacy. An application can still transmit data through analytics, logging, external tools, synchronisation, or cloud-based services. A genuinely local system needs to be designed so that sensitive information remains on the device when that is the intended requirement.

The strongest opportunity is not that every AI task will move entirely onto a phone. It is that more tasks may be completed locally, with cloud models reserved for requests that genuinely require additional capability.

The Real Opportunity and the Remaining Limits

The value of LFM3 lies in the combination of compact models, multiple modalities, and the ability to specialise them for particular tasks. Together, these characteristics could make it easier to build AI systems that operate close to users, respond quickly, and adapt to specific applications.

Consider a field-inspection workflow. A technician could capture an image, ask a question through speech, and receive a structured assessment. A local vision model could analyse the image, an audio-capable model could handle spoken interaction, and a decision model could classify the result into a format understood by the inspection software.

A similar approach could support document processing. An application might extract information from an invoice, check whether required fields are present, and route the document to the appropriate workflow. Instead of treating every request as an open-ended conversation, the system could use a model suited to each stage of the task.

The real promise of local AI is not to put every capability into one model. It is to put the right capability close to the task.

A Local-First AI Workflow

One possible deployment pattern is to process routine requests locally and escalate selected tasks when additional capability is needed.

User Input
Text, image, or audio
↓
Local Model
Process the request on the device
↓
Evaluate the Result
Check confidence, completeness, and task requirements
↙ Routine request
Complex request ↘
Use Local Result
Keep processing on the device when suitable
Optional Cloud Escalation
Use a cloud model when appropriate and permitted
↓
Application Output
Validate and deliver the result

Illustrative deployment pattern, not a built-in LFM3 feature. Escalation rules, privacy controls, validation, and model selection depend on the application.

Figure 4. A local-first AI workflow can handle suitable requests on-device while allowing selected tasks to be escalated to a cloud model.

These are potential applications, not guarantees that an out-of-the-box model will perform them reliably. Real deployments require testing on representative data, careful handling of uncertain results, and safeguards for consequential decisions.

Specialisation also introduces its own challenges. Fine-tuning can improve performance on a narrow task, but poor-quality training data can reinforce errors. A model that performs well on familiar examples may struggle with new document layouts, unfamiliar accents, unusual lighting, or unexpected user behaviour.

Developers must also consider licensing, hardware compatibility, model updates, and the cost of maintaining specialised versions. Open weights make experimentation and customisation possible, but they do not eliminate the work required to build a dependable product.

Finally, compact models should not be treated as automatic replacements for larger systems. Some tasks benefit from extensive knowledge, complex reasoning, or broader capabilities that remain difficult to reproduce in a smaller model. A practical architecture may combine local inference for routine tasks with remote models for more demanding requests.

This creates a more useful way to think about the future of AI deployment. Rather than choosing between a small model and a large one as a universal decision, developers can choose where each model belongs in the system.

LFM3 represents a step in that direction. Its significance is not simply that a model can fit into a limited memory budget, or that several modalities can share a common foundation. It is the attempt to make compact models capable enough to become useful components of real software.

The next phase of AI will depend on more than building larger models. It will also depend on making intelligence efficient, specialised, and practical enough to run wherever the work actually happens.

References

[2]  Liquid AI.
Build Specialized Multimodal Models with LFM3
Hugging Face, October 27, 2026.
Was this article helpful? No ratings yet