---
title: "Introducing the Neutrino-1 models"
description: "Today, we are releasing Neutrino-1: three open-weight models trained for a compact ternary format with CUDA, Apple-silicon, and x86 runtimes."
canonical: "https://www.fermionresearch.com/research/neutrino-8b/"
source: "Fermion Research"
---

# Introducing the Neutrino-1 models

Today, we are releasing Neutrino-1: three open-weight models trained for a compact ternary format with CUDA, Apple-silicon, and x86 runtimes.

The release contains Neutrino-1 8B, Neutrino-1 0.6B, and Neutrino-1 0.6B-Chat. The 8B is the general-purpose model for knowledge, instruction following, and tool use. The 0.6B can run independently or serve as its draft model, while 0.6B-Chat is post-trained for conversational use.

Neutrino-1 8B has 8,190,735,360 parameters, yet its compressed download is 2.56 GB and its serving artifact occupies 3.88 GB. A conventional fp16 model of the same size requires about 16 GB of weights. The difference matters during generation because single-stream decoding moves nearly every model weight for every token.

The three releases share a tokenizer, container layout, loader, and inference engine. The same model file runs on CUDA, Apple silicon, and x86, and the engine can load the 8B and 0.6B together for speculative decoding. We are releasing the weights, manifests, MLX packs, GGUF support, static binaries, and Python package today.

## The Neutrino-1 family

Neutrino-1 8B is a decoder-only transformer with 36 layers and a 4,096-wide residual stream. It uses 32 query heads and 8 key-value heads, each 128 dimensions wide. This 4:1 grouped-query arrangement reduces KV-cache memory by four relative to caching all 32 heads.

Rotary position embeddings span each head, and RMS normalization is applied to queries and keys before they enter the cache. Each layer expands from 4,096 to 12,288 through a gated feed-forward block. The model has a 151,936-token vocabulary, separate input and output tables, and supports up to 40,960 tokens of context.

Neutrino-1 0.6B follows the same design at one quarter of the width: 28 layers, a 1,024-wide residual stream, 16 query heads, 8 key-value heads, and a 3,072-wide feed-forward block. It shares the 8B tokenizer and ties its input and output embeddings into one 156 MB table. Because both models use the same token space, the 0.6B can draft directly for the 8B without a remapping stage.

Neutrino-1 8B

Neutrino-1 0.6B

Both models share a tokenizer, format, and runtime. Vocabulary weights occupy 47.5 percent of the 0.6B file and 32.1 percent of the 8B file.

Fig. 1Both containers at one scale. Width is the residual stream, split at each model's measured attention share.

## How the weights are stored

Every attention and feed-forward projection in the 8B model is trained and stored in a ternary representation. Across 36 layers, this covers 252 matrices and 6.95 billion weights. Each stored weight is negative, zero, or positive; per-row scale metadata provides its magnitude.

Those projection weights occupy 2.60 GB, or roughly two thirds of the serving artifact. Exactly 62.6 percent are in the zero state. That share is stable across attention layers, although the early feed-forward blocks become sparser: the layer 2 down projection reaches 72.5 percent zeros and the layer 3 gate reaches 70.5 percent.

Measured over the shipping container, 2026-07-27. Attention holds a flat code density at every depth; the first feed-forward blocks silence hardest.

Fig. 2Weight-state occupancy of the shipping container, measured over all 6.95 billion ternary weights.

We retain more precision for tensors that do not benefit from the same averaging effect. The two vocabulary tables use int8 rows with per-row scales and occupy 622 MB each. Normalization vectors remain at full precision and use 1.2 MB. There are no fp16 tensors in the container.

Each decoder layer therefore has the same 72,351,744-byte footprint. Attention accounts for 21.7 percent of a layer and the feed-forward block for 78.3 percent.

For distribution, we code each tensor class separately. Ternary layers compress without loss to about 55 percent of their raw size, while the denser int8 embeddings retain 88 percent. The resulting 2.56 GB download expands to the same byte-identical container on every supported platform.

