Nemotron 3.5 Bolt E4B vs Gemma 4 E4B: We Ran Both as a Local Agent

NVIDIA released Nemotron 3.5 Bolt E4B on October 23, 2026: a small model for local assistants and agents, sold as fitting in 4 GB. It is not a new architecture. NVIDIA took Google’s Gemma 4 E4B and post-trained it with reinforcement learning for multi-turn tool use and instruction following.

So the fair question is simple: did NVIDIA’s training make Gemma 4 E4B a better agent? We ran both on the same six tasks, three times each, on one RTX 5090 a few hours after the release.

One RTX 5090 32 GB, Atomic Agent v0.6.10 in external mode, upstream llama.cpp build 11840, n=3 per task, October 23, 2026. *Without one 547 second request, explained below; 1,281 s with it.

Which is better as a local agent, Bolt E4B or Gemma 4 E4B?

Bolt E4B, by a small margin on score and a large one on time. It passed one more run than Gemma, and its worst run on the hardest task (20 of 32 hidden tests) was far better than Gemma’s worst (0 of 32). With 18 runs per model, one run of difference can be noise. The speed gap is not noise: 113 seconds against 662.

Most of that speed comes from how Atomic Agent ran Bolt, not from the model generating faster. Per token, Gemma was a bit faster (193 against 178 tok/s). Bolt simply wrote about a tenth of the tokens.

Model IDs

• Bolt E4B: nvidia/NVIDIA-Nemotron-3.5-Bolt-E4B-4GB (GGUF, Q4_K_M), nvidia/NVIDIA-Nemotron-3.5-Bolt-E4B-BF16, drafter for speculative decoding nvidia/NVIDIA-Nemotron-3.5-Bolt-E4B-4GB-DFlash
• Bolt E4B on Ollama: nemotron-3.5-bolt:e4b (not tested by us)
• Gemma 4 E4B: google/gemma-4-E4B-it, GGUF we tested unsloth/gemma-4-E4B-it-qat-GGUF. In Atomic Agent’s model catalog it is gemma-4-e4b.

Why we ran Bolt twice

Bolt E4B ships Gemma 4’s chat template under a Nemotron name. Atomic Agent v0.6.10 picks how to talk to a local model from its name and template, and this combination matched neither its Nemotron rule nor its Gemma rule. So the agent fell back to a plain mode without the reasoning channel. That is what you get today if you point Atomic Agent at Bolt E4B.

We filed it and ran Bolt both ways:

• Default mode: the file as is. The model barely reasons and acts at once.
• Reasoning on: the same file, served under an alias that contains “gemma”, so the agent uses its Gemma 4 reasoning mode, the same mode Gemma 4 E4B got.

Gemma 4 E4B ran in that Gemma 4 reasoning mode, so the reasoning-on column is the like-for-like comparison of the two models.

How did they do in our agent test?

All three passed the easiest task every time. None passed the hardest task (it needs all 32 hidden tests) in any run. The middle tasks decided the score.

How we tested

The same six offline tasks as in our earlier local model runs, each in a fresh workspace with the agent’s state reset between runs:

• t1 read the database port from a YAML config (not the cache port) and write it to a file
• t2 write and run a small stats.py over a given numbers file
• t3 fix a slugify function against hidden test cases
• t4 count ERROR lines across three log files and find the most frequent error (correct answer: 43)
• t5 rename a function across three files without changing the program’s output
• t6 a small Python package from a spec: fix planted bugs, implement settle(), add a command-line tool. It passes only at 32 of 32 hidden pytest cases. The untouched package already passes 13.

Limits were 600 seconds per run for t1 to t5 and 1,200 seconds for t6. The agent was Atomic Agent v0.6.10 in external mode with default settings, except the completion budget, raised to 96,000 tokens. Sampling was the agent’s default for every model: temperature 0.2, top_p 0.95, top_k 40. NVIDIA recommends temperature 1.0 for Bolt; we kept one setting for all models.

The engine was upstream llama.cpp build 11840 (commit 36e36e63a), started with --jinja -fa on -ngl 999 -c 65536 --parallel 1. We used a 64K context because that is Bolt E4B’s limit. No speculative decoding drafter. Files: Nemotron-3.5-Bolt-E4B-Q4_K_M.gguf (6.18 GB) from NVIDIA and gemma-4-E4B-it-qat-UD-Q4_K_XL.gguf (4.22 GB) from Unsloth, the file Atomic Agent’s catalog downloads for Gemma 4 E4B.

Results

n=3 per task. *651 s including the slow request. t5 rescored as described below.

Where each model failed

