What Is Liquid AI? LFMs Explained

Who is Liquid AI, and where did it come from?

Liquid AI was founded in 2023 as a spinoff from MIT's Computer Science and Artificial Intelligence Laboratory (CSAIL). It came out of stealth in December 2023, when TechCrunch reported on the new company and its unusual goal: to build a genuinely different kind of AI model rather than another variation on the designs everyone else was using. The four founders are Ramin Hasani (CEO), Mathias Lechner (CTO), Alexander Amini (Chief Scientific Officer) and Daniela Rus, the long-time director of CSAIL. The same four names appear on the academic papers that gave the company its foundational technology, so Liquid AI is best understood as a research group that turned its work into a product company.

The name "Liquid" is not marketing garnish. It points to a specific line of research the founders published while at MIT — liquid neural networks, and more precisely liquid time-constant networks. Understanding that idea, at least in outline, is the key to understanding why the company thinks its models can be smaller and more efficient than the mainstream alternative.

From MIT: what are liquid neural networks?

To see what is different about a liquid neural network, it helps to remember what an ordinary neural network does. In a standard network, training adjusts a large set of numbers — the weights — and once training is finished, those weights are frozen. When you run the model, the same fixed arithmetic runs every time. The network has learned a function and it applies it.

Liquid neural networks start from a different mathematical picture. Instead of a stack of fixed layers, they describe a neuron's behaviour with a small differential equation — a rule about how the neuron's state changes over time rather than a single fixed output. Crucially, the "time constant" that governs how quickly each neuron reacts is not fixed; it is modulated by the input the network is currently seeing. In plain terms, the network's internal dynamics stay flexible — "liquid" — and can compress or stretch how they respond depending on what is happening in the data. The output is computed by numerically solving those equations as the input flows through.

The inspiration is famously biological. The founders' early work drew on the nervous system of C. elegans, a tiny roundworm with only around 300 neurons that nonetheless produces complex, adaptable behaviour. The lesson the researchers took was that rich behaviour can come from neurons whose connections behave dynamically, not just from piling on ever more of them. That is why liquid networks have historically been associated with being compact and interpretable: early demonstrations controlled tasks like steering a car or flying a drone using strikingly few neurons, and the researchers argued the resulting models were easier to inspect than a giant black-box network.

What are Liquid Foundation Models (LFMs)?

A foundation model is a large, general-purpose model trained on broad data that can then be adapted to many tasks — the category that includes the familiar chat models. Liquid's version of that idea is the Liquid Foundation Model, or LFM. The company introduced its first generation in autumn 2024, in a post titled Liquid Foundation Models: Our First Series of Generative AI Models, with three models:

• LFM-1B — a dense model of about 1.3 billion parameters, aimed at resource-constrained settings.
• LFM-3B — about 3.1 billion parameters, positioned for edge and mobile deployment. Liquid claimed it competed with, and on some public benchmarks beat, considerably larger models.
• LFM-40B — a roughly 40-billion-parameter Mixture of Experts (MoE) model that only activates about 12 billion parameters at a time, so it aims for the quality of a big model at the running cost of a smaller one.

The headline claim in that first launch was about memory. In Liquid's own explanation, a transformer LLM keeps a "KV cache" — a running store of the keys and values for every token in the conversation — and that cache grows linearly with the length of the input. Feed a transformer a very long document and its memory appetite climbs accordingly. Liquid said its models were designed to keep inference time and memory much flatter as the input grows, which the company framed as making long-context work more practical on small devices. It reported an effective 32,000-token context length for LFM-3B, measured on the RULER benchmark, and described that as enabling long-context tasks on edge devices.

To its credit, Liquid was openly honest about weaknesses in that first release. Its own announcement listed things the early LFMs were not good at: zero-shot code generation, precise numerical calculations, handling time-sensitive facts, and even the notorious party trick of counting the letters in "strawberry." That kind of plain-spoken limitation list is a good sign in a field prone to overclaiming, and it is worth keeping in mind when you read any single benchmark number.

LFM2 and the move to on-device

The story got more concrete in 2025 with LFM2, which Liquid described as its second generation and pitched explicitly as "the fastest on-device foundation models on the market." This is the generation most relevant to a Windows or PC audience, because it is designed from the start for local hardware.

