LFM2.5-24B-A2B: Liquid AI Hits 184 Tokens/Sec [2026]

Liquid AI shipped a new open-weight model on October 13, 2026, and the numbers behind it explain why hardware watchers spent the following two days arguing about laptop chips instead of data center GPUs. The model, called LFM2.5-24B-A2B, packs 24 billion total parameters but activates only 2 billion of them per token, a design choice that let it generate 184 tokens per second on an Apple M5 Max laptop chip, according to Liquid AI’s own release notes. That is a number normally associated with cloud inference, not a machine someone carries in a backpack.

The release landed quietly compared to the splashier large-model announcements of 2026, but it matters for a specific reason: it is built to run AI agents directly on-device, without a round trip to a data center. TechRepublic covered the launch as a local AI story aimed at developers who want to “download, customize and deploy the model” themselves, a framing that fits a broader shift toward keeping inference, and the data that feeds it, off someone else’s servers.

Google · Preferred Sources

Don't miss new tech stories on Google

Add TrendinTech once in the Google app and our stories appear in your news suggestions.

Add Now

What Liquid AI Announced on October 13

Liquid AI, the startup behind the Liquid Foundation Models (LFM) line, released two versions of the new model on the same day: a base checkpoint called LFM2.5-24B-A2B-Base and a post-trained, instruction-tuned version named LFM2.5-24B-A2B. Both are open-weight and available for download on Hugging Face as well as through Liquid AI’s own Playground, meaning developers do not need an enterprise contract or a waitlist invitation to try them.

The model is a Mixture-of-Experts (MoE) reasoning model, a type of architecture that splits a network into many smaller sub-networks, or “experts,” and routes each token to only a handful of them instead of running the whole model every time. Liquid AI’s documentation describes LFM2.5-24B-A2B as the company’s largest MoE model to date, built specifically for what the firm calls fast, private agents on-device. The pitch is straightforward: an AI agent that plans multi-step tasks, calls tools, and reasons through a problem, running on hardware the user already owns rather than a shared cloud instance billed by the token.

That positioning sits squarely inside a bigger industry argument this year, one covered in detail when Beam and Mistral shipped new open-weight models betting that openness, not scale alone, wins developer mindshare. Liquid AI is making a narrower bet: that the next competitive edge in AI is not just model quality but how few watts and how little memory it takes to get that quality onto a phone, a laptop, or a small edge server.

Inside the Architecture: 40 Layers, 64 Experts, Top-4 Routing

The technical specifics explain how Liquid AI squeezed cloud-class throughput onto consumer silicon. LFM2.5-24B-A2B uses 40 total layers, split between 30 gated short-convolution layers and 10 grouped-query attention (GQA) layers, according to Liquid AI’s model documentation. That hybrid mix, convolution-heavy with attention layers interspersed, is a known technique for cutting the compute and memory cost of long-context inference compared to a pure transformer stack.

The MoE layer itself carries 64 experts per block, with a top-4 routing scheme, meaning each token gets evaluated by only four of those 64 experts before the network produces an output. That routing is why the model’s 24 billion total parameters translate into just 2 billion “active” parameters per token, a ratio of roughly 12 to 1. The practical effect: the model stores the knowledge capacity of a 24-billion-parameter network but spends compute closer to what a 2-billion-parameter dense model would require per generated token.

Liquid AI also gave the model a 131,000-token context window and a 128,000-entry vocabulary, both sized for the kind of long, tool-heavy agent sessions where a model needs to hold an entire codebase, document set, or multi-turn conversation history in memory at once. For context, a 131K window is large enough to hold a mid-sized technical manual or several hours of chat history without truncation, which matters for agents that are expected to track long-running tasks rather than answer one-off questions.

The Benchmark Numbers: 184 Tokens Per Second on a Laptop Chip

