When Liquid AI, a startup founded by MIT computer scientists back in 2023, introduced its Liquid Foundation Models series 2 (LFM2) in July 2025, the pitch was straightforward: deliver the fastest on-device foundation models available on the market using the brand new "liquid" architecture, with training and inference efficiency that made small models a serious alternative to cloud-only large language models (LLMs) resembling OpenAI's GPT series and Google's Gemini.
The initial release shipped dense checkpoints at 350M, 700M, and 1.2B parameters, a hybrid architecture heavily weighted toward gated short convolutions, and benchmark numbers that placed LFM2 ahead of similarly sized competitors like Qwen3, Llama 3.2, and Gemma 3 on each quality and CPU throughput. The message to enterprises was clear: real-time, privacy-preserving AI on phones, laptops, and vehicles not required sacrificing capability for latency.
Within the months since that launch, Liquid has expanded LFM2 right into a broader product line — adding task-and-domain-specialized variants, a small video ingestion and evaluation model, and an edge-focused deployment stack called LEAP — and positioned the models because the control layer for on-device and on-prem agentic systems.
Now, with the publication of the detailed, 51-page LFM2 technical report on arXiv, the corporate goes a step further: making public the architecture search process, training data mixture, distillation objective, curriculum strategy, and post-training pipeline behind those models.
And in contrast to earlier open models, LFM2 is built around a repeatable recipe: a hardware-in-the-loop search process, a training curriculum that compensates for smaller parameter budgets, and a post-training pipeline tuned for instruction following and power use.
Somewhat than simply offering weights and an API, Liquid is effectively publishing an in depth blueprint that other organizations can use as a reference for training their very own small, efficient models from scratch, tuned to their very own hardware and deployment constraints.
A model family designed around real constraints, not GPU labs
The technical report begins with a premise enterprises are intimately aware of: real AI systems hit limits long before benchmarks do. Latency budgets, peak memory ceilings, and thermal throttling define what can actually run in production—especially on laptops, tablets, commodity servers, and mobile devices.
To handle this, Liquid AI performed architecture search directly on track hardware, including Snapdragon mobile SoCs and Ryzen laptop CPUs. The result’s a consistent final result across sizes: a minimal hybrid architecture dominated by gated short convolution blocks and a small variety of grouped-query attention (GQA) layers. This design was repeatedly chosen over more exotic linear-attention and SSM hybrids since it delivered a greater quality-latency-memory Pareto profile under real device conditions.
This matters for enterprise teams in 3 ways:
-
Predictability. The architecture is easy, parameter-efficient, and stable across model sizes from 350M to 2.6B.
-
Operational portability. Dense and MoE variants share the identical structural backbone, simplifying deployment across mixed hardware fleets.
-
On-device feasibility. Prefill and decode throughput on CPUs surpass comparable open models by roughly 2× in lots of cases, reducing the necessity to offload routine tasks to cloud inference endpoints.
As a substitute of optimizing for educational novelty, the report reads as a scientific try to design models enterprises can actually ship.
That is notable and more practical for enterprises in a field where many open models quietly assume access to multi-H100 clusters during inference.
A training pipeline tuned for enterprise-relevant behavior
LFM2 adopts a training approach that compensates for the smaller scale of its models with structure somewhat than brute force. Key elements include:
-
10–12T token pre-training and an extra 32K-context mid-training phase, which extends the model’s useful context window without exploding compute costs.
-
A decoupled Top-K knowledge distillation objective that sidesteps the instability of ordinary KL distillation when teachers provide only partial logits.
-
A three-stage post-training sequence—SFT, length-normalized preference alignment, and model merging—designed to provide more reliable instruction following and tool-use behavior.
For enterprise AI developers, the importance is that LFM2 models behave less like “tiny LLMs” and more like practical agents in a position to follow structured formats, adhere to JSON schemas, and manage multi-turn chat flows. Many open models at similar sizes fail not because of lack of reasoning ability, but because of brittle adherence to instruction templates. The LFM2 post-training recipe directly targets these rough edges.
In other words: Liquid AI optimized small models for operational reliability, not only scoreboards.
Multimodality designed for device constraints, not lab demos
The LFM2-VL and LFM2-Audio variants reflect one other shift: multimodality built around token efficiency.
Somewhat than embedding an enormous vision transformer directly into an LLM, LFM2-VL attaches a SigLIP2 encoder through a connector that aggressively reduces visual token count via PixelUnshuffle. High-resolution inputs routinely trigger dynamic tiling, keeping token budgets controllable even on mobile hardware. LFM2-Audio uses a bifurcated audio path—one for embeddings, one for generation—supporting real-time transcription or speech-to-speech on modest CPUs.
For enterprise platform architects, this design points toward a practical future where:
-
document understanding happens directly on endpoints resembling field devices;
-
audio transcription and speech agents run locally for privacy compliance;
-
multimodal agents operate inside fixed latency envelopes without streaming data off-device.
The through-line is similar: multimodal capability without requiring a GPU farm.
Retrieval models built for agent systems, not legacy search
LFM2-ColBERT extends late-interaction retrieval right into a footprint sufficiently small for enterprise deployments that need multilingual RAG without the overhead of specialised vector DB accelerators.
This is especially meaningful as organizations begin to orchestrate fleets of agents. Fast local retrieval—running on the identical hardware because the reasoning model—reduces latency and provides a governance win: documents never leave the device boundary.
Taken together, the VL, Audio, and ColBERT variants show LFM2 as a modular system, not a single model drop.
The emerging blueprint for hybrid enterprise AI architectures
Across all variants, the LFM2 report implicitly sketches what tomorrow’s enterprise AI stack will appear to be: hybrid local-cloud orchestration, where small, fast models operating on devices handle time-critical perception, formatting, tool invocation, and judgment tasks, while larger models within the cloud offer heavyweight reasoning when needed.
Several trends converge here:
-
Cost control. Running routine inference locally avoids unpredictable cloud billing.
-
Latency determinism. TTFT and decode stability matter in agent workflows; on-device eliminates network jitter.
-
Governance and compliance. Local execution simplifies PII handling, data residency, and auditability.
-
Resilience. Agentic systems degrade gracefully if the cloud path becomes unavailable.
Enterprises adopting these architectures will likely treat small on-device models because the “control plane” of agentic workflows, with large cloud models serving as on-demand accelerators.
LFM2 is one in all the clearest open-source foundations for that control layer to this point.
The strategic takeaway: on-device AI is now a design selection, not a compromise
For years, organizations constructing AI features have accepted that “real AI” requires cloud inference. LFM2 challenges that assumption. The models perform competitively across reasoning, instruction following, multilingual tasks, and RAG—while concurrently achieving substantial latency gains over other open small-model families.
For CIOs and CTOs finalizing 2026 roadmaps, the implication is direct: small, open, on-device models at the moment are strong enough to hold meaningful slices of production workloads.
LFM2 is not going to replace frontier cloud models for frontier-scale reasoning. Nevertheless it offers something enterprises arguably need more: a reproducible, open, and operationally feasible foundation for agentic systems that must run anywhere, from phones to industrial endpoints to air-gapped secure facilities.
Within the broadening landscape of enterprise AI, LFM2 is less a research milestone and more an indication of architectural convergence. The long run isn’t cloud or edge—it’s each, operating in concert. And releases like LFM2 provide the constructing blocks for organizations prepared to construct that hybrid future intentionally somewhat than unintentionally.
