shisa-ai/decision-index-0.3-shisa-de-2

Decision Index 0.3: Shisa DE-2

Complete runs of shisa-ai/shisa-de-2 on the public Decision Index 0.3 suite, with every request's answer. The model was read through the shisa-de SDK and served by vLLM.

There are three runs of the same weights. They differ only in how the SDK asks each question.

Run	How each question is asked	Public index	Mean latency	Results
Adaptive (SDK default)	Shown twice; the model thinks first when unsure	59.01	770 ms	runs/shisa-de-2-adaptive
Repeat	Shown twice; never thinks	57.57	169 ms	runs/shisa-de-2-repeat
Single	Shown once; never thinks	54.64	102 ms	runs/shisa-de-2-single

Adaptive and Repeat are the two submitted runs. Single is here for reference.

Each run answered all 140,620 requests (140,178 scoreable) with no errors and nothing unsupported or truncated. The public index is 20% of the board's Full score; the maintainers run the private 80% themselves.

The three ways of asking

• Adaptive. The question is written twice in one prompt and the answer is read from the model's next-token probabilities. If the top answer's probability is under 0.7 and the question has at most 26 options, the model thinks for up to 1,024 tokens and is read again after the thought. This is what the SDK does by default.
• Repeat. The same doubled prompt, with no thinking step. One forward pass per question.
• Single. The question written once, with no thinking step. The fastest read.

Repeating the question costs little and adds 2.9 points over Single. Thinking adds another 1.4 points and about 4.5 times the mean latency, because it generates text: 13.0 million tokens over the suite against 0.3 million. Nearly all of the gain from thinking is in Knowledge & Reasoning.

Scores and latency

Run	Public index	Raw index	Breadth	Median	Mean	80th percentile	Generated tokens	Request time
Adaptive	59.01	68.68	58.18	47 ms	770 ms	332 ms	13.0M	30.1 h
Repeat	57.57	67.65	56.61	45 ms	169 ms	144 ms	0.3M	6.6 h
Single	54.64	65.62	53.42	35 ms	102 ms	79 ms	0.3M	4.0 h

Latency is per suite request, timed by the client with one request in flight per server. A request can hold several questions, and each is read separately. Request time is the sum over all requests. These are our own timings on our hardware, not the maintainers' latency measurement.

Area (weight)	Adaptive	Repeat	Single
Knowledge & Reasoning (25.8%)	48.9	45.2	41.1
Language Understanding (25.8%)	62.6	61.9	59.5
Retrieval & Classification (20.0%)	64.1	63.8	60.8
Tools & Automation (18.3%)	73.3	72.2	71.1
Arts & Human Taste (10%)	39.6	39.4	34.5

All benchmarks

Chance-corrected skill, 0 to 100, as the kit's index.json reports it.

Benchmark	Adaptive	Repeat	Single
Knowledge & Reasoning
GPQA Diamond	29.2	25.2	24.5
GSM8K	81.9	70.1	66.3
ChessBench	13.6	13.8	11.3
MuSR	51.2	48.8	43.3
SATA-Bench	30.9	30.5	30.3
CRUXEval	76.3	69.7	58.5
CLadder	52.8	49.6	42.7
HLE	0.0	0.0	0.0
MMLU-Pro	69.0	62.4	60.4
BBH fixed-option tasks	70.5	65.5	62.2
WinoGrande	64.8	63.4	53.9
Language Understanding
ContractNLI	62.3	62.2	63.4
ANLI	67.6	66.1	59.4
HellaSwag	85.0	84.3	82.0
ACOS	27.5	27.6	24.8
FinEntity	88.6	87.5	86.0
iSarcasmEval	54.8	53.0	51.2
VAST	58.0	56.2	54.1
NLI4CT	61.3	62.4	58.9
RAGTruth response-level hallucination	52.6	52.1	51.6
Retrieval & Classification
BANKING77	84.2	84.2	83.3
CLINC150+OOS	84.4	84.4	83.7
BRIGHT	37.4	37.4	37.7
Amazon ESCI	42.2	41.3	38.2
PhishNChips phishing decisions	72.0	71.6	68.2
HoVer claim verification	61.5	61.1	49.3
Tools & Automation
BFCL	95.0	95.2	94.0
ToolRet	56.9	57.7	58.9
API-Bank	85.8	85.8	86.0
Home appliance simulator	47.7	40.9	40.9
When2Call MCQ	74.1	73.8	68.1
Arts & Human Taste
BPoMP	84.9	83.4	81.4
Humicroedit	26.2	25.3	24.7
POP909-CL	13.8	13.8	3.3
cfcolor	24.3	24.0	22.4
Habermas Machine	25.5	24.6	20.4
New Yorker caption matching	63.1	65.0	54.8
Scored, not counted
RouterBench	53.0	53.0	52.8
SGD/SGD-X	0.0	0.0	2.6
MMLU	80.2	78.7	76.1
ARC-Easy	98.8	98.6	98.4
ARC-Challenge	96.1	95.9	94.4
SimpleBench	16.0	16.0	4.0

