Nemotron 3.5 Bolt E4B 4GB vs Nemotron 3.5 Bolt 74B-A9B 24GB: Same Name, Opposite Machines

NVIDIA shipped two models called Bolt eight days apart. NVIDIA-Nemotron-3.5-Bolt-E4B-4GB arrived on 23 October 2026: a text-only, 8B-total conversational model post-trained from Gemma-4-E4B-it. NVIDIA-Nemotron-3.5-Bolt-74B-A9B-24GB — the model most people mean when they say Nemotron 3.5 Bolt — arrived on 15 October: a 74B-total, 9B-active multimodal agent compressed to two bits per expert weight.

They share a badge, a licence, and a launch window. They do not share a parent architecture, a modality, a context window, a benchmark suite, or a job. Reading "Bolt" as a size ladder is the mistake this comparison exists to prevent.

One is a Gemma derivative. The other is a compressed 120B agent.

The lineage explains almost everything else.

The E4B started life as Gemma-4-E4B-it, Google's instruction-tuned small model, and NVIDIA post-trained it with reinforcement learning from verifiable rewards and human feedback through NeMo-RL and NeMo-Gym. The architecture is Gemma's: 8B total parameters with 4B effective, a text-only input and output path, and a 64K context window. NVIDIA's contribution is behaviour, not backbone.

The 74B started from Nemotron 3.5 Super VL 120B-A12B, NVIDIA's own multimodal parent. NVIDIA ran a router-guided architecture search called Star Elastic against a 24GB memory budget and produced a 74-billion-parameter hybrid with 9 billion active parameters per token, combining Mamba-2 and Transformer layers in a LatentMoE design, with a C-RADIO v4-H vision encoder. It accepts text, images, and video, and it handles 256K tokens of context.

Put plainly: the E4B is a conversation model that NVIDIA tuned. The 74B is an agent model that NVIDIA compressed. The name "Bolt" describes the deployment goal — intelligence per gigabyte — not a shared architecture.

The specifications, side by side

• Total and active parameters — 8B total with 4B effective for the E4B; 74B total with 9B active for the 74B.

• Architecture — Gemma-4-E4B for the small model; Mamba-2 plus Transformer hybrid LatentMoE for the large one, with Star Elastic compression from the Super VL parent.

• Modality — text in, text out for the E4B; text, images, and video in, text out for the 74B.

• Context window — 64K tokens in and 64K out for the E4B; up to 256K tokens for the 74B.

• Precision — Q4_K_M for the E4B's shipped GGUF; IQ2 at roughly 2.0625 bits per expert weight for the 74B, with NVFP4 on some Mamba layers and Q8_0 embeddings.

• Published weights — 6.18GB Q4_K_M and 15.88GB BF16 for the E4B; 23.75GB of GGUF weights plus vision projector, 24.12GB of vLLM-ready safetensors, and 149.8GB at BF16 for the 74B.

• Licence — OpenMDW-1.1 for both, with the Gemma 4 component under Apache 2.0 in the E4B's stack.

• Release date — 23 October 2026 for the E4B; 15 October 2026 for the 74B.

• Runtime — llama.cpp for the E4B, with the card marking the recipe "pending" despite shipping quick-start commands; vLLM for the 74B, with a reference recipe that pins a nightly container by commit hash.

One metadata trap is worth flagging before it causes a purchasing mistake. The Hugging Face file widget on the 74B repository reads "22B params" while the model card specifies 74B total and 9B active. The card is right: 22B is a stale sidebar field, not a third variant, and anyone sizing hardware from the widget rather than the card will be badly wrong in the other direction.

The benchmark tables do not share a single row

This is the most important thing to understand before comparing the two, and it is the thing most coverage skips.

NVIDIA evaluated the 74B on GDPVal-AA-V2, Terminal-Bench 2.1, Tau3 Banking, HLE, AA-Omniscience, SciCode, GPQA Diamond, AA-LCR, PinchBench, MCP-Atlas, BrowseComp, and WebArena. It evaluated the E4B on MultiChallenge, RoleBench, RoleMRC, EQ-Bench v3, Brevity, BFCL-v3, When2Call, ToolSandbox, Tau2-Bench, IHEval, AgentIF, StructEval-T, IFBench, InverseIFEval, RULER, LongMemEval, LongBench v2, SysBench, GaRAGe, RAGTruth, and RelyToolBench.

There is no overlap. Not one row appears in both tables. The two suites even use different versions of the agentic benchmark — Tau2 for the E4B, Tau3 Banking for the 74B — so the closest-looking pair is not comparable either.

That means any claim of the form "the 74B is X points better than the E4B" is fabricated. NVIDIA did not publish a common harness, and no third party has run one. What the tables do support is a statement about design intent:

• The 74B was measured on tasks that look like work — terminal use, browsing, scientific coding, graduate-level questions, long-context reasoning. Its strongest published rows are BrowseComp 66.75, Terminal-Bench 2.1 50.98, GPQA Diamond 86.43, and AA-LCR 64.06.

• The E4B was measured on tasks that look like conversation — persona retention, instruction hierarchy, knowing when to call a tool, grounding in tool output. Its strongest rows are IHEval 84.79, RoleBench 67.05, RelyToolBench 63.16, and When2Call 63.36.