Every layer costs the same 72,351,744 bytes of weight lane, and the two embedding tables together cost more than seventeen layers.

Fig. 3Artifact composition by tensor class and decoder layer. Tile tint encodes each layer's coded-transport ratio.

## Training for the representation

Neutrino-1 8B begins from Qwen3-8B, which we credit as the base model. We continued training with ternary quantization-aware training: every forward pass uses the same constrained representation that later ships in the engine, while higher-precision optimizer state carries the gradients.

This distinction is central to the release. Neutrino-1 is not a floating-point model rounded to two bits after training. Its projection weights learn together while already restricted to the target representation.

Later stages focused on instruction following, tool use, mathematics, and clean termination. These objectives interact. In one run, a tool-use stage added twenty points to tool performance but removed nine points from strict instruction following; a mathematics-heavy stage reduced tool use.

We therefore ran the complete installed evaluation battery after every stage and carried vulnerable objectives into later batches. That reduced the nine-point instruction loss to less than half a point without giving back the tool-use gain. We selected checkpoints on the release engines, not only in the training harness, and stopped stages when more optimization no longer improved the full battery.

## Capabilities

Across the complete 57-subject, 14,042-question five-shot MMLU run, Neutrino-1 8B scores 72.1 on five-shot MMLU. On MMLU-Redux it scores 67.8 in a generative evaluation with thinking disabled.

On IFEval, the prompt-strict score is 77.2. The same run scores 80.2 on instruction-strict and 76.3 on prompt-loose. The BFCL v3 macro score is 68.9 across thirteen categories.

For GSM8K, we report two extraction rules because output formatting can otherwise be mistaken for mathematical ability. Flexible extraction takes the last number and scores 53.4. The stated rule accepts a number only in the requested answer position. It scores 51.73. The gap is under two points. Both runs are zero-shot and use no chain of thought, unlike many published GSM8K results that use eight-shot prompts with worked reasoning.

We use the same prompt format, shot count, extraction rule, and generation limit for every model in the comparison. This is important on strict tasks: one 16-bit instruction model loses nearly all of its flexible GSM8K score under the stated rule because it fails the answer format, not because it fails the arithmetic.

| Axis | Neutrino-1 8B8.19B | Gemma-4-E4B4B effective | Llama-3.1-8B8B | Ternary-Bonsai-8B8B | Gemma-3n-E4B4B effective | AQLM 2-bit Llama-3-8B8B |
| --- | --- | --- | --- | --- | --- | --- |
| How the weights were made | Ternary, trained in it | 16-bit, uncompressed | 16-bit, uncompressed | Ternary, trained in it | 16-bit, uncompressed | 2-bit, after training |
| Download | 2.56 GB | 16.02 GB | 16.06 GB | 2.18 GB | 15.70 GB | 4.08 GB |
| MMLUfive-shot | 72.1 | 70.57 | 68.3 | 65.75 | 64.9zero-shot | 58.72 |
| IFEvalprompt-strict | 77.2 | 88.26our run, thinking off | 80.4vendor, mean of four readings | 83.65our run; their card 81.8 | 84.41external published run | not published |
| BFCLv3, macro over 13 subsets | 68.9 | not published | 76.1vendor, version unstated | 71.45our run; their card 73.9 | not published | not published |
| GSM8K, stated format | 51.73 | 1.00 | not published | 39.67 | not published | not published |
| GSM8K, flexible extraction | 53.4 | 30.67 | 84.58-shot, with reasoning | 35.00our rule; card 91 | 60.12external published run | 50.878-shot |
| Context windowtokens | 40,960 | 131,072vendor card | 131,072vendor card | 65,536vendor card | 32,768vendor card | 8,192inherits Llama-3 |
| Decode, Apple laptoptok/s | 33.7optimized MLX | 30community M4 Pro, 4-bit | 32.0community M3 Max, llama.cpp | 49.0our MLX run | vendor publishes no rate | no laptop runtime |
| Decode, one H100 80 GBtok/s | 396 | not published | 158 | not published | not published | not published |
| Drafted decode, same machinetok/s | 763 | no rate published | 373 | none for the 8B | not published | no drafting path |

