Published one-shot two-bit conversions of 8B models score 24.2 and 24.7 on five-shot MMLU. Random choice scores 25.0. Neutrino-1 8B uses three states for the same class of projection weights and scores 72.1. The important difference is not the nominal bit width. It is when the constraint enters training.
Every Neutrino training forward pass uses the representation that ships. The model learns which connections should be negative, zero, or positive while the optimizer coordinates those choices across 36 layers. The result is an 8.19-billion-parameter model that retains about 96 percent of Qwen3-8B general knowledge in a 3.88 GB serving artifact, 4.2 times fewer bytes than the bf16 reference.
The constraint has to be present during training
A decoder reads nearly every projection weight for every generated token. Reducing those bytes lowers the memory traffic on an H100, an Apple GPU, and a desktop CPU at the same time. But the smaller representation is useful only if the network can still coordinate its intermediate activations inside it.
Rounding after training changes millions of terms independently. A small error in one weight is usually harmless; millions of unrelated errors passing through 36 residual updates are not. Ternary QAT makes the forward pass expose that error during optimization, while a higher-precision carrier retains the gradient updates that never ship with the model.
What is actually ternary
The constraint applies to seven matrices in each decoder layer. Four serve attention. The query and output matrices are 4,096 by 4,096; key and value are narrower because 32 query heads share 8 key-value heads. Each head has width 128.
Gate, up, and down form the feed-forward block. The first two expand the residual stream from 4,096 to 12,288; the third writes it back. Together, the seven matrices contain 192,937,984 ternary weights per layer. The feed-forward group contains 78.3 percent of them, so it dominates both the byte budget and the depth-wise measurements.
Every layer has the same rank, width, and 72,351,744-byte weight lane. The differences we observe by depth therefore come from the learned state pattern, not from a changing architecture.
Three states and a shared scale
A ternary weight has three states: minus, zero, or plus. The state has no magnitude by itself. The format groups consecutive input weights into fixed blocks. Each block shares one higher-precision scale.
The scale sets the block magnitude. Each state sets a sign or removes the contribution. The stored weight equals the state times the scale. This replaces one 16-bit value per weight with ternary states and a smaller set of scales.
The zero state changes the learned connectivity. A float network can make a connection small. A ternary network can remove it. Training selects which connections use minus, zero, or plus. The resulting weight distribution has three mass points, with most weights at zero.
Some tensors need more precision. A linear output sums hundreds of ternary contributions, so individual errors can cancel. An embedding lookup returns one row without that averaging. Any row error changes the full token representation.
The output head must separate one token from 151,936 alternatives. Small logit margins matter there. The model also has 308,224 normalization gains, and each one scales a full activation channel. Embeddings, the output head, and normalization gains therefore stay at higher precision.
Why rounding lands near chance
Neutrino-1 8B starts from Qwen3-8B. Every training forward pass uses the ternary representation that ships. Higher-precision optimizer state carries the gradients. The projection weights adapt together under the ternary constraint. Qwen supplied the base model; Fermion Research developed the adaptation and training method.
Post-training quantization trains in floating point and rounds the weights later. At ternary precision, this removes most measured accuracy. Published results for rounded 8B models sit near 25 on four-choice knowledge tests. Random answers also score 25. A similar model trained with ternary QAT scores 72.1.
Quantization error explains the failure. One linear output sums hundreds of weight and activation products. A trained network depends on how these terms cancel. Post-training quantization rounds each weight independently to a nearby level.
Each error is small, but unrelated errors accumulate across a row. The output then differs from the float activation. Thirty-six layers compound that difference. The final quality loss is large.
Two published one-shot two-bit conversions score 24.2 and 24.7 on five-shot MMLU. Random answers score 25.0. Three models trained for their target representation score 47.24, 65.75, and 72.1 at the same artifact size. At this precision, post-training rounding removes most measured task performance.
Quantization-aware training applies the constraint before the model ships. Every training forward pass uses ternary weights. The loss measures that representation. The gradient reaches a higher-precision carrier inside the optimizer, but that carrier never ships.
Training selects sign patterns, zero positions, and block scales that work together. The shipped projection weights come from this constrained process. They are not a post-training conversion.
2.56 GB on the wire, 3.88 GB in memory
Three equally likely states carry 1.58 bits of information. Hardware stores whole bits, so a simple container uses two bits per state. It wastes about one fifth of that space. Trained models make the states uneven, which creates more coding headroom. The release transport recovers both gaps.
The download codes the weight stream near its information content. The receiving machine expands it without loss. The 8B download uses 2.56 GB and expands to the 3.88 GB artifact the engine serves. The 0.6B file uses 328 MB and downloads in 238 MB. That download is within 0.007 percent of its order-0 coding bound.
The weights chose where to go sparse
We inspected every tensor in the shipping container. The model has 8.19 billion parameters, including 6,945,767,424 ternary states. These cover every attention and feed-forward projection across 36 layers. Just under 63 percent use the zero state. The map below shows all 252 tensors.
Attention zero share varies by 1.67 points across 36 layers. The layer 1 key matrix uses 61.84 percent zeros. The layer 25 value matrix uses 63.51 percent. Depth has little effect on attention density.
The feed-forward matrices differ in layers 2 through 4. The down matrix reaches 72.47 percent zeros, and the gate reaches 70.48 percent. Both sit about ten points above later layers and return to the common range by layer 5. The layer 1 down matrix is the densest tensor at 60.59 percent zeros.
The learned weights created this pattern. The early feed-forward rows have heavier tails than the rest of the network. Neither the format nor the training objective required that result. It appears only in matrices that write back to the residual stream.
The vocabulary is now the expensive part
Parameter count and file size measure different things. The model has 8,190,735,360 parameters. Ternary projections account for 6,945,767,424. Two untied int8 vocabulary tables account for 1,244,659,712. The remaining 308,224 values are fp32 normalization gains.
The ternary lane uses 2.60 GB. The vocabulary tables use 1.24 GB. Scales, normalization values, and row metadata use 26 MB. Ternary states make up 84.8 percent of the parameters but 67.2 percent of the file.
The 0.6B file has a different balance. Its tied int8 vocabulary table has 155,582,464 parameters and uses 47.5 percent of the file. The ternary lane uses 50.4 percent. A fixed vocabulary takes a larger share as the decoder gets smaller. The 8B vocabulary uses 32.1 percent of its file.
The 3.88 GB artifact reaches 33.7 tokens per second through the optimized MLX path. On an NVIDIA L4, it reaches 30.7 tokens per second. It uses 4.68 GiB of VRAM with 4,096 tokens of context. This fits on an 8 GB card.
Memory movement limits single-stream decode. Each generated token reads every active weight. The released artifact moves 4.2 times fewer weight bytes per token than Qwen3-8B at bf16. Both models use the same memory system.
Zero share predicts transport size
Zero share predicts download size. Across layers, the ternary lane codes to 0.516 through 0.569 of its raw bytes. Zero share and coded size correlate at minus 0.92. Layers 2 through 4 have the most zeros and the smallest coded size.
Projection types follow the same order. The down matrix codes to 0.543 of its raw size. The key matrix codes to 0.567.
The int8 vocabulary tables compress less. They retain 0.883 of their raw size. The complete 3.88 GB artifact downloads in 2.56 GB, or 0.661 of its raw size. The mix of ternary weights and dense vocabulary sets that ratio.
The state distribution survives a 14-fold scale change
The 0.6B model separates format effects from model effects. Its state shares sit within 0.4 point of the 8B across a fourteenfold parameter gap. Zero uses 62.26 percent against 62.63. Plus uses 18.87 against 18.68. Minus uses 18.86 against 18.69.
Other ratios change with scale. The 0.6B has 28 layers, a hidden width of 1,024, and a feed-forward width of 3,072. Attention uses 40 percent of each layer, compared with 21.7 percent in the 8B. Ternary states make up 73.9 percent of its parameters, compared with 84.8 percent in the 8B. Its vocabulary also uses more bytes than its ternary weights.
Knowledge survives better than behavior
One average would hide how retention changes by task. Against Qwen3-8B at full precision, Neutrino-1 8B retains 96 percent of general knowledge. It retains 87 percent on the re-annotated knowledge set and 87 percent on strict instruction following. Tool-use retention is 79 percent.
The Neutrino artifact uses 4.2 times fewer bytes. Per stored byte, those four axes reach 4.03, 3.65, 3.65, and 3.32 times the reference.
Knowledge retains more than behavior in this comparison. Many weights distribute each knowledge result. Linear sums can also cancel individual state errors. Strict instruction and tool-use tests score complete episodes instead. One failed step can fail the episode.
This order has held across every model we trained. Knowledge responds strongly to the weights. Behavior depends more on post-training and full-episode checks.
One behavior axis exceeds the reference. Neutrino-1 8B follows the required answer format more often and stops where the reference drifts. This result comes from behavior training, not from storage format alone.
Behavior objectives still interfere
Behavior objectives interact during post-training. Tool-use pressure reduced strict instruction following. Instruction pressure preserved tool use but changed termination behavior. These effects repeated in the same direction across stages. We recorded the affected axis after every stage.
A stage with two independent checks changed this pattern. Both checked behaviors improved together. This was the first two-axis gain in the program. Unmeasured axes can still fall, so evaluation coverage affects training decisions.
We do not accept a behavior gain until the full battery passes. Later stages use more checks at once so they detect adjacent regressions before checkpoint selection.
What the result establishes
Neutrino-1 8B retains 96 percent of Qwen3-8B general knowledge while using 4.2 times fewer bytes. One behavior axis exceeds the reference. State shares remain almost constant from 0.6B to 8B across a fourteenfold parameter gap. These results measure the same ternary representation during training, storage, and inference.
