Jeetu456/decider-2b

Decider 2B

Decider 2B is a 2-billion-parameter decision model. You give it a state (text or JSON) and a set of typed questions. It returns a calibrated probability for every allowed option of every question in one forward pass. It never generates text, so there is no output parsing and no malformed JSON.

Use it for routing, triage, moderation, tool choice ("call a tool, answer, or ask?"), intent detection, yes/no checks, and multiple choice that can say "I don't know". It runs on a laptop CPU, a free Colab GPU, or llama.cpp.

The request and response format follows Jev / SystemOne (POST /v1/systemone). The model is post-trained from Qwen/Qwen3.5-2B-Base and released under Apache-2.0.

At a glance

	Decider 2B	Clef-flash	pplx-decider v1.1
Parameters	2B	9B	27B
Weights (BF16)	~4 GB	~18 GB	~49 GB
Output	one pass, probabilities	one pass	one pass
AA Decision Index (estimated / published)	58.6 (est.)	49 (Clef)	53
Decision Index kit, decision & tool mean	65.6	72.9	–
License	Apache-2.0	see its card	see its card

How to read this: on the Artificial Analysis evaluations, Decider 2B is ahead of much larger decision models. Its index is an estimate, because one of the four AA tests is private (details below). On the broader Decision Index kit it is still behind Clef-flash, mainly on long contracts, API catalogues and the smart-home simulator.

Model

• Backbone: Qwen3.5-2B-Base (text). The fine-tuned weights are merged in and stored as standard safetensors. Its full-attention layers run bidirectionally, so every question and option sees the whole request. The linear-attention layers keep their native behaviour.
• Decision head: an option-pointer head on the final hidden states. It scores option i of question k as <Wq h(answer k), Wk h(option i)> / sqrt(d) + w · h(option i) (head_dim 256).
• Output: one logit per allowed option for each question. Divide by the calibrated temperature (1.2, in decider_head_config.json) and apply a softmax per question.
• Selective answering: some choices include an option that means "I don't know". When no answer reaches the threshold (0.55 by default), the model picks "I don't know". To answer more often, set DECIDER_ABSTAIN_THRESHOLD; 0 turns abstention off. At 0.65, the stand-in knowledge test gives 12.8% accuracy and 94.6% non-hallucination.

Files

File	Purpose
model-*.safetensors, model.safetensors.index.json, config.json, generation_config.json	Backbone with the fine-tune merged in
decider_head.safetensors, decider_head_config.json	Decision head; temperature, abstention threshold, maximum pass length
decider_model.py	Request format, token layout, the model, load_release_model, and systemone
tokenizer.json, tokenizer_config.json, vocab.json, merges.txt	Tokenizer
serve/	Batched Jev/SystemOne API server: Dockerfile, API keys, rate limits, metrics
examples/decider_quickstart.ipynb	Colab-ready notebook: routing, moderation, tool choice, "I don't know", batching
examples/decider_cli.py	Command-line tool for one-off and batch questions
space/	Gradio demo, ready to upload as a free CPU Hugging Face Space
gguf/	llama.cpp runner and agreement check
source/	Installable Python package decider (pip install ./source)
handler.py, requirements.txt	Hugging Face Inference Endpoints
deploy/	RunPod Serverless and Replicate/Cog recipes
training/	Data builder, training loop, evaluation harness, licences and the scripts that produced these weights
evals/	Benchmark summaries, per-benchmark comparisons, AA reports with every answer, training logs
LICENSE	Apache-2.0

Quick start

Tested with torch 2.11 and transformers 5.19 (Python ≥ 3.10). The optional flash-linear-attention and causal-conv1d packages make it faster. Without them it still runs, CPU included.

pip install "transformers>=5.19" torch huggingface_hub safetensors

import sys
from huggingface_hub import snapshot_download

path = snapshot_download("Jeetu456/decider-2b")
sys.path.insert(0, path)
from decider_model import load_release_model, systemone

model = load_release_model(path, device="cuda")          # or "mps" / "cpu"

response = systemone(model, {
    "state": "My card was charged twice for the same order. Please fix this today.",
    "questions": {
        "team": {"type": "choice", "instructions": "Which team handles this?",
                 "criteria": {"billing": "Payments, charges and refunds",
                              "technical": "App bugs, crashes and outages",
                              "account": "Login, password and profile changes"}},
        "urgent": {"type": "noul", "instructions": "Does the customer express urgency?"},
        "priority": {"type": "score", "criteria": ["Can wait", "This week", "Today"]},
    },
})
print(response["answers"])

systemone takes a Jev/SystemOne request body and returns the same response body: model, answers keyed by question ID, and usage.

• A choice answer has choice, confidence and probabilities.
• A score answer has the expected score, confidence, legend and probabilities.
• A noul answer has the probability of true.