t4, counting errors. This was the hardest small task for all three. The task needs the count (43) and the most frequent error. Gemma got the count once but named the wrong error, and wrote 18 and 40 in the other runs. Bolt in default mode once ran grep ERROR logs/*, which fails because the agent runs commands without a shell to expand the *, then kept calling grep with no file and wrote nothing; in another run it wrote 33. With reasoning on, Bolt wrote 12 once and got 43 once without naming the error.

t6, the package. Bolt in default mode lands between 20 and 23 of 32 every time, in under 25 seconds. Gemma is all over the place. In its first run it rewrote a function in money.py as one long line, which is a Python syntax error, then could not repair it: every hidden test failed, worse than leaving the package untouched (13 of 32). Its third run reached 25, the best single t6 result in the test.

t2, Bolt in default mode. In one run Bolt tried to replace the input numbers.txt with five made-up numbers. Atomic Agent refuses to overwrite a file the request names as input, and Bolt stopped to ask for permission instead of computing the stats from the real file.

Our agent’s role. Atomic Agent’s no-progress detector blocks a tool call when the model repeats itself. It fired in 1 of Bolt’s default runs, 5 of its reasoning runs and 3 of Gemma’s. Gemma’s 0 of 32 run ended with the detector stopping a loop of reads on the broken file. Atomic Agent v0.6.10 also caps reasoning at about 500 tokens per step for these models, and most reasoning steps of Bolt and Gemma ran into that cap. Longer reasoning might change the reasoning-mode results; the default-mode results don’t depend on it.

The t5 rescore. Our t5 starting folder shipped a stale Python cache (__pycache__/*.pyc) holding the old function name, and the stock checker searched those files too, so no run could pass it. We rechecked the .py files and the program’s output instead, which is what the task asks. All nine t5 runs pass that check: no old name in any .py file, the new name in all three, identical output.

The slow request. During Bolt’s last reasoning run on t6, one request took 547 seconds to produce 738 tokens. It decoded normally for about 500 tokens, then slowed to a crawl and stalled. No other request in the whole test ran below 100 tok/s. We don’t know the cause: it could be the machine, or the grammar the agent uses to cap reasoning, which kicks in near the same point. We show times with and without it.

Limits of this test. One machine, one GPU, three runs per task, five small offline tasks and one mid-size coding task, agent defaults, one sampling setting for all models, external llama.cpp. Other agents, quants, sampling settings or longer projects can rank these models differently.

Repeat this test on your repo. Take a task from your own codebase with a clear finish line, run it three times per model in Atomic Agent, and compare passes, steps and time instead of a single run.

Which one is faster?

Per token, Gemma 4 E4B: 193 tok/s against 178 for Bolt on the same RTX 5090. Per task, Bolt in default mode, by a wide margin, because it generated 11K tokens across 18 runs against 118K for Gemma.

llama.cpp timings for every request in the run. *Without the slow request.

With reasoning on, Bolt writes as much as Gemma and takes about as long. Its reasoning did not buy accuracy here: the same 12 of 18 as default mode, and lower t6 scores. For an agent on a small GPU, the default mode was the better deal in this test.

We did not test NVIDIA’s DFlash drafter, which proposes up to seven tokens per step for speculative decoding. NVIDIA’s drafter card reports about 3.4 to 3.9 accepted tokens per step on an RTX 5090 but gives no tokens-per-second figure.

How much VRAM do Bolt E4B and Gemma 4 E4B need?

About 5 GB. With a 64K context and f16 KV cache, Bolt E4B took 4,863 MiB and Gemma 4 E4B 4,333 MiB on our RTX 5090, measured with nvidia-smi after the model loaded. Both fit an 8 GB GPU with room for the KV cache to grow.

The “4GB” in Bolt’s name does not match its file: the official Q4_K_M GGUF is 6.18 GB on disk, larger than Gemma’s 4.22 GB QAT file. NVIDIA has not said what the 4 GB refers to. We measured VRAM only, not system RAM.

How do I run Bolt E4B or Gemma 4 E4B in Atomic Agent?

Gemma 4 E4B is in Atomic Agent’s model catalog. Pick gemma-4-e4b in the model list and the agent downloads and starts it.

Bolt E4B is not in the catalog yet. Run it with your own llama.cpp server and point Atomic Agent at it in external mode:

hf download nvidia/NVIDIA-Nemotron-3.5-Bolt-E4B-4GB Nemotron-3.5-Bolt-E4B-Q4_K_M.gguf --local-dir ./models
llama-server -m ./models/Nemotron-3.5-Bolt-E4B-Q4_K_M.gguf -c 65536 -ngl 999 -fa on --jinja --port 8080

Then set Atomic Agent’s local model mode to external with the URL http://127.0.0.1:8080. This runs Bolt in the fast default mode we measured. For the reasoning mode, add --alias nemotron-bolt-e4b-gemma4 to the server command so the agent recognizes the Gemma 4 template. Use a recent llama.cpp build; we used build 11840.

What do the vendor benchmarks say?

NVIDIA’s model card compares Bolt E4B with Gemma 4 E4B, Qwen3.5 4B and Nemotron 3 Nano 4B, measured by NVIDIA in its own harness. At Q4_K_M, Bolt beats Gemma 4 E4B on most rows:

These are vendor-published numbers. In our agent test the gap was much smaller than on MultiChallenge or IFBench: one run out of 18.

Which one should you pick?

• For a fast local agent on 8 GB of VRAM: Bolt E4B in default mode. It passed as many runs as the other setups, or more, in a sixth of Gemma’s time, and was the most consistent on the hardest task.
• If you want Apache 2.0 and a one-click setup in Atomic Agent: Gemma 4 E4B. It is in the catalog, uses a bit less VRAM, and decodes a bit faster per token. Expect wider swings between runs.
• For anything bigger than small scripted tasks: neither. No run of either model got past 25 of 32 on our mid-size coding task. A larger local model or Atomic Agent’s Fusion mode, where a cloud model plans and a local model does the work, is the safer bet.