ML-Intern-lab/typed-decisions-benchmark

Typed-Decisions benchmark results

Accuracy and speed of decision models on the LocalLLaMA/typed-decisions benchmark. Two runs live in this repo: the large open-weights "System 1" decision models below (this run), and an earlier pass over small specialist models (bottom section).

Run: large decision models (1×A100-80GB, 2026-10-13)

The three highest Decision Index open-weights decision models on the Hub at benchmark time: autotrust/GEV-26B-Decide (DI 62.48), perplexity-ai/pplx-decider-v1.1-27b (DI 61.56) and autotrust/JEV-35B (DI 59.73), per their model cards.

Setup: config all, test split, 400 cases × 5 typed questions = 2,000 decisions, one decision per request, sequential, client-side latency. Each model is driven through its native API: GEV-26B and JEV-35B via POST /v1/decide on each repo's bundled serve_decide.py (vLLM 0.31.0; GEV additionally patched for Gemma-4 lm_head LoRA, see scripts/apply_gemma4_patch.py), pplx via its bundled DecisionModel (transformers 5.17.0, saved noncausal attention mode + calibration temperature). Question text carries the per-option criteria descriptions; score questions are sent as a choice over the rubric's level labels so all three models produce comparable distributions. Scoring: argmax accuracy, KL(gold‖pred), per-decision Brier, ECE (10 bins).

model	params	accuracy ↑	KL(gold‖pred) ↓	Brier ↓	ECE ↓	p50 (ms)	p95 (ms)
autotrust/GEV-26B-Decide	26B MoE (≈4B active)	0.7210	0.322	0.123	0.028	40	57
autotrust/JEV-35B	35B MoE (≈3B active)	0.7295	0.409	0.147	0.045	113	117
perplexity-ai/pplx-decider-v1.1-27b	27B dense	0.7315	0.466	0.165	0.085	142	175

References from the benchmark card: Prior (ignores input) 0.470, teacher self-agreement ceiling 0.735, hosted TypeSafe Jev 1.13 zero-shot 0.727 (different request protocol, not directly comparable). All 2,000 decisions per model returned valid distributions (0 errors).

Accuracy by question type

model	noul (n=600)	choice (n=600)	score (n=800)
GEV-26B-Decide	0.815	0.693	0.671
JEV-35B	0.833	0.702	0.673
pplx-decider-v1.1-27b	0.832	0.680	0.695

Accuracy by workflow

model	agent_trace	customer_service	invoice_processing	security_incidents
GEV-26B-Decide	0.612	0.792	0.794	0.686
JEV-35B	0.656	0.812	0.734	0.716
pplx-decider-v1.1-27b	0.634	0.794	0.748	0.750

Takeaways

• Accuracy is a three-way photo finish (0.721–0.732), all just under the 0.735 teacher self-agreement ceiling and above every open-weights row in the benchmark's zero-shot leaderboard. The three models disagree per workflow: GEV is weakest on agent_trace, JEV on invoice_processing, pplx on agent_trace.
• GEV-26B-Decide is the calibration and speed standout: best KL (0.322 vs 0.409/0.466), best Brier and ECE by a wide margin, and a 40 ms p50 — 2.8× faster than JEV-35B and 3.5× faster than pplx, despite JEV/pplx both scoring ~0.01 higher on argmax accuracy.
• Latency ordering matches active parameter counts, not total size: 4B-active MoE (GEV) < 3B-active MoE (JEV) < 27B dense (pplx), all on one A100-80GB.
• Live metrics for this run: trackio dashboard.

Caveats

• Latency is single-request sequential client-side on an idle A100 — relative speed only, not a serving benchmark. GEV's server ran with thinking off (System 1 only).
• The benchmark's hosted leaderboard sent all five questions in one request; our protocol is one decision per request (the shape all three open models natively support), so numbers are comparable across these three but not exactly with the hosted table.
• Gold is a soft 3-sample teacher distribution; KL/Brier reward matching its spread, not just the argmax.
• GEV was served with a content-based port of the repo's lm_head-LoRA patch (scripts/apply_gemma4_patch.py), since the bundled patch targeted a Sept 2026 vLLM dev build rather than the 0.31.0 release.

Files (this run)