| Neutrino-1 8B | Ternary, trained in it |
| --- | --- |
| Gemma-4-E4B | 16-bit, uncompressed |
| Llama-3.1-8B | 16-bit, uncompressed |
| Ternary-Bonsai-8B | Ternary, trained in it |
| Gemma-3n-E4B | 16-bit, uncompressed |
| AQLM 2-bit Llama-3-8B | 2-bit, after training |

| Neutrino-1 8B | 2.56 GB |
| --- | --- |
| Gemma-4-E4B | 16.02 GB |
| Llama-3.1-8B | 16.06 GB |
| Ternary-Bonsai-8B | 2.18 GB |
| Gemma-3n-E4B | 15.70 GB |
| AQLM 2-bit Llama-3-8B | 4.08 GB |

| Neutrino-1 8B | 72.1 |
| --- | --- |
| Gemma-4-E4B | 70.57 |
| Llama-3.1-8B | 68.3 |
| Ternary-Bonsai-8B | 65.75 |
| Gemma-3n-E4B | 64.9zero-shot |
| AQLM 2-bit Llama-3-8B | 58.72 |

| Neutrino-1 8B | 77.2 |
| --- | --- |
| Gemma-4-E4B | 88.26our run, thinking off |
| Llama-3.1-8B | 80.4vendor, mean of four readings |
| Ternary-Bonsai-8B | 83.65our run; their card 81.8 |
| Gemma-3n-E4B | 84.41external published run |
| AQLM 2-bit Llama-3-8B | not published |

| Neutrino-1 8B | 68.9 |
| --- | --- |
| Gemma-4-E4B | not published |
| Llama-3.1-8B | 76.1vendor, version unstated |
| Ternary-Bonsai-8B | 71.45our run; their card 73.9 |
| Gemma-3n-E4B | not published |
| AQLM 2-bit Llama-3-8B | not published |

| Neutrino-1 8B | 51.73 |
| --- | --- |
| Gemma-4-E4B | 1.00 |
| Llama-3.1-8B | not published |
| Ternary-Bonsai-8B | 39.67 |
| Gemma-3n-E4B | not published |
| AQLM 2-bit Llama-3-8B | not published |

| Neutrino-1 8B | 53.4 |
| --- | --- |
| Gemma-4-E4B | 30.67 |
| Llama-3.1-8B | 84.58-shot, with reasoning |
| Ternary-Bonsai-8B | 35.00our rule; card 91 |
| Gemma-3n-E4B | 60.12external published run |
| AQLM 2-bit Llama-3-8B | 50.878-shot |

| Neutrino-1 8B | 40,960 |
| --- | --- |
| Gemma-4-E4B | 131,072vendor card |
| Llama-3.1-8B | 131,072vendor card |
| Ternary-Bonsai-8B | 65,536vendor card |
| Gemma-3n-E4B | 32,768vendor card |
| AQLM 2-bit Llama-3-8B | 8,192inherits Llama-3 |

| Neutrino-1 8B | 33.7optimized MLX |
| --- | --- |
| Gemma-4-E4B | 30community M4 Pro, 4-bit |
| Llama-3.1-8B | 32.0community M3 Max, llama.cpp |
| Ternary-Bonsai-8B | 49.0our MLX run |
| Gemma-3n-E4B | vendor publishes no rate |
| AQLM 2-bit Llama-3-8B | no laptop runtime |

| Neutrino-1 8B | 396 |
| --- | --- |
| Gemma-4-E4B | not published |
| Llama-3.1-8B | 158 |
| Ternary-Bonsai-8B | not published |
| Gemma-3n-E4B | not published |
| AQLM 2-bit Llama-3-8B | not published |

