Continuum docs
Continuum \ Advanced inference

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_SvLLM NVFP4
Short prompt, the call at p50236 ms210 ms (227 with the clock capped)
Long prompt, decode4.0 ms a token4.1 to 4.3 ms a token
4K document, first token at p5034 ms98 ms
4K document, the call at p50403 ms (95 tokens)345 ms (70 tokens)
One extraction, p503.1 s, 255 tokens a second2.6 s, 292 tokens a second
Memory on the card25.9 GB20.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.

Durability's own time outside the model call, the 4K document, 200 runs per arm
LM Studio UD-Q4_K_S95-token answer
p50 16 · p95 28 · p99 32 ms
vLLM NVFP470-token answer on average
p50 16 · p95 27 · p99 28 ms
Table view
Runtimep50p95p99Runs
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
The 200 durable runs behind the strip's LM Studio row, played back in order. Each request goes out along the top rail to Temporal, the worker and the model, and comes back along the rail beneath it. The readout counts only while the request is outside the model call, and each run's time outside it lands in the histogram. The p50 and p95 settle as the runs arrive, and the p99 is drawn once all 200 are in.

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
msDurable − direct, p50Outside the call, p50 / p95 / p99Answers at seed 42
vLLM, short1713 / 22 / 24one, 51 tokens
vLLM, long21 (81 pairs)14 / 25 / 1136 lengths, 1,048 tokens on average
vLLM, 4K document19 (58 pairs)16 / 27 / 287 lengths, 70 tokens on average
LM Studio, short2115 / 25 / 30one, 51 tokens
LM Studio, long2416 / 47.5 / 114one, 999 tokens
LM Studio, 4K document2016 / 28 / 32one, 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_SvLLM NVFP4
Facts accepted, first repeat306294
Clean on all four counts202 of 306 (66.0%)198 of 287 (69.0%)
Assertions missed, 46 sections118140
Sections with one answer across three repeats43 of 483 of 48
One extraction, p503.1 s2.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 StudioBaselineCap 4,096NVIDIA's profileThinking, budget 2,048
Settingstemperature 0.2, cap 2,048the baseline, cap 4,096temperature 1.0, min-p 0, cap 4,096temperature 0.6, thinking on, cap 8,192
Sections extracted46 of 4848 of 4848 of 4848 of 48
Facts accepted306324293510
Clean202 (66%)217 (67%)158 (54%)359 (70%)
Assertions missed11813315874
One extraction, p503.1 s3.4 s2.5 s11.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 StudioFacts acceptedOne extraction, p50Sections past the cap
1,024 tokens4768.4 s0
2,048 tokens51011.7 s0
4,096 tokens46921.6 s1

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 auto follows it. bfloat16 keeps 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 only enable_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 18 holds 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.

MachineAMD Ryzen 9 9950X3D, 64 GB, RTX 5090 (driver 617.14), Windows 11 Pro
LM Studio0.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
vLLM0.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
Both16,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
TemporalThe dev server, reached at 127.0.0.1:7233, fresh after a reboot
Differencesbf16 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