Nemotron 3.5 Bolt E4B 4GB vs LFM2.5 2.6B Base: A Finished Character Against a Blank Slate

One of these models will hold a conversation the moment you download it. The other will not hold a conversation until you train it. That is the whole comparison between NVIDIA-Nemotron-3.5-Bolt-E4B-4GB and Liquid AI LFM2.5-2.6B-Base, and every spec-sheet difference downstream of it is secondary.

NVIDIA's model is a post-trained conversational small language model: chat template, reasoning toggle, tool-calling behaviour, persona tuning, and a 21-row benchmark table. Liquid's is a pre-trained base checkpoint, published explicitly for heavy fine-tuning, with no chat behaviour and no benchmark scores on its card. Putting them in the same "small open model" bucket is a category error that leads people to download the wrong artifact and conclude the model is bad.

The short answer, before the detail

• You need a working voice, persona, or device assistant this month — take NVIDIA-Nemotron-3.5-Bolt-E4B-4GB. It is a finished behaviour, not raw material.

• You have domain data, a training budget, and a requirement that the model be yours — take LFM2.5-2.6B-Base. It is cheaper to fine-tune and carries a 128K context window.

• You want the best small conversational model Liquid makes — you want neither of these alone. You want the post-trained LFM2.5-2.6B and then decide whether the Base or the agent checkpoint is your starting point.

• You want a head-to-head benchmark — there isn't one. The Base card publishes no scores, and no third party has run the two against each other. Any article that prints a winner from a shared benchmark is inventing the benchmark.

Why the mismatch is the story

Liquid AI shipped the LFM2.5-2.6B family in three pieces: a pre-trained Base, a post-trained agent checkpoint, and a speculative-decoding drafter. The Base is the first stage of that pipeline, not a product. Its card says it is "only recommended for tasks that require heavy fine-tuning" — language- or domain-specific assistants, proprietary-data training, and similar work. A base checkpoint predicts the next token very well and has never been taught to answer a question, follow an instruction, or emit a tool call in a schema.

NVIDIA's E4B is the opposite end of that pipeline. It started from Gemma-4-E4B-it, which was already instruction-tuned, and NVIDIA post-trained it again with reinforcement learning from verifiable rewards and human feedback. The card documents the reward domains, the reasoning/non-reasoning batch ratio, and the length penalties applied to control verbosity. Whatever else is true, the model has been shaped toward a job.

So the fair question is not "which is smarter." It is "which stage of the pipeline do you need to buy."

Specifications, dimension by dimension

• Parameters — NVIDIA-Nemotron-3.5-Bolt-E4B-4GB is 8B total with 4B effective parameters in a Gemma-4-E4B architecture; LFM2.5-2.6B-Base is 2.69B dense parameters in a 30-layer hybrid stack of 22 double-gated short-convolution blocks and 8 grouped-query attention blocks.

• Context window — 64K tokens in and 64K out for Bolt; 131,072 tokens for the LFM base.

• Modality — text in, text out for both. Neither accepts images or audio.

• Vocabulary — 128,000 tokens for LFM2.5-2.6B-Base; NVIDIA does not publish a vocabulary size for the E4B, which inherits Gemma's tokenizer.

• Pre-training — 34 trillion tokens for the LFM base, with a mid-training phase that extends context to 128K. NVIDIA does not publish a pre-training token count for the E4B because it did not pre-train the model; it post-trained Gemma.

• Post-training — extensive RLVR and human-feedback work for Bolt, with explicit reasoning and conversational modes. None for the LFM base, by design.

• Published precision — Q4_K_M GGUF at 6.18GB and BF16 safetensors at 15.88GB for Bolt; a single 5.39GB BF16 safetensors file for the LFM base, with separate GGUF, ONNX, and MLX conversions elsewhere in the family.

• Licence — OpenMDW-1.1 for NVIDIA's contribution with the Gemma 4 component under Apache 2.0; LFM Open License 1.0, a custom licence with commercial terms, for Liquid's model.

• Languages — 34 in the E4B metadata, with seven named as primary post-training languages; 16 for the LFM base.

• Release — 23 October 2026 for the E4B; the LFM2.5-2.6B family was published on 4 August 2026.

The parameter gap is real but does not translate into the download gap people expect. The 2.69B Base is a 5.39GB BF16 download; the "4GB" E4B is a 6.18GB four-bit download. Comparing parameter counts across a dense hybrid and a sparse effective-parameter architecture tells you less than comparing bytes on disk.

What each card actually publishes

This is where the asymmetry becomes measurable.

NVIDIA ships 21 benchmark rows, four comparison models, and a separate Q4_K_M column. The scores are vendor-run under NeMo-Gym and explicitly flagged as potentially different from other vendors' self-reported numbers. They cover persona retention, instruction hierarchy, tool timing, grounding, long-context retrieval, and agentic task completion.

Liquid's Base card ships no benchmark table at all. That is not an omission; it is what a base checkpoint is. The numbers that circulate for LFM2.5-2.6B — IFBench 59.17, ToolSandbox 77.83, BFCLv4 56.88, LiveCodeBench v6 59.41, AIME25 51.87 — belong to the post-trained agent checkpoint, not the Base, and they are vendor-reported. Artificial Analysis lists LFM2.5-2.6B at an Intelligence Index of 8, flagged as an estimate with independent evaluation forthcoming; it has no page for the Bolt E4B at all.