• results/autotrust__GEV-26B-Decide/{full.jsonl,full.metrics.json,smoke.metrics.json}
• results/autotrust__JEV-35B/{full.jsonl,full.metrics.json,smoke.metrics.json}
• results/perplexity-ai__pplx-decider-v1.1-27b/{full.jsonl,full.metrics.json,smoke.metrics.json}
• scripts/scorer.py, scripts/run_eval_server.py, scripts/run_eval_pplx.py, scripts/apply_gemma4_patch.py — the exact harness

Reproduce

# GEV-26B / JEV-35B: vLLM 0.31.0 + the repo's serve_decide.py on an 80GB GPU
hf download autotrust/GEV-26B-Decide   # or autotrust/JEV-35B
bash <model_dir>/serve.sh              # GEV: apply scripts/apply_gemma4_patch.py to vllm first
python run_eval_server.py --url http://127.0.0.1:8000 --model-name <repo-id> --out-prefix out

# pplx: transformers 5.17.0 + the repo's bundled DecisionModel
python run_eval_pplx.py --out-prefix out

---

Earlier run: small specialist models (single T4)

Accuracy and speed of three open "typed decision" classification models on the LocalLLaMA/typed-decisions benchmark — config all, test split, all 400 cases × 5 typed questions = 2,000 decisions. Every model answers the same cases in its own native input format; answers are scored argmax-vs-gold-label plus Brier score against the gold distributions.

Run 2026-10-13 on a single Nvidia T4 (t4-small), fp32, per-case sequential calls (no batching).

model	params	accuracy ↑	Brier ↓	mean latency (ms/case)	p95 (ms/case)	decisions/sec
convaiinnovations/laya-typed-decisions	421M	0.767	0.062	122	174	41.0
mrm8488/embeddinggemma-2-ft-typed-decision	272M	0.764	0.065	670	1116	7.5
ai-forever/FRIDA-Decisions	823M	0.406¹	0.417	181	225	27.6

Reference points from the benchmark's own write-ups: random guess ≈ 0.318, majority class ≈ 0.461, TypeSafe Jev (commercial) ≈ 0.727–0.897 depending on split/protocol.

¹ FRIDA was additionally run with the state fed as raw JSON instead of flattened key: value lines: accuracy 0.413, Brier 0.398 (results/frida-jsonstate/). The rendering is not the problem — see caveats.

Accuracy by question type

model	choice (n=600)	score (n=800)	noul (n=600)
laya-typed-decisions	0.733	0.724	0.857
embeddinggemma-2-ft-typed-decision	0.712	0.739	0.848
FRIDA-Decisions	0.342	0.329	0.573

Takeaways

• The two models fine-tuned on this benchmark's training split are near-identical on accuracy (0.767 vs 0.764) and both land almost exactly on their published numbers (0.766 and 0.764 respectively), which is a good sign the evaluation harness is faithful. laya is ~5.5× faster per case on this hardware and has the best calibration (Brier 0.062).
• FRIDA-Decisions does not transfer to this benchmark out of the box (0.406, near the 0.318 random-guess floor). Its predictions are confidently wrong rather than uniform, and trying a different state rendering did not help. It was trained on Russian natural text (razvilka, 0.893 there); this benchmark is English synthetic workflow states, so this is an out-of-distribution result, not a decoding bug. Treat it as "FRIDA needs domain adaptation for this kind of input", not "FRIDA is a bad model".

Caveats

• laya ships with an out-of-range temperature for choice questions with ≥11 options and warns that affected confidences are uncalibrated (its own card documents this; accuracy is unaffected).
• The embeddinggemma checkpoint's card notes its hyperparameters were chosen while looking at the test split, so 0.764 is slightly optimistic.
• All gold labels come from annotator majority; many rows are near-ties (the benchmark's soft labels set a ceiling well below 1.0).
• Latency is single-request sequential on a T4 — relative speed, not a serving benchmark.

Files

• results/run/<model>/metrics.json — headline + per-type metrics per model
• results/run/<model>/predictions.jsonl — every per-question prediction (gold, predicted, probabilities, Brier)
• results/run/summary.json — one-file summary of the run
• results/frida-jsonstate/ — the FRIDA JSON-state A/B variant
• code/benchmark.py — the exact evaluation script used (also re-runnable: python benchmark.py --device cuda)

Reproduce

pip install torch==2.14.1 transformers==5.19.0 datasets==5.1.0 laya==0.4.6 \
  "frida-decisions[torch] @ git+https://github.com/ai-forever/FRIDA-Decisions@v0.4.0" huggingface_hub
python benchmark.py --device cuda          # full 400-case run, uploads results
python benchmark.py --limit 8 --device cpu --no-upload   # quick check