| Neutrino-1 8B | 763 |
| --- | --- |
| Gemma-4-E4B | no rate published |
| Llama-3.1-8B | 373 |
| Ternary-Bonsai-8B | none for the 8B |
| Gemma-3n-E4B | not published |
| AQLM 2-bit Llama-3-8B | no drafting path |

Measured on standard public harnesses, July 2026. Byte counts are the whole artifact in decimal gigabytes. MMLU is five-shot everywhere except Gemma-3n-E4B, whose published figure is zero-shot. Our GSM8K is zero-shot with no chain of thought under two extraction rules: flexible takes the last number in the answer, stated requires the answer in the form the prompt asked for. Other models in the table do not publish an equivalent stated-format result, so their columns appear only in the flexible row; both published results are eight-shot. IFEval is prompt-level strict for every cell we measured; Llama-3.1-8B publishes one IFEval number that is the mean of its four prompt and instruction readings under strict and loose grading. BFCL is the thirteen-subset macro of version three; Llama-3.1-8B publishes a zero-shot BFCL accuracy without naming a version, so the two are not the same meter. The Ternary-Bonsai-8B and Gemma-4-E4B scores are our own runs of those checkpoints at settings identical to ours, Gemma-4-E4B from its base repository and with its reasoning mode off; where those runs disagree with the vendor card the cell prints the card figure beside ours. The Llama-3.1-8B figures are its published ones, as is the AQLM row. The two-bit rounded row is a published study of an 8B with no released artifact, so its bytes are a class figure. Not published means the vendor states no number and we hold none.

Fig. 4Six models, twelve axes, no empty cells. Rival columns carry every axis we could source, including the rows where the class is ahead of us; the full battery is on the model card.

The 16-bit artifacts use fifteen to sixteen gigabytes. The two post-training two-bit conversions use fewer bytes but score near chance. Models trained for their target format occupy a different region of the size-to-score plot.

Six artifacts, each joined from download size to five-shot MMLU: three 16-bit, two ternary, and one rounded to 2-bit after training.

Fig. 5Each line joins a model's download size to its five-shot MMLU score.

## Tool use

BFCL combines thirteen suites into one macro score. We also report each suite. Function composition scores range from 70.0 to 85.0 across simple, multiple, parallel, and parallel-multiple calls. Relevance detection ranges from 77.1 to 80.0.

The model declines an irrelevant function almost as reliably as it selects the correct one. The live suites use schemas from public real-world APIs with varied argument names and nested fields.

Scored subsets from the preceding run on one colour scale. The current independently measured macro is 68.9.

Fig. 6BFCL v3 by category, grouped by what each suite tests. The macro mean over the thirteen is 68.9.

## Local inference

Single-stream decoding is usually limited by memory bandwidth rather than arithmetic throughput: each token streams the 2.60 GB ternary lane and the 622 MB output table. A smaller serving artifact lowers that bandwidth floor on every backend, while the engine determines how closely the hardware approaches it.

Through the optimized MLX path, the artifact decodes at 33.7 tokens per second. The separate CPU-only path reaches 24.9 while the GPU stays idle. Both paths stream the same packed weights through one memory system. On an H100 80 GB, the plain path reaches 396 tokens per second.

We also tested the engine with public BitNet b1.58-2B4T weights. Our container reaches 102.4 tokens per second on the Apple M5 test system. The reference bitnet.cpp build reaches 89.0 on the same machine and in the same session. Both runs share the same power and thermal conditions.

Model weights have a fixed cost. Context memory grows with each token. The 4:1 grouped-query cache uses 147,456 bytes per token at 16-bit precision across 36 layers. A 4,096-token history uses 604 MB. The full 40,960-token range uses 6.0 GB.

The model weights remain at 3.88 GB. Ungrouped 32-head attention would make the cache four times larger and push the full-context total past 28 GB. Grouped-query attention keeps the model and maximum cache below 10 GB.

Computed from the container’s attention geometry: 8 KV heads of 128 dimensions over 36 layers is 147,456 bytes per token of context at 16-bit precision.

