Nemotron 3.5 Lightning 30B-A3B
Continuum's extraction model on Unsloth's GGUF with LM Studio and NVIDIA's NVFP4 with vLLM: close on speed, a tie on judged extraction, reproducible only on LM Studio, and at its best with thinking on a 2,048-token budget.
UPDATED 2026-09-26 · VERSION 0.1
The model
Nemotron 3.5 Lightning 30B-A3B is Continuum's extraction model: it reads each section of an
ingested document and returns the facts in it, each with its evidence quoted from the text.
Two builds were measured, each alone on the card and one request at a time: Unsloth's
UD-Q4_K_S GGUF on LM Studio, and NVIDIA's own NVFP4 on vLLM in WSL2. They are
different quantisations on different runtimes, so a difference between them belongs to
both at once. The runs cover the model call made directly and in a Temporal workflow, the
production extractor on both builds with a judge grading the facts, and the settings that
extract the most.
One at a time
One request at a time, the two builds are close, and vLLM extracts 15% faster.
Each build served three prompts, 200 runs each after 10 warmups: a short one, a long one and a 4K document. The same studies ran the production extractor over 48 sections.
LM Studio UD-Q4_K_S | vLLM NVFP4 | |
|---|---|---|
| Short prompt, the call at p50 | 236 ms | 210 ms (227 with the clock capped) |
| Long prompt, decode | 4.0 ms a token | 4.1 to 4.3 ms a token |
| 4K document, first token at p50 | 34 ms | 98 ms |
| 4K document, the call at p50 | 403 ms (95 tokens) | 345 ms (70 tokens) |
| One extraction, p50 | 3.1 s, 255 tokens a second | 2.6 s, 292 tokens a second |
| Memory on the card | 25.9 GB | 20.7 GB |
Decode drifted by up to 15% within a run on both runtimes, with the memory clock constant, so a gap that small is a draw. The card's core clock was also capped at 2,557 MHz for the first 45 minutes after a reboot, cause unknown, which covered vLLM's short run and about its first 70 long runs. Run again at full clock, vLLM's short prompt took 210 ms at p50 against 227.
Extraction is the one clear lead: vLLM was 15% faster, and a rerun of LM Studio after vLLM moved its time by 3 ms, so the lead isn't drift. The 4K document's first token favours LM Studio because these prompts carry no run-id line, so every run repeats the one before it. LM Studio reuses the whole cached prompt. vLLM caches in blocks of 2,128 tokens, so, going by the block size, about half of the document is computed again.
Home or away
A durable workflow adds 17 to 24 ms, the same as around the Nano.
Each runtime made the same call directly and inside a Temporal workflow, alternately, 200 runs per arm on each prompt. The workflow added 17 to 21 ms at p50 on vLLM and 20 to 24 on LM Studio, paired on answers of equal length. Its own time outside the model call was 13 to 16 ms at p50, as it is around Nemotron 3 Nano 4B.
Table view
| Runtime | p50 | p95 | p99 | Runs |
|---|---|---|---|---|
| LM Studio UD-Q4_K_S, 95-token answer | 16 ms | 28 ms | 32 ms | 200 |
| vLLM NVFP4, 70-token answer on average | 16 ms | 27 ms | 28 ms | 200 |
On the long prompt the p99 is a stall. Three runs on each runtime spent 113 to 129 ms outside the model call, nearly all of it starting the workflow, spaced 5 to 10 minutes apart. Temporal's frontend renews a client's connection about every five minutes, and the durable inference benchmark traces the same stall through the whole platform.
Every prompt, both runtimes
| ms | Durable − direct, p50 | Outside the call, p50 / p95 / p99 | Answers at seed 42 |
|---|---|---|---|
| vLLM, short | 17 | 13 / 22 / 24 | one, 51 tokens |
| vLLM, long | 21 (81 pairs) | 14 / 25 / 113 | 6 lengths, 1,048 tokens on average |
| vLLM, 4K document | 19 (58 pairs) | 16 / 27 / 28 | 7 lengths, 70 tokens on average |
| LM Studio, short | 21 | 15 / 25 / 30 | one, 51 tokens |
| LM Studio, long | 24 | 16 / 47.5 / 114 | one, 999 tokens |
| LM Studio, 4K document | 20 | 16 / 28 / 32 | one, 95 tokens |
Durable minus direct is paired on answers of equal length, so on vLLM's long prompt and 4K document it rests on the runs that happened to match. The time outside the call needs no pairing: it is Temporal's own measure, and has no model time in it. One more LM Studio long run, run 38, spent 80 ms outside the call with a normal start: 55 ms went on dispatching the activity, against a median of 5. It's unexplained. vLLM's short prompt, run again at full clock after LM Studio, came out at 13 / 24 / 25.
On the job
On Continuum's own extraction, the two builds tie on quality.
Both builds ran the production extractor over 48 frozen sections of two of Continuum's own documents, three times each, directly and in the production workflow. A judge model, Qwen3.8 27B, graded each build's first set of facts without knowing which runtime wrote them: supported by its evidence, faithful, atomic, and of the right kind. It also listed the assertions each section made that no fact captured.
LM Studio UD-Q4_K_S | vLLM NVFP4 | |
|---|---|---|
| Facts accepted, first repeat | 306 | 294 |
| Clean on all four counts | 202 of 306 (66.0%) | 198 of 287 (69.0%) |
| Assertions missed, 46 sections | 118 | 140 |
| Sections with one answer across three repeats | 43 of 48 | 3 of 48 |
| One extraction, p50 | 3.1 s | 2.6 s |
The clean rates are 3 points apart, against a standard error of 3.8 over about 300 facts each, so they tie. LM Studio extracted more and missed fewer assertions, and vLLM was faster. Neither invents much: 2 or 3 facts in 300 weren't supported by their evidence, and 7 to 10 weren't faithful to it. The validator keeps invention out before the judge sees a fact, by accepting it only when its evidence is in the section word for word. The weak axis for both is kind, mostly telling an Observation from a Constraint in normative text.
The two builds extract different facts from the same text: matched on their evidence, their sections agree with a mean Jaccard of 0.42. The judge is uncalibrated, holds a few verdicts that contradict themselves on kind, and skipped about 7 of vLLM's facts, so the rates carry its noise as well as the extractor's. What the workflow costs an extraction, 18 ms at p50, is on the durable extraction benchmark.
Dialled in
Thinking on a 2,048-token budget finds 65% more clean facts, at 3.4 times the time.
The same 48 sections, extracted under each setting and graded by the same judge. The baseline is the extraction settings the studies above ran: temperature 0.2, thinking off, and a 2,048-token cap on the answer.
| LM Studio | Baseline | Cap 4,096 | NVIDIA's profile | Thinking, budget 2,048 |
|---|---|---|---|---|
| Settings | temperature 0.2, cap 2,048 | the baseline, cap 4,096 | temperature 1.0, min-p 0, cap 4,096 | temperature 0.6, thinking on, cap 8,192 |
| Sections extracted | 46 of 48 | 48 of 48 | 48 of 48 | 48 of 48 |
| Facts accepted | 306 | 324 | 293 | 510 |
| Clean | 202 (66%) | 217 (67%) | 158 (54%) | 359 (70%) |
| Assertions missed | 118 | 133 | 158 | 74 |
| One extraction, p50 | 3.1 s | 3.4 s | 2.5 s | 11.7 s |
- A 4,096 cap is needed. Two sections needed 2,448 and 2,241 tokens, and the baseline's cap cut both off mid-answer. At 4,096 they extract, and the other 46 come out byte-identical, because the cap doesn't change sampling on a runtime that repeats itself.
- NVIDIA's temperature-1.0 profile is worse. At that temperature the model paraphrases the evidence it was told to copy, so the validator rejects more and the judge finds fewer clean facts.
- Thinking finds the most. 359 clean facts against the raised cap's 217, and 74 missed against 133. The clean rate rose with the count, so the extra facts aren't padding. It splits lists harder, and more of its facts are not atomic: 49 against 26.
- vLLM ranks them the same way. Thinking gave 323 clean facts (74%) and 105 missed, against 200 and 143 with the cap raised alone. Asking vLLM for compact JSON cut the output by 17%, 754 tokens a section against 905, at the same clean rate, 62%. LM Studio has no equivalent setting.
A bigger thinking budget is slower and finds fewer.
| Thinking budget, LM Studio | Facts accepted | One extraction, p50 | Sections past the cap |
|---|---|---|---|
| 1,024 tokens | 476 | 8.4 s | 0 |
| 2,048 tokens | 510 | 11.7 s | 0 |
| 4,096 tokens | 469 | 21.6 s | 1 |
The sweep counts facts and time, and wasn't judged. At 4,096 one section's thinking and answer together passed the 8,192-token cap. Through every setting and budget, the workflow's time outside the model call held at 18 to 21 ms at p50, from 2.5-second calls to 21.6-second ones.
House rules
Each runtime needs Lightning set up its own way.
- vLLM needs its KV cache type set. NVIDIA's checkpoint declares an FP8
KV cache, and
--kv-cache-dtype autofollows it.bfloat16keeps it at 16 bits, as LM Studio's f16 is. - vLLM doesn't repeat itself at a fixed seed. One request at a time at
seed 42, it gave 6 answer lengths to the long prompt and 7 to the 4K document. vLLM's
one switch for reproducible serving,
VLLM_BATCH_INVARIANT=1, refuses this checkpoint in 0.29.0: its NVFP4 weights are weight-only (W4A16), which the deterministic kernel doesn't handle, and no recurrent layer has a batch-invariant backend. With prefix caching off and eager mode it still gave 2 answers in 20, and the Marlin W4A16 kernels are the suspect. - LM Studio repeats itself. At 16,384 context it gave one answer per prompt, 200 times in 200, and the same facts from all 46 extracted sections after a reload 40 minutes later. At 65,536 context, across a reload, one 32,000-token answer changed, cause not established.
- One key turns thinking off on both.
reasoning_effort: "none". vLLM 0.29.0 honours it for this template, though the template reads onlyenable_thinking. Both count 32 prompt tokens and 51 completion tokens for the same request, so the GGUF adds no BOS token here, unlike the Nano's. - Thinking needs a budget. On vLLM, a probe without one spent 8,192
tokens reasoning and never answered. With a 1,024-token budget
(
thinking_token_budget) it returned valid JSON in 8 s. - At temperature 0.2 it writes short. Asked for a 400-word digest of each of 95 sections, it merged them into 11, and with every section listed by number it wrote about 200 tokens each. A job whose size the input fixes, copying each section and commenting on it, filled a 32,000-token cap.
- vLLM's KV pool is sized by hand. As on the Nano, blocks times block
size isn't the context on a hybrid.
--num-gpu-blocks-override 18holds 18,432 tokens, 1.12 times a full request; 16 blocks held a request of only 14,896.
By the book
Every setting was matched, or its difference written down.
| Machine | AMD Ryzen 9 9950X3D, 64 GB, RTX 5090 (driver 617.14), Windows 11 Pro |
| LM Studio | 0.4.25, llama.cpp runtime 2.46.0, on Windows, at 127.0.0.1:1234. UD-Q4_K_S, 24.47 GB; 1 slot, flash attention off, f16 KV cache |
| vLLM | 0.29.0 in WSL2 under Docker Desktop, at 127.0.0.1:8000. NVIDIA's NVFP4 (MoE experts W4A16, Mamba projections FP8, the rest BF16), 21.6 GB, from a Docker volume; 1 sequence, 18 KV blocks, bf16 KV cache, the Marlin MoE backend |
| Both | 16,384 context; seed 42; temperature 0.2, top-p 0.95, top-k 0, min-p 0.01, repeat penalty 1.0, thinking off, 2,048 max tokens; prefix caching on |
| Temporal | The dev server, reached at 127.0.0.1:7233, fresh after a reboot |
| Differences | bf16 against f16 KV; flash attention off on LM Studio only; different quantisers; different thinking switches with the same effect |
LM Studio updated its own runtime from 2.45.0 to 2.46.0 on the morning of the runs, before the first LM Studio run, so the Nano's runtime version doesn't carry over here. vLLM loaded the weights from a Docker volume in 6.5 s, where a bind mount from Windows had taken 107 s the day before.
# durable-inference: the call direct and in a workflow, 200 runs per arm (vLLM shown)
env 'ConnectionStrings__continuum-temporal=127.0.0.1:7233' dotnet run -c Release --project src/Apps/Continuum.Console -- \
benchmark durable-inference --runs 200 --warmup 10 \
--sampling "temperature=0.2,top_p=0.95,top_k=0,min_p=0.01,repeat_penalty=1,reasoning_effort=none,max_output_tokens=2048,seed=42" \
--endpoint http://127.0.0.1:8000 --model nvidia-nemotron-3.5-lightning-30b-a3b-nvfp4 --runtime vllm \
--label lightning-nvfp4-context \
--prompt-file src/Core/Utilities/Continuum.Benchmarks/Models/Prompts/context-heavy-4k.md
# durable-extraction: 48 sections, 3 repeats, direct and durable (LM Studio shown)
env 'ConnectionStrings__continuum-temporal=127.0.0.1:7233' dotnet run -c Release --project src/Apps/Continuum.Console -- \
benchmark durable-extraction --repeats 3 --warmup 2 --label lightning-q4ks