Both sets are vendor-reported and unreproduced. The 74B's card carries an extra wrinkle worth flagging: NVIDIA describes the model as the top open model in its class on PinchBench, but its own table shows Qwen3.6-35B-A3B at 88.07 against the Bolt's 87.82. That is a 0.25-point gap and a claim that does not quite survive its own footnote.

Speed claims, with the hardware attached

Throughput is the one place both cards publish numbers, and they still cannot be lined up.

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

• E4B on a Jetson Orin Nano 8GB — 13.0 to 15.5 tokens per second and 5.8 to 6.3 seconds to first token. The same model, on the hardware the "4GB" pitch is really about.

• 74B on an RTX Spark — 83.99 tokens per second on AIPerf SPEED-Bench-Coding, with the LiLiCorr drafter attached and seven speculative tokens per step.

The 74B figure assumes a separate 1.13B drafter checkpoint, a specific benchmark, and different hardware from either E4B run. The E4B figure assumes no drafter. Comparing 133 to 84 and concluding the small model is faster is technically true and practically meaningless: one is a four-billion-effective-parameter model on a desktop GPU, the other is a nine-billion-active model on a different machine with a speculative decoder bolted on.

What the numbers do establish is the shape of the trade. The E4B is built for time to first token; the 74B is built for sustained agentic work where 84 tokens per second is enough. The Orin Nano row is the caution: a 4GB model on embedded hardware is not automatically a real-time conversationalist.

Memory: 4GB and 24GB are envelopes, not files

Both names use a memory target, and neither number is the download.

• E4B — a 6.18GB Q4_K_M GGUF. NVIDIA measures 3.1 to 4.3GB of VRAM in its own batch-1 runs on RTX hardware. The card does not publish a 4GB file.

• 74B — 22.02GB of GGUF weights plus a separate 1.73GB vision projector, for 23.75GB in total, or 24.12GB in the vLLM-ready safetensors build. The 2.0625-bit expert quantization is what makes the 24GB envelope possible.

• BF16 builds — 15.88GB for the E4B, 149.8GB across 63 shards for the 74B. The full-precision variants are for post-training, not deployment, and the 74B's card says so explicitly.

The storage gap is roughly four to one at deployment precision, and roughly nine to one at full precision. The VRAM gap is smaller than the parameter gap because the 74B is paying for its compression in bits, not in size.

Modality and context decide more than parameter count

A 64K text window and a 256K multimodal window are not the same product with different limits.

The 74B can look at an image or a video and act on it. Its card specifies RGB JPEG or PNG input, MP4 video up to two minutes, and guidance of one frame per second at 1080p or two frames per second at 720p. It can read a screenshot, a chart, a form, or a camera feed and then call tools based on what it saw. That is the capability that makes it an agent for browsing and desktop work.

The E4B cannot see. It takes text and returns text, and its 64K window is explicitly weaker than its peers at retrieval: RULER 86.99 against Qwen3.5 4B's 95.15, LongBench v2 50.50 against 59.93. If your application needs to hold a long document or a screenshot in view, the E4B is the wrong model regardless of how good its persona scores are.

Who each one is for

The E4B is for the interface layer. Interactive characters, voice assistants, embedded device agents, robots that need to select a script and speak, and any application where the model has to answer in a few hundred milliseconds on hardware that costs less than a workstation. NVIDIA's demos make the intent concrete: a Reachy Mini robot on a Jetson Orin Nano using the E4B to choose animation scripts while a separate vision model handles perception, and a blacksmith NPC that verifies payment, looks up a recipe, gathers ingredients, and hands over an item.

The 74B is for the work layer. Always-on personal agents that browse, code, analyse data, monitor background tasks, and call APIs. It runs on RTX Spark, DGX Spark, RTX PRO workstations, and GeForce RTX cards with enough memory, and it is designed to sit alongside other applications inside a 24GB budget. Its benchmark profile — BrowseComp, Terminal-Bench, GPQA, AA-LCR — is the profile of a model that finishes tasks, not one that holds a conversation.

Neither is a substitute for the other. A game studio that wants believable NPCs does not need a 74B multimodal agent; an agent platform that needs to read a webpage and run a terminal command cannot use a text-only 4B conversational model.

What a two-model family implies for deployment

The interesting architectural consequence is that NVIDIA has shipped a portfolio rather than a ladder. The E4B handles the reflex layer, the 74B handles the local work layer, and Super VL 120B-A12B handles the heavier multimodal cases. That is three different memory budgets and three different jobs, all under one licence family.

Most applications will still need a fourth layer they cannot download: a frontier model for the requests that exceed the local hardware, or a second vendor for the modality the local model lacks. Routing those through one API — 200+ models, 0% markup on provider list price, automatic failover when a provider degrades — lets the local Bolt stay the fast path and the hosted model stay the exception. The alternative is a separate integration, key, and bill for every model above the local tier.

What would settle the family question

One run. Put both Bolts through the same harness on the same tasks — a conversational set, an agentic set, and a multimodal set — and publish the rows. NVIDIA has the checkpoints, the evaluation stack, and the incentive; it chose to publish two separate tables instead.

Until that exists, the defensible reading is this: the 74B is the more capable model by design and by evidence, on the tasks NVIDIA chose to measure. The E4B is the more appropriate model for a large class of interfaces where a 24GB agent is absurd and a 4GB conversational model is exactly right. The name on the box is the same. The machine inside is not.