Fig. 7Resident memory against context length, computed from the container's attention geometry.

## Speculative decoding

Drafted decode uses two models in one format. Neutrino-1 0.6B proposes a short token sequence. The 8B scores up to seven proposed positions in one forward pass. The engine keeps the longest exact match and then emits the next token from the 8B.

Greedy drafted decode cannot emit a token that the 8B would reject. We still test the implementation against plain decode, token by token. The release path produced 27,648 consecutive tokens with zero differences.

Speed depends on how many proposed tokens the 8B accepts. On an H100 80 GB, counting output reaches 763 tokens per second against 396.7 without drafting. Facts reach 500, code 437, prose 422, and chat 402. On counting prompts, the 8B accepts all six proposed tokens on every verify pass. Each 8B pass emits about seven tokens.

Both models occupy one MLX process that peaks at 4.3 GiB. Factual prompts reach 25.71 tokens per second against 22.00 without drafting. The 8B accepts 74 percent of proposed tokens. Six prompts produced identical tokens with drafting on and off.

1. 01The 0.6B draftsOne to seven tokens, length chosen from recent acceptance.
2. 02The 8B verifies in one passEvery drafted position scored in a single batched forward pass.
3. 03The agreed prefix is keptThe longest run where both models chose the same token.
4. 04The 8B emits the next tokenFrom its own distribution, then the loop restarts.

Factual prompts leave 5.0 drafted tokens alive per pass and need 86 passes for 512 tokens; code leaves 1.8 and needs 181.

Stage means come from the 2026-07-25 mechanics probe. The drafted path is certified exact on the shipping configuration: 27,648 consecutive tokens compared against plain decode with zero divergences.

Fig. 8The verify cycle and what it delivers per content class. Certified across 27,648 consecutive tokens.

The controller selects draft length for each step. Factual completions accept 96 to 99 percent of proposed tokens at every tested length, so the controller uses seven-token drafts. Other text accepts fewer tokens as the draft grows. The controller then shortens the draft to one or two tokens.

Nine prompt classes, one runtime, and one draft model in the 2026-07-25 probe. The controller uses longer drafts when recent acceptance is high and shorter drafts when it is low.

Fig. 9Acceptance against draft length, nine prompt classes, one runtime and one draft model.

## The 0.6B models

Neutrino-1 0.6B can run alone or draft for the 8B. Alone, it reaches 1,177 tokens per second on an H100 80 GB. Paired with the 8B, it produced 27,648 tokens with zero differences from plain decode. On counting prompts, the pair reaches 762.6 tokens per second and accepts all six proposed tokens per pass.

The model has 596,049,920 parameters. Its file uses 328 MB, and its download uses 238 MB. The native binary reaches 225 tokens per second on the native CPU path. MLX reaches 201.2 tokens per second in 0.526 GiB of memory.

The model uses the 8B tokenizer, so proposed tokens need no remapping. The vocabulary table uses 47.5 percent of the 0.6B file. The same table class uses 32.1 percent of the 8B file. The small model ties its embeddings because vocabulary is its largest storage cost.

Qwen3-0.6B is the full-precision reference at the same parameter count. Its bf16 weights use 1.50 GB and score 60.82 on zero-shot ARC-easy. Neutrino-1 0.6B scores 53.45 from a 238 MB download. Its process uses 0.526 GiB, just over one third of the reference weight size.

87.9 percent of Qwen3-0.6B’s ARC-easy, at 6.3 times fewer bytes.

Both sides graded on our harness at zero-shot accuracy. Qwen3-0.6B is the base model this container was built from, and the Neutrino side is the shipped container.

Fig. 10The 596,049,920-parameter models evaluated on the same harness at bf16 and ternary weight precision.

Neutrino-1 0.6B-Chat adds conversational post-training to the same container. The chat stage changed state occupancy by less than 0.1 percentage point in every projection. It left the tied embedding table byte-identical. The stage rearranged ternary states inside the projections without replacing the model.

