Nemotron 3.5 Bolt 74B vs LFM2.5 24B A2B: Two Ways to Fit an Agent in 24GB

The interesting thing about NVIDIA Nemotron 3.5 Bolt 74B-A9B 24GB and Liquid AI LFM2.5 24B A2B is not that one is three times bigger. It is that both are answers to the same constraint — an agent that runs on a machine you own rather than a machine you rent — and they answer it from opposite directions. One compresses a very large model until it fits. The other is designed small from the first token and spends its budget on being fast rather than on being large.

The numbers are close enough to be confusing. Bolt is a 74-billion-parameter checkpoint with 9 billion active per token, stored at roughly two bits per expert weight, in a 24GB file. LFM2.5-24B-A2B is a 24-billion-parameter checkpoint with 2.45 billion active per token, at ordinary precision. Both are mixtures of experts. Both run without a network. Behind the similar-sounding pitch, almost every engineering choice is different.

What LFM2.5-24B-A2B actually is

Liquid AI's checkpoint is the largest and final member of the LFM2.5 family and the last of that family still to ship. Its weights went up on Hugging Face in early October and the company announced it on 13 October 2026, so it is roughly as new as Bolt and hasn't accumulated much independent results either.

Architecturally it is a specific bet. Forty layers, of which thirty are double-gated short-convolution blocks and ten are grouped-query attention — a mostly-convolutional stack with attention used sparingly, rather than the Mamba-2/attention interleave NVIDIA uses. Sixty-four experts per MoE block with top-4 routing, which means the model reads four experts per token out of sixty-four. 2.45 billion parameters active per token against 24.0 billion resident. A 128,000-token vocabulary, 36 trillion training tokens, and a 131,072-token context window.

It is text-only, and it always thinks before it answers — the reasoning trace is not optional. Liquid positions it against models a size and a half larger on agentic tasks, and posts a LiveClaw score of 48.09 against 38.19 for Qwen3.6-35B-A3B to support that. That is a vendor comparison on a vendor-selected benchmark and should be read as such, but the active-parameter count it is boasting about is checkable in the model's own configuration.

What Bolt actually is

Bolt is not a model that was designed small. It is Nemotron 3.5 Super VL 120B-A12B after NVIDIA ran Star Elastic over it — a router-guided architecture search that has to satisfy a hard footprint, in this case under 24GB at batch size 1 and 128K context — and then quantised its expert weights to IQ2-XXS at 2.0625 bits per element with quantisation-aware distillation to recover what that cost.

The compression is aggressive in a way Bolts's parameter count hides. Expert top-K came down from 22 in the parent to 9, which is nearly the same top-K as LFM2.5's top-4 despite the model carrying three times the parameters. The vision tower was reattached afterwards from the parent, so Bolt accepts images and video where LFM2.5-24B-A2B accepts only text, and it inherited a 256K context window doubled over Liquid's.

NVIDIA's published claim for the compression is a general one worth repeating: for a fixed memory budget, compressing a large model beats training a small one from scratch. Bolt is that claim as an artifact. And NVIDIA's own framing makes the comparison explicit — its model card states that the Gemma and Qwen baselines were selected for fitting in 24GB at 4-bit, which is a different route to the same envelope than Bolt's 2-bit weights.

The spec contrast, both sides on one line

• Total and active parameters — Bolt: 74B total, 9B active per token. LFM2.5-24B-A2B: 24.0B total, 2.45B active per token.

• Backbone — Bolt: Mamba-2 state-space blocks interleaved with mixture-of-experts and attention. LFM2.5-24B-A2B: thirty double-gated short-convolution blocks plus ten grouped-query attention layers.

• Routing — Bolt: top-9 experts after compression, down from 22 in the parent. LFM2.5-24B-A2B: 64 experts per block, top-4.

• Stored precision — Bolt: IQ2-XXS experts at 2.0625 bits per element, Mamba layers at NVFP4, embeddings and output at Q8_0. LFM2.5-24B-A2B: full-precision weights, with GGUF, FP8, ONNX and several MLX bit-widths published as siblings by the vendor.

• Context — Bolt: up to 262,144 tokens. LFM2.5-24B-A2B: 131,072 tokens.

• Modality — Bolt: text, images and video in, text out. LFM2.5-24B-A2B: text in, text out.

• Licence — Bolt: OpenMDW-1.1. LFM2.5-24B-A2B: lfm1.0, free for commercial use below $10M in annual revenue and a paid commercial licence above it.

• Intelligence Index — Bolt: 21, measured by Artificial Analysis. LFM2.5-24B-A2B: no Artificial Analysis profile exists for this checkpoint, so there is no comparable independent score and this article will not invent one.