The headline figure driving coverage from AlphaSignal and others is the Apple M5 Max result: 184 tokens per second. That number comes directly from Liquid AI’s own benchmarking, run on Apple’s current top-tier laptop silicon. On AMD’s Ryzen AI Max+ 395, a chip aimed at the same premium on-device AI segment, Liquid AI reported 114 tokens per second, a gap that puts Apple’s silicon roughly 60 percent ahead of AMD’s flagship on this specific workload.

On data center hardware, Liquid AI reported throughput of up to 21,000 output tokens per second on a single NVIDIA B300 GPU. That figure needs a caveat the company itself provided: the 21K number is aggregate throughput at high concurrency, meaning many requests being served in parallel, not the generation speed a single user would see on a single response. Liquid AI stated the result directly in a public post: “On an @nvidia B300, we get over 21k output tokens/s at high concurrency.” It is an important distinction, because aggregate throughput and single-stream latency answer different questions, one about serving cost at scale and the other about how snappy an individual agent feels to the person using it.

Not every attempt to run the model went as smoothly as the headline numbers suggest. A developer writing on note.com reported that LFM2.5-24B-A2B did not fit in the GPU memory of a 16GB Apple M4 machine, and that running it on CPU instead produced only about 3.6 tokens per second, a steep falloff from the 184 tokens per second Liquid AI recorded on the much higher-end M5 Max. That gap is a useful reminder that on-device benchmarks are tied tightly to the specific chip and memory configuration being tested, and that a 24-billion-parameter model, even with only 2 billion active parameters, still needs enough memory to hold the full weight set.

Hardware	Throughput	Notes
Apple M5 Max (laptop)	184 tokens/sec	Liquid AI’s headline on-device figure
AMD Ryzen AI Max+ 395	114 tokens/sec	Liquid AI’s reported figure for AMD’s flagship on-device chip
NVIDIA B300 (single GPU)	Up to 21,000 tokens/sec	Aggregate throughput at high concurrency, not single-response speed
Apple M4, 16GB (third-party test)	3.6 tokens/sec (CPU only)	Model did not fit in GPU memory; reported by a developer on note.com

Pricing: $0.10 Per Million Input Tokens

For teams that would rather call LFM2.5-24B-A2B through an API instead of running it locally, Liquid AI priced access at $0.10 per 1 million input tokens, $0.05 per 1 million cached input tokens, and $1.00 per 1 million output tokens. Cached input pricing at half the standard input rate rewards applications that repeatedly send similar context, such as an agent that keeps re-reading the same codebase or document set across many turns, a pattern increasingly common in agentic workflows rather than single-shot chat.

That pricing sits at the aggressive end of the current market, especially for a 24-billion-parameter-class model. It lands in the same general territory as the steep cuts other providers made this year to stay competitive on cost per token, a trend that has turned API pricing itself into a battleground as much as raw benchmark scores. The open-weight option removes the API cost question entirely for teams with the hardware to self-host, which is precisely the audience Liquid AI is targeting with the on-device throughput numbers.

Open Weights, No Waitlist

Both LFM2.5-24B-A2B and its base checkpoint are open-weight, meaning the trained parameters themselves, not just an API endpoint, are downloadable. TechRepublic described the release as letting developers “download, customize and deploy the model” on their own infrastructure, a model of distribution that differs from the closed, API-only approach taken by several larger frontier labs. AlphaSignal’s coverage noted day-one support across a wide set of inference runtimes, including llama.cpp, MLX, vLLM, SGLang, and ONNX, which matters practically because it means the model works with tools developers already have installed rather than requiring a brand-new serving stack.

That breadth of runtime support is a deliberate strategy choice. A model that only runs well on one inference engine limits itself to whichever community already uses that engine. By shipping compatibility with MLX (Apple’s framework), llama.cpp (the dominant lightweight C++ runtime), and vLLM and SGLang (both popular for GPU-serving at scale), Liquid AI positioned the release to be tested immediately across laptops, workstations, and data center GPUs without developers waiting on third-party conversion work.

From LFM2-24B-A2B to LFM2.5: What Changed