So the honest scorecard is: one model has a large, unaudited vendor table, and the other has no table and an independent estimate attached to a different checkpoint in its family. Neither column supports a direct comparison.

Memory and speed are measured on different planets

Both vendors publish latency numbers, and they are not comparable. Read them as separate claims about separate setups.

• Bolt on an RTX 5070 12GB — 3.5 to 4.3GB of VRAM, 548 to 1,238ms to first token, 106.2 to 133.4 tokens per second, measured by NVIDIA with llama.cpp and CUDA at batch 1.

• Bolt on a Jetson Orin Nano 8GB — 4.2 to 4.9GB of VRAM, 5.8 to 6.3 seconds to first token, 13.0 to 15.5 tokens per second. Embedded, but not conversational-fast.

• LFM2.5-2.6B on an M5 Max — around 220 tokens per second, vendor-reported CPU decode.

• LFM2.5-2.6B on a phone-class chip — around 30 tokens per second, vendor-reported.

The M5 Max figure is not a GPU comparison, the Orin Nano figure is not a laptop comparison, and neither vendor published the prompt lengths, batch sizes, or quantization settings in a form that would let you line them up. The one number that is directly checkable is on disk: 6.18GB for Bolt's Q4_K_M against 5.39GB for the LFM base at BF16.

Licences: both open, neither one Apache

NVIDIA's model is OpenMDW-1.1 plus an Apache 2.0 component for Gemma 4. OpenMDW is permissive and allows commercial use, but it is not OSI-approved, and the Gemma inheritance means the Apache terms travel with part of the stack. NVIDIA's card states the model is ready for commercial or non-commercial use.

Liquid's LFM Open License 1.0 is a custom licence with a US$10 million annual-revenue threshold for commercial use. It is not Apache or MIT, and the Base card points at a LICENSE file rather than summarizing the terms. For a research project this rarely matters; for a product with a legal review it is the first thing to read.

The practical difference is not "open versus closed." Both are downloadable and both permit commercial use within their terms. The difference is which terms your counsel has to clear, and whether the model you are shipping carries a second vendor's licence inside it.

The fine-tuning bill, which is the real decision

If you choose the LFM base, the download is the cheap part. You are buying 2.69B parameters of raw pre-trained capability and then paying to teach it a job: data collection, cleaning, supervised fine-tuning, evaluation, and the iteration loop that follows. Liquid's pitch is that 34 trillion tokens and a 128K context make that starting point strong enough to be worth the work.

If you choose the Bolt E4B, you are buying NVIDIA's post-training as a starting point. The BF16 build is 15.88GB and NVIDIA publishes two recipes for changing it: full-parameter training on 8× H100 80GB with FSDP2 and a learning rate of 1e-5, or LoRA on 2× H100 80GB with dimension 16, alpha 32, and a learning rate of 2e-4. Both recipes freeze the vision and audio towers, which is a reminder that the Gemma 4 E4B base is multimodal even though the Bolt release is text-only.

That is a heavier fine-tuning floor than the 2.69B LFM base, and a much lighter behaviour-building job. The E4B already does persona, instruction hierarchy, and tool timing; you are adapting a working model, not creating one.

If you are building a product rather than a model

The default should be the finished checkpoint. A voice assistant, an NPC, a kiosk interface, or a device agent needs behaviour on day one, and the E4B is the only one of these two that has any. Its weaknesses are documented and specific: Tau2-Bench 55.10 against Qwen3.5 4B's 75.06, RULER 86.99 against 95.15, LongBench v2 50.50 against 59.93. It is a conversational model that can call tools, not an agent that can plan.

The LFM base is the right purchase only when the model itself is the product: a domain-specific assistant in a language or vocabulary the general models handle badly, a fine-tune on proprietary data, or a research baseline you intend to own. In that case the absence of chat behaviour is a feature, because you are not paying for behaviour you will overwrite.

There is a third case that neither card addresses: you want to compare them on your own task. Do that with a held-out evaluation set and the same decoding settings, not with the vendors' tables. The E4B's card recommends temperature 1.0 and top_p 0.95 in both thinking modes; Liquid publishes its own settings for the post-trained checkpoint. Matching those is the minimum for a fair test, and even then you are comparing a post-trained model to a base model, which is not a fair test at all.

Where the local model ends and the rest of the stack begins

Whichever checkpoint you pick, it will sit inside an application that also needs models it cannot run. A 2.6B base or a 4B conversational model handles the local reflex layer; it does not handle a 200K-token document, a hard coding task, or a request that needs a frontier model's judgement. Routing those requests through one API — 200+ models, 0% markup on provider list price, automatic failover across providers — keeps the local model as the fast path without forcing a second contract for the slow one.

Which download is yours

Take the E4B if you need a small model that talks, follows instructions, and calls tools today, and you can live with a 6.18GB download and the documented long-context and agentic weaknesses. Take LFM2.5-2.6B-Base if you are starting a fine-tuning project, want a 128K window and a 16-language tokenizer, and have the data and compute to teach the model its job.

The mistake to avoid is downloading the Base, prompting it like a chatbot, and concluding that Liquid's 2.6B is worse than NVIDIA's 4B. It is not worse. It is earlier in the pipeline. The comparison that would actually settle the family question is Bolt E4B against the post-trained LFM2.5-2.6B, and nobody has published that run yet.