• Published price — Bolt: none anywhere, and no hosted endpoint. LFM2.5-24B-A2B: $0.10 per million input tokens with a $0.05 cached rate, and $1.00 per million output, on Liquid's own hosted endpoint, with $2 of starting credit.

That last pairing is the sharpest fact in the comparison, and it runs in the direction most people do not expect: the model with the smaller footprint is the one that has a price, and the model with the larger footprint is the one that doesn't. Bolt cannot be tried without buying hardware. LFM2.5 can be tried this afternoon for a rounding error.

Speed, and how carefully to read the numbers

Neither model has an independent datacentre measurement. This is the honest state of the evidence and it constrains what can be said.

For LFM2.5-24B-A2B, Liquid reports 184 tokens per second on an Apple M5 Max and 114 on an AMD Ryzen AI Max+ 395, and claims up to 1.7× faster inference than comparable MoEs on-device. Those are vendor figures on laptop-class silicon, unreproduced by anyone else, and they say nothing about what the model does on a datacentre GPU with many concurrent requests.

For Bolt, NVIDIA reports 83.99 tokens per second on AIPerf SPEED-Bench-Coding with the LiLiCorr speculative drafter active, on an RTX Spark-class machine. That is also vendor-reported, also unreproduced, and measured on a different benchmark against different silicon, so it cannot be set beside Liquid's 184 and treated as a comparison. The honest statement is that both companies measured their own model on their own preferred hardware and neither number transfers.

What is structural rather than measured: Bolt reads 9 billion parameters per token and LFM2.5 reads 2.45 billion. At equal memory bandwidth, an MoE reads roughly in proportion to its active parameters, and low-bit expert weights help further by shrinking bytes moved per parameter. LFM2.5 has the smaller active set by a factor of 3.7, and it is running at higher precision per weight, so the byte traffic per token is the place to look. That is an argument that Liquid's model should be faster, not a measurement that it is.

Which one to download

The split here is not capability versus capability, because they are not attempting the same task. Bolt is a multimodal agent that reads screenshots and drives a browser at 74B scale, compressed until it fits. LFM2.5-24B-A2B is a text agent built to answer fast on a machine with no discrete GPU at all.

Reach for Bolt when the agent has to see — WebArena, PDFs, video frames — or when the workload runs offline on a machine with a Blackwell-class accelerator already in it, and when you accept that you will be the first person to measure its throughput. Reach for LFM2.5-24B-A2B when the task is text, the machine is a laptop, latency matters more than depth of reasoning, and the whole point is that the model fits in unified memory alongside the rest of your applications.

The two things that would change the answer: an independent benchmark run on both, and any published hosting for Bolt. Neither exists today.

Running them next to a hosted model

Both of these checkpoints are, by design, things you run yourself. Neither is on our catalogue — the catalogue was checked rather than assumed, and neither the Nemotron nor the LFM2.5 families appear in it — so this section is not a pitch for hosting either one. It is a note about what sits beside them.

A local 24B agent on a laptop handles the routine work: routing, summarising, tool-call formatting, the ninety per cent of turns that never needed a large model. The turns that do need one still have to go somewhere, and that is where a router earns its place. OrcaRouter exposes 200-plus models behind one key at the provider's list price with 0 percent markup added, so a vendor price cut is live on our side the same day, and its routing DSL lets you describe a composition — a cheap model for the first pass, an escalation rule, a fallback — as a single call rather than as application code. Automatic failover across providers means a capacity problem upstream is retried rather than surfaced to your users.

For anyone building on a local executor, that division of labour is the reason a small checkpoint stays viable: the small model does the volume, and the expensive model is reached without a second contract or a second SDK.

What would settle it

Two measurements are missing and both are cheap for someone with the hardware. The first is a like-for-like throughput and latency run: LFM2.5-24B-A2B against the 24GB Bolt checkpoint, same harness, same batch sizes, same context lengths, on the same accelerator. Nobody has run it. The second is a third-party evaluation of LFM2.5-24B-A2B on the benchmarks NVIDIA used, so that the LiveClaw claim and the Bolt table can be read against each other instead of being quoted in parallel from two different marketing pages.

Until then, the choice is a memory-budget decision rather than a benchmark decision. One model asks you to own a GPU with 24GB of Blackwell-class compute and gives you vision and 74B of distilled reasoning in return. The other asks for a laptop, costs pennies an hour to try on someone else's servers, and gives up sight and half the context window to get there.

What the numbers cannot tell you is whether any of it has gone wrong in the field: the documented AI incidents and agent failures around models in this class are collected in the OrcaRouter AI Incident Archive, where each entry carries its own sources, severity, confidence grade and disputed flag.