The push to run capable AI systems directly on phones, laptops, and other everyday hardware has grown steadily as cloud costs, latency, and data-privacy concerns accumulate.
Many teams have looked for ways to keep useful agent-style behavior close to the user without relying on large remote models for every step. Liquid AI, an MIT spin-off that has focused on efficient foundation models for on-device use, has pursued this direction through successive generations of its Liquid Foundation Models.
This time, the company introduced 'LFM3.'
The release is not a single flagship model.
Instead, it is a small set of roughly 2 billion parameter models that all grow from the same backbone.
One handles pure text and long contexts. Another accepts images and video. A third works with speech. An omni version combines vision and audio. Two decision models turn documents, pictures, or audio into structured answers an application can act on immediately. Because they share an architecture optimized for phones, laptops, and edge hardware, the same weights can be fine-tuned on a single GPU and then run locally without per-token fees.
LFM3 rests on a redesigned tri-hybrid architecture that mixes gated short convolutions, sliding-window attention, and global attention.
Of the 24 layers, 13 are convolutions with a kernel size of 7, five use sliding-window attention, and six are global attention layers. Additional details include head-wise gating, partial rotary position embeddings on the global layers, and sandwich normalization.
What that means in practice is a text agent that can sit on a laptop and triage an inbox, check a calendar, search the web, and pick the right tool among thousands of options, all while keeping the conversation history inside a 256,000-token window.
The vision model can watch a short clip or a camera feed, reason about charts or spatial relationships, and locate objects. In one reported adaptation, it was fine-tuned on a few thousand wind-turbine inspection photos and then described defects, supporting evidence, and locations.
The audio model listens to spoken requests and turns them into tool calls or spoken replies across eighteen languages, with a causal encoder that begins processing while the user is still talking.
The decision models answer multiple questions about the same input in one pass, returning bounding boxes, extracted fields with source spans, numerical ranges, or multi-select probabilities, so an application can route a support ticket or pull invoice data without another cloud call.
On several of the agent and vision tasks Liquid measured, these smaller models hold their own against systems several times larger.
The text model, for example, outscores a roughly 9-billion-parameter counterpart on certain browser and business-application benchmarks, and the vision model matches the average of a 12-billion-parameter model across a broad suite of visual tests.
Those results come from the company's own evaluations and do not erase the clear advantages larger models still hold on broad knowledge or complex coding. Liquid itself notes the size limit.
The practical point is narrower: for the kinds of specialized, tool-using, or multimodal jobs that can be defined in advance, a model that fits in about a gigabyte at 4-bit precision and can be adapted in hours is often enough.
The architecture itself was chosen by measuring both quality and real hardware behavior across phones, a Raspberry Pi, laptop chips, cloud CPUs, GPUs, and an NPU.
Most layers are short convolutions rather than full attention, which helps keep speed and memory use reasonable as context grows.
The result is less a claim that small models have become universally superior and more a demonstration that, for agents that live on the device, specialization and efficient design can close a large part of the gap that once required a data-center model.
Teams that want private, always-available assistance tailored to their own tools and terminology now have a concrete set of starting points rather than only the choice between a weak local model and a distant large one.
Taken together, the release illustrates a continuing trade-off rather than a wholesale replacement of larger systems.
On specialized agent workflows, targeted tool use, and specific multimodal tasks, sub-2B models can match or exceed systems several times their size in Liquid’s reported numbers, all while remaining small enough for local deployment and single-GPU fine-tuning.
However, these efficiency gains come with noticeable limitations that teams must account for.
First, sub-2B parameter models face clear capacity bottlenecks when it comes to complex, multi-step logical reasoning, deep synthesis, and unexpected edge cases compared to frontier cloud models. Second, compressing these models into a ~1GB footprint using aggressive 4-bit quantization creates trade-offs: while it makes them light enough to run on edge hardware like mobile NPUs or Raspberry Pis, quantization can introduce numerical instability or subtle drops in performance across sensitive audio and vision tasks. Third, heavy domain-specific fine-tuning on small datasets carries a risk of "catastrophic forgetting," where a model adapted for a niche enterprise task might lose some of its broader tool-selection or language capabilities.
Finally, running everything locally transfers the burden of hosting, securing, and orchestrating the underlying tools and APIs directly to the user's device or private network.
Independent replication of the full suite also remains limited at the time of the announcement, so reported performance figures reflect the company’s internal evaluation protocols.
For teams that need low-latency, private agents on hardware they control, LFM3 offers a practical and efficient starting point, provided its trade-offs in broad knowledge and complex reasoning are carefully managed.
