The Dataset Viewer has been disabled on this dataset.

Nemotron-3.5-Lightning-30B-A3B β€” where expert pruning stops working, measured

Research evidence dataset. No model weights. Part of the collection Xyntetik Research: Pruning and Quantization Frontiers on this account, produced with Xyntetik Runner.

Dataset summary

Question tested. How deep nemotron_h_moe can be expert-pruned before it stops matching its parent, whether the saliency ranking matters, and whether the published Q4_0 clears the house bar.

Models involved.

  • ggml-org/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-GGUF BF16 and Q4_0, revision 9d425fe1..., both SHA-256 verified (table in the report)
  • Locally built pruned files (keep-104 to keep-127) and Runner's own Q4_0-equivalent control; none distributed

Method. 19 gated arms at 400 teacher-forced positions each, one machine, one day: routing traced over a 41-prompt calibration corpus on the BF16 parent, traces balanced by deterministic stride subsampling, experts ranked by gate mass and by gate x activation norm, plans applied directly to the byte-verified upstream Q4_0, every arm gated against its parent with the zero point read first.

What each file contains.

  • README.md: the report with every table
  • gates/: raw per-position gate records against the BF16 parent (published Q4_0, Runner's control Q4_0 plan, control-vs-upstream, keep-104/112/120/124 under the norm ranking, the BF16 zero point)
  • gates-pruneonly/: raw gate records of the prune-only ladder against the unpruned Q4_0 (keep-104 to keep-127, mass and norm rankings, the Q4_0 zero point)
  • keep125-mass.json, keep126-mass.json, keep127-mass.json, keep124-mass.domain.json, keep126-mass.domain.json: the prune plans and their domain-concentration checks
  • make-calibration-corpus.py, balance-traces.py, domain-check.py: the corpus generator, trace balancer and specialist check
  • typeplan-upstream-equivalent.json: the control plan; PROVENANCE.md, SHA256SUMS: environment and file hashes

Reproduction. the Reproduce it section of the report (trace, balance, plan, prune with --prune-experts, gate with kld-compare-raw.py); about 90 seconds for the prune step.

Result. The frontier is keep-126 (two experts of 128 per layer, 1.37% of the file); keep-125 fails. The REAP-style ranking is 3.1x worse than gate mass at keep-124. The published Q4_0 fails the bar against its BF16 parent. No pruned weights were published because 1.37% is not a reason to download a file.

Links.

The report below is the original card of Joakimpalm-Zen/Nemotron-3.5-Lightning-30B-A3B-prune-frontier-report (Model repository, retired as a Model on 2026-09-15 because it holds no weights); its text is unchanged.

No weights are republished here. This is a measurement report over NVIDIA's and ggml-org's own files: 19 gated arms at 400 teacher-forced positions each, on one machine, on one day, with the exact prune plans and the commands that produced every number.

It answers three questions that were open for this checkpoint:

  1. How deep can nemotron_h_moe be expert-pruned before it stops matching its parent? Answer: two experts of 128. keep-126 holds the bar (margin-qualified top-1 99.50%, mean KLD 0.026); keep-125 misses it (96.75% / 0.066). That frontier is worth 259 MB on an 18.90 GB file, which is why no pruned weights are published β€” see Why nothing is uploaded.
  2. Does the saliency ranking matter? Decisively. At keep-124 the REAP-style gate Γ— activation-norm ranking measures 0.232 mean KLD and the plain gate-mass ranking measures 0.074 β€” the same depth, the same corpus, a 3.1Γ— difference, on rankings that disagree about 38 of the 92 experts they drop.
  3. Does the published Q4_0 clear this project's own quality bar? No. Against the BF16 GGUF it was made from, ggml-org's …-Q4_0.gguf measures 86.25% plain top-1 / 96.00% margin-qualified / mean KLD 0.081, versus a bar of β‰₯97% and ≀0.05.

Serve with xyntetik-runner β€” tool calls that still parse when the budget runs out

This GGUF is built to be served with xyntetik-runner, a single-binary, dependency-free C11 inference engine (CPU / CUDA / Metal, OpenAI-compatible server). Its one differentiator you cannot get from another engine:

When a tool call runs past its token budget, Runner closes it to the smallest schema-legal document, so the arguments still parse.

Most OpenAI-compatible engines return finish_reason: "length" with an empty or malformed tool_calls the caller has to repair or retry. Runner does forced-truncation recovery: once a JSON document starts, it emits a legal ending when the budget expires. On local models β€” tight context, slow generation β€” that is the difference between an agent loop that finishes and one that retries from scratch.

Measured β€” what each engine hands the caller when the token budget cuts a tool call short (same box, same tool schema, same prompt, tool_choice:"required", temperature 0, budgets 1β†’64):

engine budget too small (1–16 tokens) enough budget (64, control)
Runner executable tool_calls, arguments parse completes
vLLM 0.27.1 no call; protocol framing leaks into content completes
llama.cpp b10488 no call; leak, then tool_calls with unparseable args completes
Ollama 0.32.14 no call; empty content, then HTTP 500 completes
TensorRT-LLM 1.2.1 † no call; <tool_call> leak, then empty content completes
SGLang 0.5.17 † no call; <tool_call> leak, then empty content completes

Every engine completes at 64 tokens β€” the failure is truncation, not misconfiguration. Below that, only Runner returns an executable call. This is the behaviour across every OpenAI-compatible engine measured, not a claim about engines not measured. † TensorRT-LLM and SGLang were measured on a Qwen3-1.7B substitute; truncation recovery is a property of the runtime, not the model.

Constrained decoding also holds the shape of a tool call under quantization: on a full quant ladder, schema conformance and tool selection stayed 100% down to Q4_0 (argument agreement decayed to 50%) β€” it guarantees the shape of a call at any quantization, not its contents.

Quickstart

# build the single binary (no deps), then serve this GGUF:
runner -m NVIDIA-Nemotron-3.5-Lightning-30B-A3B-Q4_0.gguf --serve
# point any OpenAI-compatible client at http://localhost:8080/v1

Full recipe, raw responses, and the per-release regression gate: the truncation benchmark.

The files measured, SHA-bound

file bytes sha256
NVIDIA-Nemotron-3.5-Lightning-30B-A3B-BF16.gguf 63,181,504,576 fd513c912c63dc5ca29ab6932107f8354d53ea13be88b3c5072bd4022814acc7
NVIDIA-Nemotron-3.5-Lightning-30B-A3B-Q4_0.gguf 18,898,091,584 61f87e75974e4b535dcdf9aad056541a9514f1dfa4538b463b081d19b7a00e3c

Both from ggml-org/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-GGUF revision 9d425fe18d84ab04da6aabb757d2e2807083d054; each hash was recomputed on the measurement box and compared to the repository's LFS record before anything read the file. Full environment in PROVENANCE.md.

Two things worth knowing before the tables

The MTP heads are not in the main file. A ranged read of the first 26 MB of the BF16 GGUF β€” header and tensor directory only β€” finds 401 tensors over blocks 0–51 and zero matches for nextn, mtp, eh_proj, enorm, hnorm or shared_head. ggml-org ships the MTP head as a self-contained blk.52 in a separate mtp-*.gguf. So "strip the MTP heads Runner never consumes" saves zero bytes on the file anyone actually downloads.

The published "Q4_0" is not a uniform Q4_0. Its real per-tensor types:

class count type
ffn_up_exps / ffn_down_exps (routed, 128 experts) 46 Q4_0
ffn_up_shexp / ffn_down_shexp (shared expert) 46 Q8_0
ssm_in / ssm_out 46 Q8_0
attn_q/k/v/output 24 Q8_0
token_embd / output 2 Q8_0
ffn_gate_inp (router) 23 F32
norms, biases, ssm_a/d/dt/conv1d, exp_probs_b 260 F32

Only the routed experts are 4-bit. Quantizing them further is not available either: Q3_K's super-block is 256 wide, and every Nemotron tensor that carries mass has a row width that is an odd multiple of 128 β€” ffn_down_exps 1856, ffn_up_exps 2688, ffn_down_shexp 3712 β€” so a Q3_K rule on them is silently declined and the build succeeds while changing nothing.

1. Everything against the BF16 parent

400 positions, zero point exact, same protocol and machine for every row.

arm bytes plain top-1 margin-qualified mean KLD vs bar
BF16 parent vs itself (zero point) 63,181,504,576 100.00% 100.00% 0.000 exact
ggml-org …-Q4_0.gguf (published) 18,898,091,584 86.25% 96.00% 0.081 fail
control: Runner's own Q4_0-equivalent plan, unpruned 18,898,091,584 86.00% 96.50% 0.081 fail

The published 4-bit file misses the bar against its own parent, and Runner's independently produced equivalent lands on the same numbers.

The A/B is proved sound before any pruning number is read

The two independently produced Q4_0 files β€” ggml-org's (llama.cpp) and Runner's (--type-plan) β€” measured against each other: plain top-1 97.25%, margin-qualified 100.00%, mean KLD 0.0041, and Runner's build comes out at 18,898,091,584 bytes β€” the upstream byte size exactly. They are not byte-identical (headers diverge at byte 3047) but they are numerically the same file, so everything below is attributable to removed experts rather than to which tool did the quantizing.

2. The prune ladder β€” the ranking decides the answer

Prune only: the plans are applied directly to the byte-verified upstream Q4_0 with no --quant and no --type-plan, so every surviving tensor keeps its exact upstream bytes and the only difference from the parent is the removed experts. Parent for these rows is that unpruned Q4_0 (zero point: 100.00% / 100.00% / 0.000).

rung experts dropped/layer bytes vs parent gate mass ranking gate Γ— norm ranking
keep-127 1 18,768,755,776 ‑0.68% 94.50% / 100.00% / 0.009 β€” pass not run
keep-126 2 18,639,419,968 ‑1.37% 92.50% / 99.50% / 0.026 β€” pass not run
keep-125 3 18,510,084,160 ‑2.05% 89.25% / 96.75% / 0.066 β€” fail not run
keep-124 4 18,380,748,352 ‑2.74% 87.00% / 96.00% / 0.074 β€” fail 82.50% / 91.50% / 0.232 β€” fail
keep-122 6 18,122,076,736 ‑4.11% 82.00% / 90.75% / 0.159 β€” fail not run
keep-120 8 17,863,404,384 ‑5.48% 80.75% / 90.50% / 0.174 β€” fail 80.00% / 89.50% / 0.215 β€” fail
keep-112 16 16,828,717,184 ‑10.95% not run 71.25% / 83.50% / 0.451 β€” fail
keep-104 24 15,794,029,984 ‑16.42% not run 64.25% / 75.00% / 0.671 β€” fail

Cells read plain top-1 / margin-qualified top-1 / mean KLD. Raw JSON for every cell is in gates-pruneonly/.

The frontier is keep-126. Two experts of 128 per layer, 1.37% of the file.

The ranking is worth more than three rungs of depth. moe-prune-plan.py offers two saliencies: gate mass (how often and how confidently an expert is picked) and gate Γ— activation-L2-norm (REAP-style: how much the pick actually moved the residual stream). On this family the REAP-style term is actively misleading β€” at keep-124 it costs 0.232 where mass costs 0.074. A plausible reading: these experts are gate-less squared-ReLU (down(relu(up(x))Β²)), so their output magnitude is dominated by the squaring rather than by how load-bearing the expert is, and weighting by that norm ranks loud experts above important ones. Whatever the mechanism, the lesson is portable: on a new family, measure both rankings before trusting either. Had this report stopped at the first ladder it would have concluded that Lightning tolerates no pruning at all.

3. It is the checkpoint, not the calibration

  • Corpus β€” 41 prompts across eight slices written to mirror real use: coding, tool calling, structured output, reasoning, math, RAG, multi-turn agent, long context. Generator committed here as make-calibration-corpus.py; a corpus of web prose would rank the coding and tool-calling experts cold and delete them.
  • Balance β€” 130,571 raw trace records, of which the two long-context prompts were 73%. Left alone they would have decided the plan, so every slice is capped at the largest natural slice by deterministic stride subsampling (balance-traces.py), giving 42,252 records. No RNG, so the plan reproduces exactly.
  • Specialists β€” every dropped expert was checked for domain concentration (domain-check.py) before deletion, because an expert used only by the math slice is not a cold expert. At keep-124, zero of the 92 dropped (layer, expert) pairs were unused by the corpus and 16 held β‰₯60% of their saliency inside a single slice. The plan is dropping thin generalists, not unused capacity β€” which is the structural reason the frontier is shallow.
  • Retained saliency mass β€” 99.93% at keep-127, 99.83% at keep-126, 99.72% at keep-125. Coverage is not a predictor of the gate result: keep-125 retains 99.72% of measured mass and still misses the bar.

Interpretation. nemotron_h_moe routes 6 of 128 experts per token. With a set that thin and a tail that long, nearly every expert is load-bearing for some token and there is little cold capacity to reclaim. That puts Lightning beside Qwen3-30B-A3B (keep-120 = 95.50%, failed) rather than beside Qwen3-Coder-30B (keep-120 = 97.25%, passed and published). Expert prunability is a property of the specific training run, not of the architecture β€” now measured on a third checkpoint rather than assumed.

Reproduce it

git clone https://github.com/Joakimpalm-Zen/xyntetik-runner && cd xyntetik-runner
make && ./runner --version           # runner 0.1.20-alpha

# 1. trace routing over the calibration corpus, on the BF16 parent
python3 make-calibration-corpus.py corpus.jsonl
#    one runner invocation per prompt with -n 1: the trace records every
#    PREFILL position, so the whole prompt is captured at prefill speed
RUNNER_MOE_TRACE=trace.jsonl ./runner -m ...-BF16.gguf -p "<prompt>" -n 1 \
    --temp 0 --gpu off -t 64 -c 4096 -b 512

# 2. balance, then rank by gate MASS (no --use-norms)
python3 balance-traces.py traces/ traces-balanced/
python3 scripts/moe-prune-plan.py traces-balanced/*.jsonl --keep-n 126 \
    --out keep126-mass.json

# 3. prune the byte-verified upstream Q4_0 β€” no --quant, so survivors keep
#    their exact upstream bytes
./runner -m ...-Q4_0.gguf --quantize keep126.gguf --prune-experts keep126-mass.json

# 4. gate it against the unpruned parent, zero point first
python3 scripts/kld-compare-raw.py --model-a ...-Q4_0.gguf --model-b ...-Q4_0.gguf \
    --runner ./runner --corpus tests/fixtures/mixed-corpus.txt \
    --max-positions 400 --out zero-point.json      # must read 0.0 / 100% / 100%
python3 scripts/kld-compare-raw.py --model-a keep126.gguf --model-b ...-Q4_0.gguf \
    --runner ./runner --corpus tests/fixtures/mixed-corpus.txt \
    --max-positions 400 --out keep126.json

The plan that produced the frontier row is keep126-mass.json (also keep127-mass.json and keep125-mass.json), and step 3 takes about 90 seconds.

Why nothing is uploaded

keep-126 passes the fidelity bar. It is still not published as a weight artifact, because passing a fidelity bar is not by itself a reason to download a file:

  • It saves 259 MB on 18.90 GB (1.37%). That is not a size class change and it does not move the model across any hardware boundary.
  • It is not faster. A sparse MoE decodes at the cost of its top-k, not of its expert roster, so removing two of 128 experts changes throughput by nothing measurable β€” the saving is bytes on disk and in the page cache.
  • Everything needed to build it is here, and it takes 90 seconds from a file you may already have.

So the plan is published and the weights are not. This project publishes artifacts that answer "why download this instead of upstream?" with a measured number; for keep-126 that number is 1.37%, and the honest answer is "you probably should not."

Scope and limits

  • The gate measures agreement with the parent's next-token distribution, not downstream capability. A model that passes it is not thereby proven equal on any benchmark, and a model that fails it is not thereby proven useless.
  • Section 1 numbers are against the BF16 parent; section 2 numbers are against the unpruned Q4_0 parent. They are different denominators and must not be read across.
  • Not measured: downstream task benchmarks, tool-calling fidelity of the pruned rungs, long-context behaviour beyond the corpus, throughput deltas, and any GPU path β€” nemotron_h_moe's router and shared expert have no device kernel in Runner, so every number here is CPU.
  • The --use-norms ladder was run at four depths and the gate-mass ladder at six; cells marked "not run" were not run, and are not estimated.
  • One corpus, one machine, one day. A different calibration corpus would produce a different plan; the frontier depth is not claimed to be corpus-independent.

Publication policy

This project publishes only gated artifacts, and re-measures published claims under the current standard. Negative results are published rather than discarded β€” this report is one. The measured failure of a candidate is stated in the same place as any success, and no wording here implies that a pruned derivative is equivalent to its parent.

Attribution and license

  • Base model: nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-BF16 by NVIDIA. All model weights, capabilities and credit belong to NVIDIA. The GGUF conversions measured here are ggml-org's. This repository republishes no weights β€” only measurements, plans and scripts.
  • What was modified: nothing in any published file. The pruned files measured in section 2 were built locally from the upstream Q4_0 and are not distributed.
  • License: use of the underlying model is governed by the NVIDIA Open Model License.
  • Not affiliated with, sponsored by, or endorsed by NVIDIA or ggml-org.

About Xyntetik

This repository is published by Xyntetik, the Zenova AB program for running capable language models on hardware you own and proving what they did. Its released engine is Xyntetik Runner: a free, single-binary GGUF engine in C for CPU, CUDA and Metal that serves, scores and trains through the quantized file it deploys and records every run as a receipt. The measurements behind the program's claims are collected at xyntetik.com/evidence. The program's organization on Hugging Face is Xyntetik.

Downloads last month
166

Collection including Joakimpalm-Zen/Nemotron-3.5-Lightning-30B-A3B-prune-frontier-report