What is in each run folder

File	Contents
scores.json	The public index, area scores and per-benchmark scores. The file a submission points at.
index.json, benchmark-summary.json	The index breakdown and each benchmark's native metric.
results.jsonl.gz	One line per request: the answers with their probabilities, token usage and timing. No benchmark text.
environment.json, environment-shard1.json	Engine options, policy, readout version, serving details and a SHA-256 of every SDK source file, one per shard.

Setup

Model	shisa-ai/shisa-de-2, merged BF16 weights
Server	vLLM 0.30.0, vllm serve shisa-ai/shisa-de-2, no other options; 262,144-token context
Hardware	NVIDIA RTX PRO 6000 Blackwell (96 GB), one per server
SDK	shisa-de v0.4.0, readout de2-codebook-v1, raw probabilities (calibration off)
Kit	apolinario/decision-index at 62d2f51, edition 0.3
Dates	2026-10-08 and 2026-10-09

Each run was split round-robin across two servers, one sequential process each, and the two halves were concatenated before scoring. All three runs use the same v0.4.0 client code. The engine file gained its policy option between the Adaptive run and the other two; each environment.json records the hashes of the files it ran.

Reproduce

You need a GPU that holds the model with its full context, vLLM 0.30.0, and Python 3.10 or newer.

1. Install the SDK and the kit.

git clone https://github.com/shisa-ai/shisa-de
git clone https://github.com/apolinario/decision-index
git -C decision-index checkout 62d2f51

cd shisa-de
python -m venv .venv
.venv/bin/pip install -e . -e "../decision-index[rebuild]"

2. Build the suite. The kit rebuilds it from pinned sources rather than redistributing it (about 7 GB of downloads; accept the HLE terms first).

export HF_HUB_DISABLE_XET=1
.venv/bin/python -m decision_index suite rebuild --work work
.venv/bin/python -m decision_index suite import \
    --rows work/artifacts/benchmark-suite/release-v2-rebuilt/selected-rows.jsonl.gz \
    --added-rows work/artifacts/benchmark-suite/release-v2-rebuilt/added-rows.jsonl.gz \
    --gsm8k-rows work/artifacts/benchmark-suite/release-v3-rebuilt/gsm8k-rows.jsonl.gz

3. Serve the model.

CUDA_VISIBLE_DEVICES=0 vllm serve shisa-ai/shisa-de-2 --host 127.0.0.1 --port 8026

4. Run and score.

.venv/bin/python scripts/decision_index_run.py \
    --suite-dir suite-0.3 \
    --endpoint http://127.0.0.1:8026 \
    --policy repeat-think \
    --out runs/shisa-de-2-adaptive

Use --policy repeat for the Repeat run and --policy direct for Single. Pass --endpoint once per server to split the work, add --limit 20 for a quick check, and re-run the same command to resume. scores.json appears in the run folder at the end.

On two servers the runs took about 15 hours (Adaptive), 3.3 hours (Repeat) and 2 hours (Single). Scores can move slightly between server launches, because vLLM's probabilities are not bit-identical from one launch to the next.

The engine is scripts/decision_index_engine.py, and docs/DECISION-INDEX.md describes what it does with each question.

Use the SDK yourself

pip install shisa-de
vllm serve shisa-ai/shisa-de-2

from shisa_de import DecisionModel

with DecisionModel.from_endpoint("http://127.0.0.1:8000/v1", model="shisa-ai/shisa-de-2") as de:
    labels = {"intent": ["spam", "ham"]}
    text = "WINNER! Claim your free prize now!"

    de.classify(text, labels)                    # Adaptive, the default
    de.classify(text, labels, reasoning=False)   # Repeat
    de.classify(text, labels, reads="single")    # Single

The same settings can be given to DecisionModel to change the default for every call. The SDK's README covers them, and READOUT-DE2.md is the exact contract.