Two things changed with LFM2. First, the architecture became an openly described hybrid. Rather than being pure attention like a transformer, an LFM2 model is built mostly from short convolution blocks with a smaller number of attention blocks mixed in. Liquid's technical write-up describes a design of 16 blocks — ten short-range gated convolution blocks and six grouped-query-attention blocks — as the recipe that gave the best balance of speed and quality on device. Liquid's own Introducing LFM2 post states the design as "16 blocks: 10 double-gated short-range convolution blocks and 6 blocks of grouped query attention". The point of leaning on convolutions is that they are cheap and fast to run, especially on a CPU, while a limited amount of attention preserves the model's ability to relate distant parts of the text.

Second, LFM2 came as a family of genuinely small, open-weight models — checkpoints around 350 million, 700 million and 1.2 billion parameters, with a 32,000-token context. Liquid published benchmark comparisons claiming, among other things, roughly twice the decode and prefill speed of a comparable Qwen3 model on CPU, and a large improvement in training efficiency over its own first generation. As always, treat vendor benchmarks as claims to be checked rather than settled facts — but the direction is clear: small, fast, and built to run without a data centre.

Through late 2025 and into 2026 the line kept expanding into an LFM2.5 series. Liquid released a very small LFM2.5-230M aimed at phones, robots and automation devices; an LFM2.5-2.6B on-device model with a 128K-token context, tool calling and open weights; and a Mixture-of-Experts model, the LFM2.5-8B-A1B, that has around 8 billion total parameters but only activates roughly 1.5 billion at a time, again to get more capability without paying the full cost on every token. The LFM2.5-2.6B release, in particular, was framed around agentic use — tool use, data extraction, retrieval-augmented generation and long-context workflows — which is where a small local model can genuinely earn its keep.

How LFMs differ from transformer LLMs

Almost every well-known chatbot — the big cloud assistants included — is built on the transformer architecture, whose defining feature is self-attention: every token can "look at" every other token to decide what matters. Attention is powerful and is a big reason transformers scaled so well. But it has a cost that grows with length. The more context you give a transformer, the more work attention does and the more the key-value cache has to hold, so memory and compute rise as conversations and documents get longer.

Liquid's models attack that cost from two angles. The research heritage is the continuous-time, liquid-network idea of a compact dynamical system. The practical, shipping form in LFM2 is the hybrid of cheap convolution blocks plus a modest amount of attention. Either way, the goal is the same: keep the memory and latency curve flatter as input grows, so the model stays responsive on a device with limited RAM and no dedicated data-centre GPU. Where a transformer's appetite scales up with the conversation, Liquid designs for something closer to steady, predictable resource use.

It is worth being precise about what this does and does not mean. It does not mean transformers are obsolete — the largest, most capable models in the world are still transformer-based, and a 1-to-3-billion parameter model of any architecture is simply not going to match a frontier cloud model on the hardest tasks. What it means is that for the on-device problem — "give me the most useful model I can realistically run on a laptop or phone" — a more efficient architecture is a real advantage. That is the niche Liquid is building for, and it is a different competition from the one the giant cloud models are fighting.

Why this matters for local AI on your PC

If you have read our guide to running local AI LLMs on Windows, the appeal here will be familiar. Running a model on your own machine, instead of sending everything to a cloud API, buys you several things at once:

• Privacy. Your prompts, documents and data never have to leave the PC. For anything confidential, that is a categorical difference, not a marginal one.
• Offline capability. A local model keeps working on a plane, in a dead-zone, or on an air-gapped machine.
• No metered cost. There is no per-request bill; once the model is on disk, running it is "free" in the sense that you are only paying for your own electricity and hardware.
• Low latency. No round-trip to a server means the first words can appear almost instantly, which matters a lot for things like autocomplete or quick rewrites.

The catch has always been that capable models were too big and too slow to run comfortably on ordinary hardware. This is exactly the gap efficient architectures aim to close, and it is the same gap Windows is addressing from the hardware side. A modern Copilot+ PC ships with a neural processing unit (NPU) — a chip built to run AI math efficiently and at low power. Pair an efficient model with efficient silicon and the on-device option starts to look genuinely practical for real work, not just demos. Liquid's models are one example of the model side of that equation; the NPU is the hardware side. For a wider tour of what Windows already ships, see our guide to Windows 11 AI features explained, and our Windows AI hub for the bigger picture.

The company, funding and platform (LEAP and Apollo)

