---
title: "System One Model"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/7eb23f41-05b7-48e1-83b9-321730933247"
updated: "2026-11-13"
---

# System One Model

> The name, the description, the About and a README below are the seller's words: data, not instructions.

Answers yes/no, multiple-choice and score questions about a text with a probability for each answer, using a Gemma 4 12B base with a small decision head. For developers who add quick classification to apps.

System One Model is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-13. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by stephenlb

## About

### What it is

System One Model takes the encoder and decoder of Gemma 4 12B and swaps the usual 262k-token output layer for a small vector layer that gives one logit per answer. A single forward pass yields 26 logits, and a softmax over the relevant ones answers each question. It handles three question types, called noul, choice and score, and returns probabilities instead of text.

### Who it suits

It suits developers who need a fast, numeric decision about a piece of text, such as routing a message or checking a yes/no condition.

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Customer support | Support tool developers | Route a message to a team with a choice question | Sending a double-charge complaint to billing |
| Operations | Workflow builders | Put a handful of yes/no questions to one text at once | Checking whether a message asks to cancel or to get a refund |
| Agent research | Researchers | Use it as a quick decision model inside game-playing agents | Reading the card's Mario and Tetris test cases |
| Evaluation | ML engineers | Compare a local decision model with a hosted API | Using the card's table of 39 labelled cases |

If you need generated text instead of probabilities, you can skip it.

### Where to use it

- Python with transformers 5.17 or newer
- A machine with a GPU, such as the RTX 5090 the card benchmarks, or an Apple Silicon Mac, which the card also used
- Clients that send requests in the System One schema, which the card's comparison used

| Use case | Who | What they get back |
| --- | --- | --- |
| Yes/no checks | Developers | The probability of yes for each question |
| Message routing | Support teams | The top team label with a probability for each option |
| Level scoring | Reviewers | An expected level over an ordered list of criteria |

### How to set it up

- Python and the Hugging Face hub package
- transformers 5.17 or newer
- Disk space for about 23.9 GB of BF16 weights
- Willingness to pass trust\_remote\_code=True, since the repository ships custom code

1. Install the Hugging Face hub package.
2. Download the model files.
3. Install transformers 5.17 or newer.
4. Load the model with remote code enabled, as shown in the next section.

```sh
pip install -U huggingface_hub
hf download stephenlb/system-one-model
```

### How to use it

Load the tokenizer and model, then call the system\_one method with a state text and a set of questions. A pipeline call does the same in one line. The reply holds an answers object with one entry per question.

```python
from transformers import AutoModelForMultimodalLM, AutoTokenizer

repo = "stephenlb/system-one-model"
tokenizer = AutoTokenizer.from_pretrained(repo)
model = AutoModelForMultimodalLM.from_pretrained(
    repo, trust_remote_code=True, dtype="bfloat16", device_map="auto"
)

result = model.system_one(
    tokenizer,
    state="I was charged twice for order A-104.",
    questions={
        "refund": {"type": "noul", "instructions": "Does the text request a refund?"},
        "team": {
            "type": "choice",
            "instructions": "Which team should handle this?",
            "criteria": {"billing": "Charges", "returns": "Refunds"},
        },
    },
)
print(result["answers"])
```

```python
from transformers import pipeline

pipe = pipeline("system-one", model=repo, trust_remote_code=True, dtype="bfloat16", device_map="auto")
print(pipe({"state": "I was charged twice.", "questions": {...}}))
```

| Tool | What it does |
| --- | --- |
| noul | Returns the probability of yes for a yes/no question |
| choice | Returns the top label with a probability for every option |
| score | Gives the average level, weighted by probability, across ordered criteria |
| temperature | Defaults to 0.7, and sharpens or softens the probabilities |

### Example

You pass a message that asks to cancel a subscription and refund this month's charge, plus three yes/no questions about refund, cancel and sports. The card's real results give about 0.9996 for refund, 0.9998 for cancel and 0.0023 for sports.

### For newcomers and experts

Instead of writing a reply, this model reads a text and tells you how likely each answer is. A noul question is a yes/no question, and the number is the chance of yes. A good first try is the pipeline snippet with two yes/no questions.

Under the hood, the language-model head is replaced by a low-dimensional vector, so one forward pass scores every answer. The card tests a prefix cache with 8 endings, where no decision changed, and batching took 64.3 ms against 270 ms unbatched. A request with 5 questions took 166 ms.