Describe your options. Accuracy goes up a lot when each choice option says what it means, rather than being a bare key.

For batches:

from decider_model import encode_record
batch = model.encode([encode_record(r) for r in requests])
logits = model(**{k: v.to("cuda") for k, v in batch.items()}) / model.temperature

Serving

docker build -f serve/Dockerfile -t decider-2b .
docker run --gpus all -p 8000:8000 -v ~/.cache/huggingface:/hf-cache \
  -e DECIDER_MODEL=Jeetu456/decider-2b -e DECIDER_ALLOW_NO_AUTH=1 decider-2b

curl http://localhost:8000/v1/systemone -H 'Content-Type: application/json' \
  -d '{"state":"Checkout is down, nobody can pay!","questions":{"urgent":{"type":"noul","instructions":"Is this urgent?"}}}'

Way	Hardware	Notes
Python, one file (decider_model.py)	GPU, Apple Silicon or CPU	~50 ms per request on a GPU, ~1 s on a desktop CPU
Python package (source/)	Same	Decider.from_pretrained().decide()
HTTP server (serve/)	NVIDIA GPU	Dynamic batching, keys, Prometheus metrics
llama.cpp / GGUF (Jeetu456/decider-2b-GGUF)	Any CPU, Mac	Q8_0 2.0 GB (38/38 agreement with the original), Q4_K_M 1.3 GB (35/38); runner in gguf/
Colab	Free T4	Same Python code
HF Inference Endpoints / RunPod Serverless / Cog	Hosted	handler.py, deploy/
SGLang / vLLM	–	Not supported (needs engine support for the decision head)

Input format

Field	Description
state	Any string or JSON value describing the situation (may be empty)
questions	Mapping of question ID to question (at most 128)

Each question has:

• type: noul (true/false), choice (named options) or score (ordered levels).
• instructions: what to decide. A string or any JSON value. Optional for choice and score.
• criteria: for choice, a mapping of option ID to description. For score, a list of levels from lowest to highest. None for noul.

Requests are never truncated. Questions that don't fit next to the full state in one 12,288-token pass are split across passes, and each pass repeats the full state. A request is rejected if it is over 65,536 tokens, or if the state plus its longest question is over 32,768 tokens.

Results

All numbers are our own runs on one RTX PRO 4000. The reports, every model answer, and the logs are in evals/.

Artificial Analysis Decision Index (estimated)

We reproduced the Artificial Analysis Decision Index methodology on the same public test sets. AA-Omniscience-Decision is private. Its two scores come from a stand-in: 2,000 MMLU-Pro questions in the same format (four answers plus "I don't know"). The index is therefore an estimate, not an official Artificial Analysis result. Other models' numbers are Artificial Analysis's published scores, read on 18 October 2026.

Evaluation	Decider 2B	Rank of 12	Best published
Decision Index (estimated)	58.6	2	65 (d1-ultra)
Omniscience-Decision accuracy (stand-in)	16.8	12	41 (d1, GPT-6 Luna)
Omniscience-Decision non-hallucination (stand-in)	90.4	1	85 (d1-ultra)
HLE multiple choice (accuracy, 513)	15.4	2	19 (Jev 1.14)
When2Call (accuracy, 3,423)	74.0	10	93 (d1-ultra)
WildGuardTest (average F1, 1,760)	91.5	6	95 (d1-ultra, GLiDE)

Published index scores for comparison:

Model	Index
d1-ultra	65
Jev 1.14	57
GLiDE	54
Microsoft-Decision-1	54
Decider v1.1 27B	53
Mercury Decide	53
Celeris-1	52
d1	50
Clef	49
GPT-6 Luna	48
Clef-Omni	44

Median latency is 84–89 ms per task (batch 1, one RTX PRO 4000).

Caveats.

• Our WildGuardTest keeps all 1,760 unanimous-agreement rows. AA also drops rows that trigger refusals, leaving 835, and that list is not published.
• The stand-in knowledge test is easier to abstain on than the real one may be.
• One of the two averaged fine-tunes descends from a run whose data was decontaminated against the AA test sets only after training, so some When2Call test questions may have been seen in training. All later training data was decontaminated before training.
• Decider is a 2B model: its knowledge accuracy is the lowest in the table. It scores well because it says "I don't know" instead of guessing, and AA weights non-hallucination equally with accuracy.

Decision Index kit 0.3 (6,000-request sample)

A fixed sample of 6,000 requests. The suite was rebuilt from the decision-index kit (commit 25c6ec7). Humicroedit (403 on download) and HLE are not in it, because HLE is scored above. The Clef-flash numbers come from its model card (suite 0.2.1), not from our run. Starred rows are decision & tool benchmarks.