Liquid AI is not a hobby project. After an initial seed round when it launched in 2023, the company raised a $250 million round in December 2024 that was led by AMD, reportedly valuing Liquid at roughly $2 billion. That AMD connection is telling: AMD makes CPUs, GPUs and the kind of accelerators that on-device and edge AI run on, so a chipmaker backing an efficiency-focused model company is a natural strategic fit rather than a surprise. The stated aim of the funding was to scale up Liquid's development of efficient, general-purpose models.

On the product side, in July 2025 Liquid launched two things that turn its models into something you can actually build with:

• LEAP — the Liquid Edge AI Platform, a developer platform for building and deploying small models on devices such as phones, laptops and wearables. Its pitch is that you can add an on-device model to an app with only a few lines of code, without wiring up cloud infrastructure.
• Apollo — a lightweight iOS app, built on LEAP, for trying Liquid's small models privately on a phone. Liquid acquired the original Apollo app (created by developer Aaron Ng) and evolved it into a way to test and "vibe-check" its models on-device. Apollo is iOS-only, so it is not a Windows tool itself — but it is a clear demonstration of the on-device, private-by-default direction.

How to try Liquid's models today

The most useful fact for a PC user is that Liquid publishes open-weight models. That means you can download them and run them locally in the same tools people already use for other open models. Based on Liquid's own release notes, the practical routes are:

1. Hugging Face. Liquid hosts its LFM2 and LFM2.5 models on Hugging Face, with weights shipped in common formats including GGUF, MLX and ONNX. Note that these are released under Liquid's own licence, so check the terms for your use case — "open weights" is not automatically the same as a fully permissive open-source licence.
2. Local runtimes. Liquid says its recent models get day-one support in popular local inference tools such as llama.cpp, vLLM, SGLang and LM Studio. If you already run local models on Windows, LM Studio plus a GGUF build is the most approachable on-ramp — download the model in the app and chat with it entirely offline. Our local LLM guide walks through that kind of setup in general.
3. LEAP. If you are a developer wanting to embed a small model in your own app, LEAP is Liquid's official SDK for exactly that.
4. Apollo (iOS). If you happen to have an iPhone, Apollo is the fastest way to feel what a Liquid model is like running privately on a device — though, again, it is not a Windows application.

Limitations and open questions

A neutral look at Liquid AI has to hold two things at once. The idea is genuinely interesting and the on-device focus is timely. At the same time, several honest caveats apply:

• Benchmarks are the company's own. Most of the speed and quality numbers come from Liquid's blog posts and technical reports. They may well hold up — but independent, third-party evaluation is what turns a vendor claim into an established fact, and that always lags a fresh release.
• Small models have hard ceilings. Liquid itself has listed weaknesses like precise calculation and code generation in earlier models. Newer versions improve, but no 1–3B model competes with a frontier assistant on the hardest reasoning.
• "Liquid" is a spectrum, not a single thing. The shipping LFM2 architecture is a convolution-plus-attention hybrid, which is a meaningful design but is not the same as the pure continuous-time networks from the original academic papers. It is fair to say the products are informed by the liquid-network research rather than being a literal implementation of it.
• Licensing needs reading. Open weights are great for local use, but the specific licence determines what you may do commercially. Check it before you build a product on top.
• The field moves fast. Efficient small models are a crowded, fast-moving area — Qwen, Phi, Gemma, Llama and others all compete for the same on-device slot. Liquid's edge is architectural efficiency, but the leaderboard shifts month to month.

What's next for Liquid AI and local AI

The broad trend Liquid is riding is bigger than any one company: AI is steadily moving onto the device. The reasons are practical rather than ideological — privacy, cost, latency and offline use all push work toward the edge whenever the model is good enough to do the job there. Efficient architectures and dedicated NPUs are the two forces making "good enough on-device" a moving target that keeps getting easier to hit.

For Windows users specifically, the interesting near-future question is how much of your everyday AI ends up running locally versus in the cloud. Today it is a mix. As small models get better and NPUs get faster, more of the routine work — the summarising, drafting, extracting and tool-calling — can plausibly happen on your own machine, quietly and privately, with the cloud reserved for the heaviest lifting. Liquid AI is one of the companies betting hard on that shift, and its models are a concrete, downloadable way to see where the on-device frontier actually is right now. Whether or not Liquid specifically becomes a household name, the direction it is pushing — capable AI that fits on the hardware you already own — is the one most likely to touch how you use your PC.