LFM2.5-24B-A2B is not Liquid AI’s first attempt at this parameter count. The company released an earlier checkpoint, LFM2-24B-A2B, carrying the same 24-billion-total, 2-billion-active parameter structure, as what it called at the time its largest LFM2 model, meant to demonstrate that the underlying LFM2 architecture scales effectively to larger sizes. Liquid AI’s own documentation now marks that earlier model as deprecated, instructing developers to use LFM2.5-24B-A2B instead for improved performance.

That history matters for anyone deciding whether to bet infrastructure on this specific model line. A model generation that gets deprecated within roughly eight months of release, replaced by a point-five successor with the same parameter footprint but better throughput, suggests Liquid AI is iterating on efficiency within a fixed architecture family rather than chasing larger parameter counts. For a company explicitly targeting on-device deployment, that is the correct axis to optimize: squeezing more tokens per second and better reasoning out of the same memory footprint, since consumer hardware memory budgets do not move nearly as fast as cloud GPU memory does.

Why On-Device Agents Are the Target, Not Chatbots

Liquid AI’s framing throughout the release emphasizes agents, not conversational chat. An agent, in the current industry sense, is a model wired up to call tools, browse files, execute code, or chain multiple steps together to complete a task without a human approving every intermediate step. That workload profile is different from chat: it tends to involve longer context (hence the 131K window), repeated similar inputs (hence the discounted cached-token pricing), and a premium on responsiveness, since a slow agent that takes minutes to plan a five-step task is far less useful than a fast one, even if the slow one is marginally more accurate.

Running that agent loop entirely on-device solves two problems at once: latency, because there is no network round trip to a remote API for every tool call, and privacy, because the data the agent reads, a user’s files, emails, or codebase, never leaves the machine. That privacy angle lines up with concerns raised elsewhere this year about where sensitive data ends up when routed through third-party AI infrastructure, a worry that has shaped how enterprises evaluate which AI models they route different kinds of work to depending on sensitivity and cost. Coverage from WISE AI framed the release in similar terms, describing it as a 2-billion-active-parameter MoE built specifically for local agents rather than general-purpose chat.

Competitive Field: Where LFM2.5-24B-A2B Fits

The on-device AI model space has gotten crowded through 2026, with multiple approaches competing for the same laptops and edge devices. Smaller dense models from major labs chase efficiency through parameter count alone, running every parameter on every token. Liquid AI’s MoE approach instead keeps a large total parameter budget, which theoretically gives the model more capacity to store knowledge and reasoning patterns, while activating only a slice of it per token to keep latency and memory bandwidth demands down.

That architectural choice also puts LFM2.5-24B-A2B in a different lane from the hardware-first approach other companies are taking, where the bet is on faster chips rather than leaner models. Nvidia, AMD, and Apple have all pushed on-device AI performance through silicon improvements, the kind of gains benchmarked when Qualcomm’s Snapdragon X2 went up against Intel’s latest Core Ultra chips earlier this year. Liquid AI’s approach is complementary rather than competing: better architecture efficiency on top of better silicon compounds, rather than substituting for it, which is part of why the same model shows such a wide performance range between a 16GB M4 and a far more capable M5 Max.

On the GPU side, the same efficiency logic plays out at data center scale. The 21,000 tokens-per-second figure on a single NVIDIA B300 shows how MoE sparsity pays off even on hardware built for the opposite problem, maximum throughput at any power draw, a theme that also shaped recent coverage of how much raw GPU horsepower actually translates into usable AI throughput once software efficiency enters the picture. A model that needs fewer active parameters per token leaves more of a GPU’s memory bandwidth free to serve additional concurrent users, which is exactly what high-concurrency aggregate throughput measures.

Market Impact: Open Weights as a Strategy, Not a Giveaway

Releasing a model’s weights for free download looks, on paper, like giving away the product. In practice, open-weight releases have become a deliberate go-to-market move for smaller AI labs competing against giants with far larger training budgets. By letting any developer download, inspect, and fine-tune LFM2.5-24B-A2B, Liquid AI trades direct API revenue for developer adoption and ecosystem lock-in around its architecture, a strategy that mirrors moves made by other infrastructure players this year, including Nvidia’s own decision to open source several of its GPU orchestration tools rather than keep them proprietary.

