Neutrino-1

fermion-research‘s open-weight model family, released 2026-07-27: Neutrino-1 8B, Neutrino-1 0.6B, and Neutrino-1 0.6B-Chat, all Apache-2.0, all shipped in a proprietary ternary-family weight format at “one eighth the bytes of fp16” (ternary-weights). The pitch is footprint, stated as a market claim: an 8B-class model that downloads in 2.56 GB and occupies 3.88 GB on disk, against roughly 16 GB for the fp16 models it benchmarks against.

The spoke’s first ternary entry, and the first model here whose headline axis is neither capability nor price but bytes.

The three models

0.6B-Chat is the small model finished for conversation. The 0.6B’s second job is as the certified draft model for speculative decoding against the 8B — the release ships both in one process under a 6 GiB cap on a 16 GB MacBook.

What is actually new here

The weights were trained in the shipping format, not quantized into it. The claim is explicit: “There is no full-precision product model that was rounded afterward: the ternary representation is the medium the weights learned in.” That does not fit this wiki’s existing quantization frame, which splits the world into PTQ and QAT — both of which start from a higher-precision model. See ternary-weights.

The format is proprietary and the training method is unpublished. “The format extends the ternary family with proprietary structure, and the extensions are unpublished”; the training methods are “the lab’s unpublished work.” So the weights are open and the reason they work is not.

Measured structure, published. 62.6% of the 6.95B ternary weights are exactly zero, 18.7% positive, 18.7% negative — signs balanced to within 0.02 points with nothing in training enforcing it. Zero density is flat across attention at every depth but spikes in the earliest feed-forward blocks (down projection 72.5% at layer 2, gate 70.5% at layer 3). Every layer costs exactly 72,351,744 bytes.

Drafted decode with an exactness certificate. The 0.6B proposes up to seven tokens, the 8B verifies in one batched pass, and the release reports 27,648 consecutive tokens with zero divergences from plain decode. Delivered speedup tracks content: ×1.92 on counting (763 tok/s vs 396.7 plain, H100), ×1.26 facts, ×1.10 code, ×1.06 prose, ×1.01 chat. Mechanism detail belongs to ../llm-inference-wiki.

The benchmark table, and how to read it

Fermion’s own comparison, every side run on one measurement stack with the same prompt format, shot count, extraction rule and generation cap:

Read the row labels, not the bolding. The release prints its own losses — it trails Gemma-4-E4B on instruction following by 11 points and Llama-3.1-8B on tool calling by 7, and its context window is the smallest in the table by 3.2×. The MMLU win is the load-bearing claim: higher than a 16-bit 8B at a sixth of the download.

Two cells need care. GSM8K compares Neutrino’s zero-shot, no-chain-of-thought run against Llama’s 8-shot-with-reasoning number, which the page discloses in the cell and which makes that column not a like-for-like. And Gemma-4-E4B’s 1.00 under stated-format extraction is a formatting failure the page itself names — “a formatting failure and not an arithmetic one” — while leaving it in a table where it reads as a rout.

Provenance — what is checkable and what is not

• T1, first-party primary: the lab’s own release post, with unusual methodological disclosure (it states when its re-run of a rival differs from that rival’s card — Gemma-3n-E4B “our run; their card 81.8”, “our rule; card 91”).
• Every number in the table is Fermion’s. Rival scores are Fermion’s re-runs on Fermion’s stack. Controlling the whole measurement is what makes the comparison internally consistent and also what makes it unverified. No independent evaluation exists — nothing from artificial-analysis or any other referee in this wiki.
• The one externally-anchored measurement is the engine comparison: loading the public BitNet b1.58-2B4T weights into Fermion’s container reaches 102.4 tok/s on a 16 GB Apple M5, against 89.0 from the reference bitnet.cpp build on the same machine in the same session. Someone else’s weights, two engines, one machine — the only claim here where Fermion does not control both sides.
• The core claim is not reproducible by design. Open weights under Apache-2.0, closed format extensions, closed training method. A reader can run the model; nobody outside the lab can check why native ternary training holds at this depth.
• Speed figures are dated snapshots on named hardware (H100 80 GB, base Apple M5, NVIDIA L4).

The architecture is Qwen3’s, and the page does not say so

Verified against qwen‘s published Qwen3-8B/config.json while ingesting: every architectural field Fermion states for the 8B matches Qwen3-8B exactly — 36 layers, 4,096 hidden, 32 query over 8 KV heads, 128-dim heads, 12,288 feed-forward, 151,936 vocabulary, 40,960 positions, untied embeddings. The 8,190,735,360 parameter count matches too, and the described per-head RMS normalization of queries and keys is Qwen3’s distinctive QK-norm. The 0.6B likewise matches Qwen3-0.6B’s shape, tied embeddings included.

Stated carefully, because two readings survive and this wiki cannot pick between them:

1. Architecture reuse, which is normal and legal. Model configurations are not proprietary, Qwen3 is Apache-2.0, and adopting a proven geometry to isolate the variable you are actually testing — the weight format — is a defensible experimental choice, arguably the right one.
2. Undisclosed lineage. A post detailed enough to report per-layer zero density and byte-exact layer sizes never names the architecture it adopted, and the framing throughout (“Neutrino-1 8B is a 36-layer decoder-only transformer…”) reads as original design.

The wiki records the match, not a verdict. It matters because footprint claims are comparative: “an 8B at 2.56 GB” means something different if the 8B in question is a known-good geometry. The spoke has precedent on both sides — agents-a1 discloses its Qwen3 lineage in its own materials, sakana-fugu presents other providers’ models as a family of its own. See synthesis.

Availability

Apache-2.0, “no waitlist, no gated preview.” Hugging Face (fermionresearch/Neutrino-8B, -0.6B, -0.6B-Chat), pip install fermion-research for the engine and chat front end, native binaries, a GGUF pack with a public llama.cpp fork adding the format as two tensor types, and an MLX pack for Apple GPUs. On an NVIDIA L4 the GGUF pack decodes at 30.7 tok/s in 4.68 GiB peak VRAM, inside an 8 GB card. No API and no pricing — the model is the product, not a service.

Cross-spoke context

Routed whole on the model-market substance. The rest is noted here, not duplicated:

• ../llm-inference-wiki — the runner-up spoke, and it has a real claim. Grouped-query cache math (147,456 bytes per context token, 6.0 GB at full context), decode as a memory-bandwidth problem before a compute one, and the whole drafted-decode mechanism are that spoke’s subject. This is the documented dual-lens case: the format as a market lever is here, the format as execution mechanism is there.
• ../machine-learning-wiki — §4 is a substantive post-training finding and belongs to that spoke’s train-time domain: behavioural training pressure degrades specific other axes rather than uniformly (a tool-calling stage moved tool use +20 while instruction following bled −9), the damage is diet-dependent, and folding an installed axis’s own signal into a stage’s batches protects only that axis (the 9-point bleed fell under half a point). Dose curves differ per axis: tool calling saturates in ~25 steps, instruction following ~50, knowledge-heavy stages peak mid-course then decay.

Related

fermion-research · ternary-weights · quantization · open-weight-models · qwen · llm-benchmarks · gemma-4 · llama · agents-a1 · synthesis