We test the chat model on the engines users receive. It answered 20 of 20 sentence fragments and 30 of 30 factual prompts, produced no absurd affirmations, and leaked no template text in five checks. It held its identity in all eight probes. Across the held-out response set, every reply was well formed, with zero nonsense affirmations and zero prompt parroting.

Stopping is measured separately because a useful first answer can still be followed by a loop. The static binary terminated cleanly on 88.5 percent of the stop-discipline set and looped on 4.5 percent. MLX terminated on 85 percent and looped on 5 percent. Reporting both runtimes makes backend-specific decoding failures visible instead of hiding them behind a single conversational score.

### Decode rate

Neutrino-1 0.6B, single-stream greedy

### Conversation

Neutrino-1 0.6B-Chat, held-out prompts, shipping container

### Form and identity

Neutrino-1 0.6B-Chat, 100 held-out probes

### Stop discipline

Neutrino-1 0.6B-Chat, on both shipping runtimes

Fig. 11The small models, graded on the shipping containers and the runtimes they ship on.

## Run Neutrino-1

The pip package includes the engine, loader, and chat interface. The repository also includes static binaries for macOS arm64 and Linux x86-64. These binaries run the container on the CPU without Python in the execution path. Each model records its compatible engine version, and the loader checks that version before use.

```text
$ pip install fermion-research
$ fermion chat --model fermionresearch/Neutrino-8B
```

On the first 8B run, fermion downloads a 2.56 GB coded transport with a progress bar, verifies its SHA-256, and unpacks it locally. Later runs load from cache.

- Long context with bounded KV memory<div><span class="select-none text-paper/30">$ </span>fermion chat --model fermionresearch/Neutrino-8B --kv-dtype int8 --yarn-factor 4</div> The native window is 40,960 tokens. --yarn-factor 4 extends the loaded window toward 160K without changing the artifact; --kv-dtype int8 holds 131,072 tokens in about 9.3 GiB. fp16 is the default, fp32 preserves byte-identical 0.1.9 output, and --yarn-factor 1.0 is exact identity.
- A local OpenAI-compatible server<div><span class="select-none text-paper/30">$ </span>fermion serve --model fermionresearch/Neutrino-8B</div> Serves at http://127.0.0.1:8000/v1. Point any OpenAI client at that base URL; the key can be any string. Tool calling, streaming, and a persistent KV session are on by default.
- Plain Transformers<div><span class="select-none text-paper/30">$ </span>hf download fermionresearch/Neutrino-8B --local-dir Neutrino-8B \</div><div> --exclude "gguf/*" --exclude "*.tv4z"</div> <div>import fermion</div><div>from transformers import AutoModelForCausalLM, AutoTokenizer</div><div>model = AutoModelForCausalLM.from_pretrained("Neutrino-8B")</div><div>tokenizer = AutoTokenizer.from_pretrained("Neutrino-8B")</div> Import fermion first to register the trtc_v4 model type. Load from the downloaded local directory; passing the Hub repository id directly to from_pretrained does not work.
- GGUF, through our llama.cpp fork only<div><span class="select-none text-paper/30">$ </span>git clone https://github.com/fermionresearch/llama.cpp && cd llama.cpp</div><div><span class="select-none text-paper/30">$ </span>git checkout fermion-fv5</div><div><span class="select-none text-paper/30">$ </span>cmake -B build -DCMAKE_BUILD_TYPE=Release -DLLAMA_CURL=OFF -DGGML_METAL=OFF</div><div><span class="select-none text-paper/30">$ </span>cmake --build build -j --target llama-completion</div> The pack uses the FV5 tensor type: stock llama.cpp, Ollama, and LM Studio cannot load it. The fermion-fv5 branch is the CPU/CUDA build and requires -DGGML_METAL=OFF. For Apple-GPU kernels, use the live fermion-fv5-metal branch and omit that flag.
- MLX, on Apple silicon<div><span class="select-none text-paper/30">$ </span>cd Neutrino-8B/mlx</div><div><span class="select-none text-paper/30">$ </span>pip install -r requirements.txt</div><div><span class="select-none text-paper/30">$ </span>python -m fermion_mlx --model ../neutrino-8b_v4.bin --mode chat --tokenizer .</div> Run this exact sequence after downloading the repository. The working directory and relative model path are required.