For hardware makers, the release adds a concrete workload to point to when marketing on-device AI capability. Apple’s M5 Max benchmark result gives Apple a specific, third-party-verified number to cite for its chip’s AI credentials, the kind of proof point that matters as companies decide whether on-device inference capacity should factor into how idle Mac hardware gets put to work for AI tasks rather than sitting unused. A model that runs well locally only matters commercially if there is a reason to keep inference local instead of defaulting to the cloud, and agent workloads, with their privacy and latency sensitivities, supply exactly that reason.

Historical Context: The Shrinking Active-Parameter Trend

The industry has spent the better part of two years chasing a specific efficiency curve: how much total model capacity can be packed behind a small active-parameter footprint. Mixture-of-Experts architectures were a niche research topic a few years ago and are now the default design for any model maker chasing both scale and deployability at once. Liquid AI’s own model line illustrates the trajectory directly: the company’s first LFM2-24B-A2B checkpoint proved the architecture could scale to 24 billion total parameters at all, and roughly eight months later LFM2.5-24B-A2B arrived as the refined, faster, production-ready version of the same idea.

That pace, proof-of-concept to production refinement within under a year, reflects how compressed model development cycles have become across the industry generally in 2026. Model makers are no longer just racing to the next parameter-count milestone, as was common in the early large language model era. They are racing to shrink the effective compute cost per unit of capability, since enterprise buyers now weigh total cost and latency as heavily as raw benchmark scores when choosing which model to deploy.

Specification	LFM2.5-24B-A2B
Release date	October 13, 2026
Model type	Mixture-of-Experts (MoE) reasoning model
Total parameters	24 billion
Active parameters per token	2 billion
Context length	131,000 tokens
Vocabulary size	128,000
Layers	40 total (30 gated short-convolution, 10 GQA)
MoE routing	64 experts per block, top-4 routing
API input price	$0.10 per 1M tokens
API cached input price	$0.05 per 1M tokens
API output price	$1.00 per 1M tokens
License	Open-weight (Hugging Face and Liquid AI Playground)

What Developers Are Reporting So Far

Early hands-on reports from the first two days after release are mixed in a way that is typical for any model this new. AlphaSignal’s coverage focused on the positive throughput story, framing the 184 tokens-per-second laptop result as evidence that a 24-billion-parameter-class model can now run comfortably on consumer hardware. The note.com account from a developer running the model on a 16GB M4, by contrast, hit a memory ceiling the model simply could not fit under, forcing a fallback to CPU execution at a small fraction of the advertised speed.

Both reports are consistent with each other once the hardware difference is accounted for. The M5 Max is Apple’s highest-memory-bandwidth consumer chip; a base-tier 16GB M4 simply does not have the unified memory headroom to hold a 24-billion-parameter model’s full weight set alongside an active context window and the rest of the operating system’s memory needs. That gap is likely to shape how the model gets adopted: as a tool for people with higher-end hardware or for cloud and workstation deployment, rather than a drop-in option for every laptop on the market.

Predictions: Where This Goes From Here

A few trends look likely to follow from this release over the next several months. First, expect other model makers to publish their own MoE models at similar or smaller active-parameter counts specifically benchmarked against Apple’s M-series chips, since Liquid AI’s 184 tokens-per-second figure has effectively set a public reference point competitors will feel pressure to match or beat.

Second, hardware memory capacity, not raw compute speed, is likely to become the more visible bottleneck story. The gap between the M5 Max result and the 16GB M4 struggle shown by the note.com test suggests memory headroom, not processor speed alone, will decide which consumer devices can run next-generation on-device models at all, putting pressure on chipmakers to grow unified memory configurations faster than they have in past hardware cycles.

Third, expect API pricing for mid-size open-weight models to keep compressing. Liquid AI’s $0.10 per million input tokens and $1.00 per million output tokens sits aggressively low for a 24-billion-parameter model, and rivals chasing the same developer base are likely to match or undercut it rather than cede that price tier.