Benchmark	Decider 2B	Clef-flash
*BFCL	95.8	98.8
*ToolRet	66.9	66.4
*API-Bank	62.5	93.1
*BANKING77	82.1	90.9
*CLINC150+OOS	83.8	66.8
*RouterBench	75.8	79.9
*Home appliance simulator	75.0	97.7
*SGD/SGD-X	92.3	34.2
*ContractNLI	43.4	84.3
*ANLI	41.2	59.1
*BRIGHT	31.2	39.3
*Amazon ESCI	38.0	57.4
*FinEntity	85.7	97.1
*PhishNChips	55.5	75.0
*HoVer	54.6	61.2
*When2Call MCQ	65.5	65.6
MMLU	57.5	91.8
MMLU-Pro	29.4	65.3
GPQA Diamond	27.5	51.0
ARC-Easy / ARC-Challenge	84.2 / 78.3	99.5 / 98.3
HellaSwag / WinoGrande	78.3 / 65.8	98.6 / 97.5
GSM8K	37.9	67.3
BBH fixed-option	49.6	68.9
CLadder	59.7	97.7
NLI4CT	63.0	78.6
RAGTruth	23.5	35.6
All benchmarks mean (40)	51.8	–
Decision & tool mean (16)	65.6	72.9

The full 40-benchmark table is in evals/decision-index/compare-clef-flash.txt.

Training

• Data: about 375,000 records in Jev format, from commercially licensed sources only (--policy commercial). They were decontaminated against the whole Decision Index suite and all four AA test sets, using 13-word n-gram overlap plus exact field matches. Every source and its licence decision is listed in training/licenses.json.
• Task coverage: routing, intents, moderation (WildGuardMix), tool use (When2Call, ToolACE, glaive), NLI and fact checking, knowledge with "I don't know", and tasks built in the benchmark shapes by training/data_tasks.py: BFCL-style tool yes/no, API-Bank-style tool catalogues, model routing profiles, SGD dialogue intents and smart-home policy.
• Recipe: LoRA rank 64 on all text linear layers of Qwen3.5-2B-Base, plus the decision head; cross-entropy plus 0.25 × Brier score; 12,288-token passes.
  1. Two fine-tunes of the same base: one on knowledge-with-"I don't know", safety and tool-reply data, and one on the full task pool with family-balanced sampling (each family drawn in proportion to size^0.5; train.py --family-alpha).
  2. Their merged weights averaged 50/50, heads included (training/blend.py).
  3. A 50,000-record LoRA top-up on that average (lr 1e-4, head lr 5e-4, family weights 2–4× on intents, When2Call, home, NLI, commonsense and safety; training/pod/release/train_topup.sh), then merged. Temperature 1.2 fitted on a held-out split.
• Hardware: one NVIDIA RTX PRO 4000 Blackwell (24 GB).
• Reproduce: training/README.md (setup, data, balanced fine-tune, evaluation) and training/pod/release/README.md (average, top-up, release).

Intended use and limits

Good for: fast, cheap, calibrated decisions inside an application. Examples are ticket routing, moderation gates, tool or agent step choice, intent detection, policy checks, and model routing.

Not good for:

• Open-ended answers or anything that needs text generation.
• Knowledge-heavy questions. Its accuracy on hard knowledge is low, and it abstains instead.
• Long legal contracts (ContractNLI 43) and adversarial NLI (ANLI 41).
• Very long tool catalogues compared with 9B+ models (API-Bank 62.5 against 93).

Other things to know:

• English-centric. Text only; no images.
• Safety classification is good (WildGuardTest F1 91.5) but not perfect. Don't use it as the only safeguard where harm is costly.
• Probabilities are calibrated on our held-out data. Re-check calibration on your own traffic before you set hard thresholds.

License

The model weights and code are released under Apache-2.0, following the base model Qwen/Qwen3.5-2B-Base.

The training data was restricted to commercially usable sources. These include:

• WildGuardMix (ODC-BY; check AI2's responsible-use terms)
• When2Call (CC-BY-4.0)
• ToolACE and glaive-function-calling-v2 (Apache-2.0)
• the Schema-Guided Dialogue train split (CC BY-SA 4.0, attribution: Google Research)
• BANKING77 (CC-BY-4.0)
• CLINC150 (CC-BY-3.0)
• MultiNLI

training/licenses.json lists every source and its decision. You are responsible for checking that these terms fit your use.

Citation

@misc{decider2b2026,
  title  = {Decider 2B: a 2B-parameter one-pass decision model},
  author = {Jeetu456},
  year   = {2026},
  url    = {https://huggingface.co/Jeetu456/decider-2b},
}

Thanks to the Qwen team for the base model, and to the authors of every dataset listed in training/licenses.json.