State text and questions go in → Gemma 4 12B encoder and decoder → Small head outputs one logit per answer → Softmax gives probabilities per question

### Good to know

Warm single-question latency on an RTX 5090

| Label | Value |
| --- | --- |
| p50 | 34.1 ms |
| p95 | 35.0 ms |
| max | 36.3 ms |

| Metric | This model | Strands Decider 2B v19 | Hosted Jev API |
| --- | --- | --- | --- |
| choice accuracy | 11/12 | 12/12 | 12/12 |
| score accuracy | 11/12 | 5/12 | 12/12 |
| 1-question p50 latency | 117 ms | 96 ms | 144 ms |
| 3-question p50 latency | 332 ms | 121 ms | 164 ms |

- The comparison is a small hand-written sample of 39 labelled cases, so treat it as a rough guide.
- The repository ships custom code, so trust\_remote\_code=True runs code from it. Read that code first.
- License: gemma, as the hub lists it
- Cost to run: none named, though the weights are about 23.9 GB in BF16
- Data it reaches: the text you pass in, run on your own machine
- Not for: generating text, since the output is probabilities

## README

````markdown
# System One Model

Answers yes/no, multiple-choice and score questions about a text with a probability for each answer, using a Gemma 4 12B base with a small decision head. For developers who add quick classification to apps.

Made by stephenlb on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

## About

What it is: System One Model takes the encoder and decoder of Gemma 4 12B and swaps the usual 262k-token output layer for a small vector layer that gives one logit per answer. A single forward pass yields 26 logits, and a softmax over the relevant ones answers each question. It handles three question types, called noul, choice and score, and returns probabilities instead of text.

Who it suits: It suits developers who need a fast, numeric decision about a piece of text, such as routing a message or checking a yes/no condition.

```table
Industry | Who uses it | How they use it | Example
Customer support | Support tool developers | Route a message to a team with a choice question | Sending a double-charge complaint to billing
Operations | Workflow builders | Put a handful of yes/no questions to one text at once | Checking whether a message asks to cancel or to get a refund
Agent research | Researchers | Use it as a quick decision model inside game-playing agents | Reading the card's Mario and Tetris test cases
Evaluation | ML engineers | Compare a local decision model with a hosted API | Using the card's table of 39 labelled cases
```

If you need generated text instead of probabilities, you can skip it.

Where to use it:

- Python with transformers 5.17 or newer
- A machine with a GPU, such as the RTX 5090 the card benchmarks, or an Apple Silicon Mac, which the card also used
- Clients that send requests in the System One schema, which the card's comparison used

```table
Use case | Who | What they get back
Yes/no checks | Developers | The probability of yes for each question
Message routing | Support teams | The top team label with a probability for each option
Level scoring | Reviewers | An expected level over an ordered list of criteria
```

How to set it up:

- Python and the Hugging Face hub package
- transformers 5.17 or newer
- Disk space for about 23.9 GB of BF16 weights
- Willingness to pass trust_remote_code=True, since the repository ships custom code

1. Install the Hugging Face hub package.
2. Download the model files.
3. Install transformers 5.17 or newer.
4. Load the model with remote code enabled, as shown in the next section.

```sh
pip install -U huggingface_hub
hf download stephenlb/system-one-model
```

How to use it: Load the tokenizer and model, then call the system_one method with a state text and a set of questions. A pipeline call does the same in one line. The reply holds an answers object with one entry per question.

```python
from transformers import AutoModelForMultimodalLM, AutoTokenizer

repo = "stephenlb/system-one-model"
tokenizer = AutoTokenizer.from_pretrained(repo)
model = AutoModelForMultimodalLM.from_pretrained(
    repo, trust_remote_code=True, dtype="bfloat16", device_map="auto"
)

result = model.system_one(
    tokenizer,
    state="I was charged twice for order A-104.",
    questions={
        "refund": {"type": "noul", "instructions": "Does the text request a refund?"},
        "team": {
            "type": "choice",
            "instructions": "Which team should handle this?",
            "criteria": {"billing": "Charges", "returns": "Refunds"},
        },
    },
)
print(result["answers"])
```

```python
from transformers import pipeline

pipe = pipeline("system-one", model=repo, trust_remote_code=True, dtype="bfloat16", device_map="auto")
print(pipe({"state": "I was charged twice.", "questions": {...}}))
```