Fourth, runtime compatibility will keep expanding as a competitive requirement rather than a nice-to-have. Day-one support across llama.cpp, MLX, vLLM, SGLang, and ONNX set a bar other model releases will likely need to clear just to be taken seriously by developers who already have inference infrastructure built around those tools.

Fifth, enterprise interest in on-device agent deployment is likely to grow specifically among regulated industries, finance, healthcare, and legal, where keeping sensitive data off third-party servers is a compliance requirement rather than a preference. A model that can run an agent entirely locally removes an entire category of data-residency questions that API-based deployment cannot avoid.

The Bigger Picture for Edge AI Hardware

LFM2.5-24B-A2B is a software release, but its real impact runs through hardware. Every tokens-per-second figure in Liquid AI’s announcement doubles as free marketing for the chip it was measured on, and every memory-ceiling failure doubles as a reminder of which configurations are not yet good enough. That dynamic is likely to keep intensifying as more labs ship models specifically designed, as this one was, to make the gap between cloud inference and on-device inference as small as possible.

For now, the practical takeaway for developers is straightforward: LFM2.5-24B-A2B is a real, downloadable, and benchmarked option for teams that want agent-capable reasoning running locally, provided the hardware underneath has enough memory to hold it. The open-weight release and broad runtime support mean the barrier to trying it is low. Whether it becomes a default choice for on-device agents depends less on the model itself at this point and more on how quickly consumer hardware memory budgets catch up to what MoE architectures like this one are capable of using.

Frequently Asked Questions

What is LFM2.5-24B-A2B?

LFM2.5-24B-A2B is an open-weight Mixture-of-Experts reasoning model released by Liquid AI on October 13, 2026. It has 24 billion total parameters but activates only 2 billion per token, and it is designed to run AI agents directly on-device rather than through a cloud API.

How fast is LFM2.5-24B-A2B on a laptop?

Liquid AI reported 184 tokens per second on an Apple M5 Max and 114 tokens per second on an AMD Ryzen AI Max+ 395, according to the company’s own benchmarking published with the release.

Can LFM2.5-24B-A2B run on a 16GB machine?

One developer reported on note.com that the model did not fit in GPU memory on a 16GB Apple M4, forcing a fallback to CPU inference at roughly 3.6 tokens per second. Running the model comfortably appears to require a machine with significantly more unified memory than 16GB.

How much does the LFM2.5-24B-A2B API cost?

Liquid AI priced API access at $0.10 per 1 million input tokens, $0.05 per 1 million cached input tokens, and $1.00 per 1 million output tokens.

Is LFM2.5-24B-A2B open source?

Both the base checkpoint, LFM2.5-24B-A2B-Base, and the post-trained LFM2.5-24B-A2B model are open-weight and downloadable from Hugging Face, as well as accessible through Liquid AI’s Playground.

What is a Mixture-of-Experts model?

A Mixture-of-Experts model splits its network into many smaller sub-networks, called experts, and routes each token to only a handful of them instead of running every parameter on every token. LFM2.5-24B-A2B uses 64 experts per MoE block with top-4 routing, which is why it only activates 2 billion of its 24 billion total parameters per token.

What inference tools support LFM2.5-24B-A2B?

According to AlphaSignal’s coverage of the release, the model has day-one support for llama.cpp, MLX, vLLM, SGLang, and ONNX runtimes, covering both consumer laptop setups and GPU-based server deployments.

How does LFM2.5-24B-A2B differ from LFM2-24B-A2B?

LFM2-24B-A2B was Liquid AI’s earlier checkpoint at the same 24-billion-total, 2-billion-active parameter size, released to prove the LFM2 architecture could scale to that size. Liquid AI has since marked that earlier model as deprecated, directing developers to LFM2.5-24B-A2B for improved performance.

Liquid AI’s 24B Model Hits 184 Tokens/Sec On-Device [2026]