- Dataset summary
- Serve with
xyntetik-runnerβ tool calls that still parse when the budget runs out - The files measured, SHA-bound
- Two things worth knowing before the tables
- 1. Everything against the BF16 parent
- 2. The prune ladder β the ranking decides the answer
- 3. It is the checkpoint, not the calibration
- Reproduce it
- Why nothing is uploaded
- Scope and limits
- Publication policy
- Attribution and license
- About Xyntetik
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-GGUFBF16 and Q4_0, revision9d425fe1..., 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 tablegates/: 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 checksmake-calibration-corpus.py,balance-traces.py,domain-check.py: the corpus generator, trace balancer and specialist checktypeplan-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.
- Runner: https://github.com/Joakimpalm-Zen/xyntetik-runner
- Base model: https://huggingface.co/nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-BF16
- Contrast case that passed and shipped: https://huggingface.co/Joakimpalm-Zen/Qwen3-Coder-30B-A3B-Instruct-keep120-Q4_K_M-GGUF
- Former Model-typed location of this report: https://huggingface.co/Joakimpalm-Zen/Nemotron-3.5-Lightning-30B-A3B-prune-frontier-report
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:
- How deep can
nemotron_h_moebe 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. - 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.
- 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.ggufmeasures 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-normsladder 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