#### The full CLI

Every command takes --model with a Hub id or local path.

[Fermion documentation](https://www.fermionresearch.com/docs/)

Fig. 12fermion chat, static capture; the rate line is the measured native CPU figure.

The release also includes a GGUF pack and [a public llama.cpp fork](https://github.com/fermionresearch/llama.cpp) with two tensor types for the format. The CUDA build offloads all 36 layers. On an NVIDIA L4, it reaches 30.7 tokens per second. It peaks at 4.68 GiB of VRAM with 4,096 tokens of context.

Under greedy decode, the CPU build matches a full-precision expansion of the container. An MLX pack serves Apple GPUs. We compare every converted pack with the shipping container, token by token, before release.

## Availability

All three models are available now. The Neutrino-1 8B repository includes the weights, manifest, and install files. The download uses 2.56 GB. All three models ship as open weights under the Apache License 2.0. The license permits commercial use, modification, fine-tuning, and redistribution.

The GGUF pack, MLX implementation, and llama.cpp fork are public. Fermion keeps the optimized kernels closed.

Weights, native binaries, GGUF pack, MLX pack.

```text
$ fermion chat --model fermionresearch/Neutrino-8B
```

Run Neutrino-1 8B

```text
$ pip install fermion-research
$ fermion chat --model fermionresearch/Neutrino-8B
```

First run downloads a 2.56 GB coded transport, shows progress, verifies its SHA-256, and unpacks locally. Later runs load from cache.

The draft model, and a fast model on its own.

```text
$ fermion chat --model fermionresearch/Neutrino-0.6B
```

Run Neutrino-1 0.6B

```text
$ pip install fermion-research
$ fermion chat --model fermionresearch/Neutrino-0.6B
```

First run downloads the 0.24 GB coded transport, shows progress, verifies its SHA-256, and unpacks locally. Later runs load from cache.

The conversational small model.

```text
$ fermion chat --model fermionresearch/Neutrino-0.6B-Chat
```

Run Neutrino-1 0.6B-Chat

```text
$ pip install fermion-research
$ fermion chat --model fermionresearch/Neutrino-0.6B-Chat
```

First run downloads about 0.33 GB of raw model files with progress and verifies them. This model does not use the coded transport. Later runs load from cache.

The engine, the loader, and the chat front end.

```text
$ pip install fermion-research
```

Adds the format to the llama.cpp toolchain.

```text
$ git clone https://github.com/fermionresearch/llama.cpp && git checkout fermion-fv5
```

Two related reports add more detail. [Intelligence at one-eighth the bits](https://www.fermionresearch.com/research/one-eighth-the-bits/) covers ternary QAT and the model format. [The Neutrino Engine](https://www.fermionresearch.com/research/the-neutrino-engine/) covers the local runtime.

## More from the lab

![A cobalt cellular membrane becoming progressively finer](https://www.fermionresearch.com/images/backgrounds/cobalt-cell.webp)

ResearchJuly 27, 2026

### Intelligence at one-eighth the bits

One-shot two-bit conversion lands near chance. Training inside the constraint produces 72.1 MMLU from a 3.88 GB artifact. This is what changed inside the weights.

![A honey-toned filament carrying energy across a tactile surface](https://www.fermionresearch.com/images/backgrounds/honey-filament.webp)

ResearchJuly 27, 2026

### The Neutrino Engine

An A100 can move the weights for one measured decoder step in 104 microseconds. The step takes 694. The Neutrino Engine is built around the gap.

Source: [https://www.fermionresearch.com/research/neutrino-8b/](https://www.fermionresearch.com/research/neutrino-8b/)