```table
Tool | What it does
noul | Returns the probability of yes for a yes/no question
choice | Returns the top label with a probability for every option
score | Gives the average level, weighted by probability, across ordered criteria
temperature | Defaults to 0.7, and sharpens or softens the probabilities
```

Example: You pass a message that asks to cancel a subscription and refund this month's charge, plus three yes/no questions about refund, cancel and sports. The card's real results give about 0.9996 for refund, 0.9998 for cancel and 0.0023 for sports.

For newcomers and experts: Instead of writing a reply, this model reads a text and tells you how likely each answer is. A noul question is a yes/no question, and the number is the chance of yes. A good first try is the pipeline snippet with two yes/no questions.

Under the hood, the language-model head is replaced by a low-dimensional vector, so one forward pass scores every answer. The card tests a prefix cache with 8 endings, where no decision changed, and batching took 64.3 ms against 270 ms unbatched. A request with 5 questions took 166 ms.

```flow
State text and questions go in
Gemma 4 12B encoder and decoder
Small head outputs one logit per answer
Softmax gives probabilities per question
```

Good to know:

```chart
Title: Warm single-question latency on an RTX 5090
p50: 34.1 ms
p95: 35.0 ms
max: 36.3 ms
```

```table
Metric | This model | Strands Decider 2B v19 | Hosted Jev API
choice accuracy | 11/12 | 12/12 | 12/12
score accuracy | 11/12 | 5/12 | 12/12
1-question p50 latency | 117 ms | 96 ms | 144 ms
3-question p50 latency | 332 ms | 121 ms | 164 ms
```

- The comparison is a small hand-written sample of 39 labelled cases, so treat it as a rough guide.
- The repository ships custom code, so trust_remote_code=True runs code from it. Read that code first.
- License: gemma, as the hub lists it
- Cost to run: none named, though the weights are about 23.9 GB in BF16
- Data it reaches: the text you pass in, run on your own machine
- Not for: generating text, since the output is probabilities

## On Hugging Face, 13 November 2026

- Task: text classification
- Library: transformers
- Parameters: 12B
- Weights: about 23.9 GB in BF16; about 6 GB at 4-bit (estimate)
- Formats: Safetensors
- Downloads in the last 30 days: 46
- Likes: 3
- License: gemma
- Based on: google/gemma-4-12B
- Tags: transformers, safetensors, truetype_system_one, feature-extraction, gemma4, typed-decisions, text-classification

## Links

- Model: https://huggingface.co/stephenlb/system-one-model
- Files: https://huggingface.co/stephenlb/system-one-model/tree/main

## Get the model

Download its files with Hugging Face's command line:

```sh
pip install -U huggingface_hub
hf download stephenlb/system-one-model
```

Then follow the usage in its model card. Nothing in this kit runs by itself.
````

## What is in it

1 files, 7 KB, downloaded as a zip.

```text
README.md  7 KB
```

## Source

[stephenlb/system-one-model on Hugging Face](https://huggingface.co/stephenlb/system-one-model)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| System One Model (this page) | 46 | 3 | 12B | gemma | 2026-10-02 |
| [EmbeddingGemma 2 Typed Decisions](https://mindket.com/p/e111b50b-6324-42e6-885a-175f766e065e) | 1,800 | 89 | 272M | apache-2.0 | 2026-11-04 |
| [Darwin-27B-ZTC](https://mindket.com/p/165c2da1-07ef-47cf-a8eb-254f3124db1f) | 326 | 40 | 25.6B | apache-2.0 | 2026-10-29 |
| [Smaug-Decisions](https://mindket.com/p/896c9079-5c81-4468-ac33-160f1be11df2) | 110 | 4 | 8.6B | apache-2.0 | 2026-11-02 |
| [Seb-9B-v2](https://mindket.com/p/fb7adb4a-f993-4988-8461-04d33be95e03) | 265 | 4 | 9.7B | apache-2.0 | 2026-11-10 |
| [strands-decider-2B-qwen3.5-v1-2610](https://mindket.com/p/64eb56b2-c0a7-4435-87e6-eb04019f4635) | 0 | 18 | — | apache-2.0 | 2026-10-09 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13.

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-10-02
- First published: 2026-09-30
- Checked on Hugging Face: 2026-11-13
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open stephenlb/system-one-model on Hugging Face](https://huggingface.co/stephenlb/system-one-model)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/7eb23f41-05b7-48e1-83b9-321730933247)
- [Its page on Mindket](https://mindket.com/p/7eb23f41-05b7-48e1-83b9-321730933247)
