Awesome System One Models

A list of System One models, a class of AI models built to make fast, structured decisions (also called decision models). Jev from TypeSafe was the first. This list covers it, the open and hosted alternatives, and the agents, tools, SDKs and benchmarks built around them.

A System One model doesn't write text. You hand it some state and a few typed questions, and it answers with a choice, a score, or a yes/no probability. There's nothing to parse, and it's fast and cheap enough to sit in front of routing, classification, verification and agent supervision. A sibling class is forming next to the decision models — extraction models, which answer with typed values pulled or predicted from the input instead of choices. The wider System 1 / System 2 literature — cascades, routing, dual-process agents — is lineage rather than membership, and lives under Reading. The name comes from Kahneman's System 1.

Prefer a web version? Visit system-one-models.com to search and sort the list, with stars and growth for each entry.

Contents

• Models - Call a hosted model. Jev for the original API, CLM or Laya for open weights, Clairic for extraction.
• Serving & runtimes - Run one locally, or turn any open model into one, without new training.
• Applications - Agents that act, and the tools that plug a System One model into other software.
• SDKs & Adapters - Calling from application code.
• Baselines - Want a cheaper classifier first. Same job, different interface.
• Evaluation - Compare models, evaluate your own, know the failure modes.
• Reading - The psychology the name comes from.

Models

Trained for the job — state in, typed answers out. Hosted or open weights.

Open weights

• agent-jev - AgentJev-0.6B: a small trained decision model that takes unstructured state (diffs, traces, logs) and returns calibrated distributions in one ~50 ms forward pass. Apache 2.0.
• Ainvest-Decision-27b - Text-only decision model on Qwen3.8-27B scoring options through a custom 255-way readout with last-token pooling and noncausal full-attention layers — evaluated as an M02 weight merge, 26B stored params in BF16. #15 on the Decision Index's Nov 6 draw (68.23); the card is precise about what its numbers are ("existing public-run scores, not a maintainer-assigned Full score"), ships publication validation (zero choice flips on a fixed 100-request sample), and credits tasksource for much of the gain. Prompts over 16,384 tokens per question are refused, never truncated. Apache 2.0 with the full inference package in-repo.
• basal-omni-1.0-ultra - Polish–English decision family on Gemma 4 (31B ultra, 12B max) with its own basal engine: up to 255 options, choice / noul / score plus tool (picks the tool from OpenAI or MCP definitions, not the arguments), act, and multi, on /v1/systemone. Trained on ~640K PL/EN decisions distilled from basal-1.5, shipping per-type temperatures and certified confidence thresholds in the weights — the card publishes coverage at 1% target error, an option-order flag, an FP8 build, and zero-shot images through Gemma's encoder with honest probes of where image answers break. JevBench's October board ranks ultra #4 official among 192 open systems (71.7, above the Jev 1.13 reference). Apache 2.0.
• Chon-1.0-12B - Vietnamese–English LoRA (~1 GB) on an unmodified Gemma-4-12B-it: choice (2–16 options), yes/no, and score, served on the TypeSafe wire by the chon package. The card is honest that most decisions are one pass but some take a short extra pass (p95 23.5 s) — and on JevBench's Nov 3 re-measure that honesty aged badly: the 12B fell from #26 to #168 on the official composite (14.2), while the family's new Chon-1.1-31B now leads it at #23 on the Decision Index's Nov 6 draw (67.54). Own 720-item held-out replica published. Apache 2.0.
• Clef - Cloudflare's open decision-model family, Apache 2.0: frozen Qwen backbones with a trained routing head, prefill-only non-autoregressive scoring. Clef (27B) and Clef-flash (9B) take text + image with a 64K context; Clef-omni (Qwen3-Omni 30B-A3B MoE) adds native audio and video — a 21 s clip with sound scores in ~1.5 s, text in ~130 ms. Clef's October runs put it first on the Jev Decision Index for a time; on the Nov 6 draw it sits #89 (54.92) with the open fine-tune wave well past it, while Jev and Laya still lead some tasks. Hosted on Workers AI — Clef-flash at $0.038/M input undercuts Jev — with an RL fine-tuning platform, in production on Threat Intelligence.
• CLM - Contrastive Language Model: dual state/action encoders (frozen Qwen3-8B + 20M heads) where candidates embed once and cache, rather than re-reading the state. Apache 2.0, TypeSafe wire-compatible. Claims Jev parity on computer-use, gaming, and tool-calling at up to 9× lower latency, plus SOTA held-out verifier results (Terminal-Bench 2.1, DeepSWE).
• Cua-S1 - Research stack for small specialist computer-use models. First checkpoint is form-oriented: cua-s1-forms, a 706K-param option scorer with its training dataset on Hugging Face. Planning and execution stay separate.
• d1 - Liquid AI's open decision-model family: d1-3B (text + vision, from LFM2.5-VL), d1-omni-600M (adds audio), and a late-October d1-2B on LFM3-VL with real traction for its age (~6K downloads in its first week). Single forward pass; on the Decision Index's October draw d1-3B scored 48.57 on the public split — best under 10B that week, on par with Decider 35B-A3B at 12× its size — at ~8 ms on an RTX 4090, 16 ms on Jetson AGX Thor (the family is absent from the Nov 6 board). Open weights and GGUF builds on Hugging Face; also hosted, and JevBench's v1.8 API board ranks the new, larger d1-ultra #5 of 49 (76.0) with d1 itself #13 — d1-ultra also tops Artificial Analysis's Decision Index (65).
• d3 - The vLLM-SR org's flagship line (promoted from the Vela entry — the two are different products): d3-ultra (27B) and siblings span text, JSON, images, and video with choice, noul, ordinal, box grounding, and track outputs — the interface extended into visual grounding and object tracking. Multiple JevBench top-20 regulars (d3-turbo #6 capability) and top JDI placements (d3-ultra #7, d3-turbo #25 on the Nov 6 draw); served through the org's own vLLM fork, not stock vLLM. Apache 2.0.
• decider - Qwen3.5 fine-tunes (0.8B up to a 35B MoE), a Gemma-4-12B variant whose v2 ranks #27 on JevBench's official open-weights composite (73.7), and training-free readouts of larger chat models; Apache 2.0 weights on Hugging Face. Serves TypeSafe /v1/systemone, so the official SDK works by repointing TYPESAFE_BASE_URL.
• Decisio - Open decision family on Gemma 4 (12B and 31B, v0.8 / v0.9): its v1.6.1-era peak — #3 of 192 on JevBench's official composite, 71.69 tying Jev and Quyet inside overlapping intervals, leading Jev on sealed-set intelligence 73.3 vs 61.6 — did not survive the re-measures; the Nov 3 board has the 12B at #59 of 235 (70.1) and the 35B-A3B down at #137 (27.2). Answers 50 questions on a 3K-token doc in ~1.1 s by evaluating questions in batch rather than decoding per-question, about 40x faster than the letter-readout families. 58.55 on Decision Index 0.3.2.
• dohnuts - PsiACE's small multimodal decision models: choose, judge, or score over a message, document, or image in one forward pass, with multiple questions sharing the same input. The Python toolkit covers training, inference, eval, and agent integration; ships a 0.8B model for a consumer GPU. Apache 2.0.
• Drex - Nace.AI's decision models: v2.0 on a Qwen3.6-35B-A3B MoE with a Kev pointer head — claims 60.9% head-to-head against Jev in their eight-game arena — plus v1.5 on a distilled Qwen3.5-9B and a DLM diffusion build, each serving /v1/systemone three ways: Python/vLLM, a llama.cpp GGUF fork, or Ollama. Weights carry Nace's Open RAIL-M license (not Apache; check commercial terms), and Nace also hosts the API at $0.05/M with a 131K context — the Max tier ranks #7 on JevBench's v1.8 API composite (75.4, I 79) at $0.031/1k.
• FlexDM-LoRA 2.1 - The adapter-is-enough entry: a 4 GB LoRA (r128, the exact average of two seeds, applied at strength 0.7) on an unchanged Gemma-4-31B-it, served unmerged in vLLM over FP8 — no full fine-tune, no custom runtime. The reader lists every question before the state, reads short requests twice, and re-reads low-confidence answers with options reversed; the readout is the option-label logits at Answer: (. #4 on the Decision Index's Nov 6 draw (71.61, listed in the #2 tie group), with the highest new-domain score of any single model (79.92 — only the REAX ensemble is higher) and +4.05 Full over the same reader untrained (#22); the card publishes the 34-task private breakdown, calibration (77.9% accuracy, ECE 0.054, Brier 0.305), and full decontamination. CC BY-SA 4.0.
• FRIDA-Decisions - SberAI's Russian-first encoder decision model: choice / score / noul plus a ranking question type, all questions scored in one packed encoder pass with an exact state cache. Torch, int8 ONNX, MLX, or vLLM.
• GEV-26B-Decide - AutoTrust's adaptive-thinking decision model on Gemma-4-26B-A4B: System 1 answers in one ~45 ms pass, and when its leading option falls below 0.8 confidence the unmodified base thinks in Gemma's thinking mode and its answer distribution is folded 50/50 into the result — one set of weights, text and images. Own scoring puts it at 62.48 on Decision Index 0.2.1 vs Jev 1.13's 57.9, and with zero robot training data its thinking mode scores 56.8% on DeepMind's ERQA, above robot-trained VLMs; computer use runs at 85 ms per click (95% of 60 tasks). The sibling AutoTrust-JEV-27B v1.1 is the family's board leader at #18 on the Nov 6 draw (67.95), with JEV-27B-VL and JEV-9B trading speed for embodied precision, and the GuruSearch demo running every ranking as a calibrated decision. Apache 2.0, vLLM, ~1.1M downloads.
• GLiNER2.5-Decide - Decision specialist from the GLiNER team: any label set at call time — intent, routing, multi-label tags, ordinal scores — answered in one forward pass with no generated tokens. Apache 2.0, in 340M / 1B / multilingual builds. Claims 60.2% vs JevK5's 57.6% on Fastino's own 17-domain suite; on JevBench's harder multi-step items it scored near chance — a 340M classifier built for simpler task shapes.
• GUI-Decisions - GUI grounding as a decision instead of generation: a fixed slot template (action, x, y, x2, y2, ...) read from next-token distributions, with coordinates as 256-bin labels rather than decoded JSON digits. ~150 ms per computer-use step on Gemma 4 31B, about 3x faster than the same model writing JSON. LoRA training code plus 2B and 31B weights on Hugging Face.
• H2O-Lightning-4B - H2O.ai's multimodal decision family: the 4B on Qwen3.5 (text plus record images, one pass per decision, runs on unmodified vLLM behind a stdlib shim) and a new 31B on Gemma-4-31B-it (v1.0.7, FP8, one-engine overlay) that ranks #4 on JevBench v1.8's open capability view (84.3, I 79.3) and #7 official. The 4B topped the v1.6.1 composite when the board held 76 systems; the family has stayed top-ten through every reshuffle since. Apache 2.0, live ZeroGPU demo on HF Spaces.
• Intern-Decision - Shanghai AI Lab's multimodal decision family (internlm org): 0.8B / 2B / 4B on Qwen3.5, returning an answer distribution per question in one forward pass over text and images. Apache 2.0, with a GitHub training stack, an HF Spaces demo, and a community CoreML port.
• Jebadiah v2.1 - Frontier Infra's LoRA pair — 27B on Qwen3.8, 9B on Qwen3.5 — assigning a probability directly to each option. Apache 2.0 with GGUF and MLX builds, and unusually honest reporting: Decision Index 0.4.1 puts the 27B (T1e recipe) at 64.4, tied 6th, and the 9B at 50.9 at 125 ms median latency — while the author notes the gains over v2 are not shown significant and When2Call declined. The 9B is the calibration pick.
• Jeffan-31b-1710 - Full Gemma-4-31B fine-tune now sitting #10 on the Decision Index's Nov 6 draw (69.75 Full; it was #2 on the late-October draw at 73.13), with a dated-checkpoint naming scheme (Oct 17) and a 4B sibling. Apache 2.0. No public write-up yet — the board placement is the story.
• Jev-Omni - Multimodal decision classifier on Gemma 4 12B: text, image, audio, or video in, a probability per option out. Apache 2.0 weights. One question per call, best under about 20 options. Topped Image JevBench's original pool; on the rebuilt v0.3.0 it sits mid-board (54.3 capability, 13th under the Jev-class caps).
• Jeva - NUS research model built for the failure modes letter-readout models inherit: a set-native architecture encodes each candidate independently against an immutable option memory, so representations are request-independent and reusable, decisions are permutation-stable (zero flips under candidate reordering, against 17–23% for comparable open models), sets scale to 2,048 options, and an explicit null probability separates "none of these applies" from uncertainty (98.66% null-detection AUROC). 4B checkpoint and code, Apache 2.0; the paper frames it as System One models from first principles.
• JevEmbed - HIT-TMG's recipe for turning an embedding model into a decision model: choice / score / noul heads over your pick of embedder, with a Hugging Face model collection and dataset. Apache 2.0.
• JevK5 - Open-weight Jev alternative (4B and 9B, Apache 2.0) serving /v1/systemone at about 13 ms on an H100. JevBench v1.4 ranked v0.2 second of 76 systems and first open entrant, though the project itself reports Jev edging it on 308 fresh sealed items. Two-teacher distillation, pre-registered epoch sweeps.
• jevlike - Train a small one-pass scorer over a changing list of text options. Each option queries the context; a shared head returns one probability per option. Byte encoder from scratch, or a frozen Hugging Face encoder.
• jevos - MiniCPM5-1B cut to 17 layers with a one-logit head, quantized to GGUF and run on CPU via llama.cpp. Serves TypeSafe /v1/systemone for noul (yes/no) questions only, so the official SDK works by repointing TYPESAFE_BASE_URL. MIT.
• jiwo - Small trained decision models on Qwen3.5 (0.8B and 4B) serving /v1/systemone at ~50 ms on one H100. jiwo-0.8b once ranked #1 of 27 under 1B on the Decision Index board; on the Nov 6 draw both v2 models sit low (the 0.8B at #209) with GLiDE 0.8B now leading the sub-1B bracket. Apache 2.0.
• julia-1 - Supersonic Labs' 144M decision model on the multilingual mmBERT-small encoder: state + question + 2–20 options, choice / score / noul with probabilities, on CPU. Real traction for its size: the HF card plus the ggml-org GGUF mirror total about 13K downloads.
• kev - LoRA plus a pointer readout, versioned as Kev 1.0 in four sizes from a laptop-friendly 0.8B to Kev-27B on Qwen3.8-27B (#61 on the Decision Index's Nov 6 draw at 59.56, up from 52.3 as v2 checkpoints landed). Apache 2.0, with training code and frozen eval suites. TypeSafe /v1/systemone drop-in, calibrated by default via a fitted temperature. Its frozen evals put Kev-27B within a point of Jev on unseen sources (0.851 vs 0.857 Brier); MLX, ROCm, CUDA, and a one-command Modal deploy. Also the only open-weights route on OpenRouter's Decisions API.
• Kev-Bio - "Every pixel is an option": medical ultrasound biometry rebuilt as System One decisions — clinical measurement questions generate queries for each caliper endpoint, matched against dense ultrasound features into spatial probability maps from which landmark coordinates and measurements fall out (MRE 22.50 px, measurement MAE 15.38 on the nine-view FU/GU Biometry 2026 set, beating specialist heads). No relation to kev above — the name is a collision; the pattern is decisions applied to spatial grounding. Code and models open.
• KnowLine 31B-Gen1 - PelaAI's Gemma-4-31B-it fine-tune, tied for the top JevBench v1.8 capability score (85.2, I 77.4, C 93.0 — statistically level with mammoth-1) and now #3 on the Decision Index's Nov 6 draw (71.91); ranked #83 on JevBench's official composite: at $0.061 per 1,000 decisions it sits at 1.88× Jev's cost cap, so what it buys with the size is intelligence, not efficiency. Grew into a family — Gen1.5 35B-A3B at #33 (65.77) and a Gen2.5 26B-A4B at #40 on the same draw. Apache 2.0.
• Laya - Multilingual, non-autoregressive decision engine. Typed choice / score / noul over 100+ languages in a single forward pass (about 33 ms on a T4). Router across English, multilingual, and typed-decisions checkpoints. Apache 2.0.
• liquamen - Anonymous solo line (plantwaterer) whose rigor outclasses most org releases: a uniform average of two post-training branches on Gemma-4-31B-it with a Bayesian last-layer head (letter softmax at one fitted temperature; a Laplace-posterior correction for yes/no), mammoth-style prompt-bidirectional full-attention layers, and cyclic Latin-square option-order averaging for 5–52 options. #11 on the Nov 6 draw (69.14) with the sibling oenogarum at #16. The card's self-audit found one training item duplicating a test question and scores it wrong; data attribution lists all 40+ sources with licenses. Apache 2.0.
• Lumma-Fev-27B - FrontiersMind's full fine-tune of Qwen3.8-27B (~100K decision samples) for English, Hindi, Tamil, and Kannada — the first Indic-language entrant in the class. A dedicated output head scores options directly; the card reports 90.7% vs Jev 1.13's 83.9% on its held-out set with calibration error 0.009 vs 0.045, and is honest that Jev still wins BBH and WinoGrande and that score questions are untested. Apache 2.0, lumma-fev pip package, ~49 GiB in bf16.
• mammoth-1 / elephant-1 - Base Labs (Baseten) full fine-tunes of Qwen3.5-27B and -9B, MIT weights, with a joey-1 2B sibling (text + image, provider-advertised $0.01/M and 20 ms p50) now completing the size ladder. The architectural move: block-bidirectional attention on Qwen3.5's full-attention layers (the GDN layers stay causal), so each question encodes knowing its own options while the state prefix stays cacheable across questions — worth +3.8 Decision Index points over the causal mask at fixed data, and the report notes Perplexity's Decider v1.1 applies a similar change. Trained in a week on 6.21M examples (cross-entropy plus a Brier term, and uncertainty-aware abstention rows that add an "I don't know" option and drop the correct answer), with the full eight-mix data evolution published: 45.5 → 74.0 on the public split. mammoth-1 led the Jev Decision Index at 75.34 on the Oct 29 draw (#1 of 247) and still leads JevBench v1.8's open capability view at 85.2, but the Nov 6 draw (edition 0.4.1, private-test reweighting) drops it to #13 of 274 (68.44) under REAX 1.3 — an ensemble whose Q-part blends a mammoth descendant; elephant-1 ties d1-ultra at 65 on Artificial Analysis's Decision Index.
• NanoJev - 0.6B replica trained from scratch, MIT. Ships the weights, the dataset, and the end-to-end training pipeline, plus a side-by-side demo against Jev.
• NeuDecide - Neuphonic's ~40 MB voice-action model: speech in, an action decision out, running entirely on WebAssembly in the browser. From the neuTTS/neucodec audio lab; model repo is gated, the Space is the public demo.
• Nimble - Qwen3.5-9B LoRA from Bespoke Labs. Contrastive recipe, not distilled from Jev. 90% vs Jev 93% on a 324-example holdout. Now also served by Bespoke as an API: October's price cut to $0.04/M input put Nimble-v4-max #8 on JevBench's v1.8 API board (74.8), and the open-weights Nimble v4.1 Max sits #8 on the Decision Index's Nov 6 draw (70.03).
• OneJev - Multimodal decision family from the PlayJev authors: calibrated probabilities over screenshots, photos, video, and text in one forward pass, in 0.8B / 4B / 9B / 27B sizes. Apache 2.0 weights plus a Hugging Face dataset, with published comparisons against Jev 1.13 and Jev-Omni.
• Open Jev - 150M ModernBERT encoder that answers per-request noul / choice / score questions in one pass. Trains on a Colab T4 in about 30 minutes. Not the same project as SemIf, which was also once called OpenJev.
• openJev-verdict-2.0 - 151M ModernBERT decision engine, non-autoregressive, with published calibration numbers. Claims the top spot over Jev and Laya on the LocalLLaMA typed-decisions benchmark.
• Phocinae - Largha-150M: a 144M bilingual decision model on mmBERT-small (English-first, Chinese evaluated on translated cases). Calibrated noul / choice / score answers robust to option reordering, one pass per decision.
• Piccolo-27B - AgentScope's (Alibaba) decision model built for tool review and context selection, with bidirectional attention and a reference implementation in-repo — the production-flavored end of the class, wired into the QwenPaw agent stack with a live Decision Playground. #14 on the Nov 6 draw (68.40); the card's own suite puts it at 84.4% on HarnessJevBench Hard and 82.6% on DataJevBench. Bilingual English/Chinese, Apache 2.0, ModelScope mirror.
• PlayJev - 0.8B multimodal Jev-like model that plays GUI games directly from raw pixels. Apache 2.0.
• Quyet - Open five-size family (Tiny to a 31B Large) on Gemma 4: merged LoRA plus a letter-readout decision prompt with fitted temperatures. TypeSafe /v1/systemone answers via the quyet Python package; English and Vietnamese, Apache 2.0, GGUF builds. The speed runner-up in Microsoft's Decision-1 benchmark post.
• REAX 1.3 - The first decentralized-trained leader: a Bittensor subnet-92 lab where miners compete to train decision models and releases build on the best of them. REAX 1.3 runs two parts in parallel on one GPU (FP8, ~115 GB of weights): Part G blends a miner's Jeffan-31b fine-tune with KnowLine-31B, Part Q a miner's mammoth-1 descendant with d3-ultra, their per-option probabilities averaged 50/50. #1 on the Decision Index's Nov 6 draw (73.98) — an ensemble of the open wave's best ingredients, and the card is honest about what that means: its own CI-bearing comparisons, a "not official leaderboard scores" label on its measurements, and per-contributor attribution for every blended weight. Apache 2.0 with the full upstream license chain preserved.
• ReJev - Independent reproduction of Jev-style post-training on MiniCPM5-2B via LoRA: 51% → 80.5% on a sealed, leakage-checked holdout for about $5 of compute. Stage 1 covers single-letter choice only; the rigor is the point — significance testing, baselines, and a technical report that voids its own figure after finding contamination. MIT.
• RSI-Jev - Recursively self-improving research loop that trains the models: AI agents propose hypotheses, register predictions before spending GPU time, and retire their own champions on the evidence. Eight releases in 13 days, 496 published experiments including failures; v6.1-VL 27B posts 65.64 on the Decision Index 0.3 public set, the top listed score. MIT code, Apache 2.0 weights, Jev-compatible API.
• Sarvam Prism - Sarvam AI's 105B-parameter MoE (10B active) adapted for typed decisions — the largest decision model released, and the strongest Indian-language entrant: typed probabilities in English and Indic languages with the evaluation to match (public JDI runs plus an internal Indic suite; Sarvam's own Artificial Analysis reconstruction is not an official AA score). Apache 2.0 weights but a custom FP8 runtime needing ~120 GB of GPU memory — the interface doesn't imply small.
• Sieve - Eight-size Apache family (0.8B full fine-tune up to a 31B, most sizes LoRA-plus-head) from sthanika-ai; the 31B v3 sits #5 on the Decision Index's Nov 6 draw (71.10) with the v2 27B still top-30. Thin on write-ups, thick on checkpoints — the evidence is the board.
• StartLux-Decision - Open family from 0.8B to 27B emitting a calibrated probability per option in one pass, with a short thought generated only when the model is unsure: adaptive compute in an open model. Apache 2.0, vLLM / llama.cpp / MLX engines, and a proper technical report. v1.1's 27B Instant and AutoThink builds on Qwen3.8-27B post 82.6 and 80.3 capability on JevBench, though at 6.5× and 11× Jev's serving cost they fall outside the board's Jev-class caps.
• Strands Decider - The Strands Agents org's open decision-model family (weights live under Hugging Face's amazon org too): four Gemma 4 builds from E2B to 26B-A4B, each answer carrying a calibrated reliability score, with JevBench, Brier, and Decision Index numbers published per size — the 2B uses a ~1M-param pointer head in place of the LM head, scoring each option's hidden state against the <answer> position, with all 19 training iterations documented in the repo. Apache 2.0, ships a CLI. Amazon's production deployment (case study, Nov 9) replaced Claude Sonnet 4.6 ticket labeling with the E4B build at equal quality and 98% lower cost ($0.0005 vs $0.0222 per ticket, 897 ms vs 4,215 ms) — the largest production win the class has published, and honest about its boundaries (JSON key-order sensitivity moved probabilities by up to 0.19; labels needing explanation or weekly-changing catalogs stay on an LLM).
• Surogate Rune - Full fine-tune of Gemma 4 26B-A4B for typed decisions over text and images. Weights are gated behind HF's terms. Now at v3, which also powers Surogate's hosted s1-pro service; #6 official on ImageJevBench v0.3.0.
• system-one-open - Jev-style replica on Gemma 4 E2B / Gemma 3 270M, trained and served on Modal. One forward pass, no decoding. Live demos for support, Doom, browser-use, and smart home.
• Tacit / Tacitus - Nokia's trained siblings to the training-free AnyJev: Tacit (1.7B–9B on Qwen) is self-distilled with no human labels or external data — the base model generates its own decision problems, answers them with reasoning, then learns to produce those answers in one forward pass — and Tacitus-31B fine-tunes Gemma-4-31B-it with training and inference co-designed. Tacitus tied for third by Full score on Decision Index 0.4.1 (Oct 21).
• Tev1 - Together AI's Jev-inspired experiment: Qwen3.5 fine-tunes that take state + question + 2–24 options and return one letter — openly next-token, not a non-autoregressive runtime. MIT, with full data recipe and a "train your own for $17" writeup. A 4B experimental build is also served on OpenRouter.
• THX-01 - 322M multilingual encoder decision model that answers typed questions and returns supporting evidence: alongside choice / yes-no / ordinal it outputs numeric extractions, verbatim excerpts, and citations — the output contract of an extraction model in an encoder-sized decision package. Post-training covers 18 languages; all comparisons are producer-run, and the 1,024-token input limit (state plus question plus options) bounds it to short-context work. Apache 2.0.
• Torchcast Decision - Three-size family (4B / 12B / 27B, the 4B multimodal) from Singapore forecasting shop Torchcast AI: 262K context, TypeSafe /v1/systemone wire, 33 ms per noul on one H100. The 27B posts 65.00 on Decision Index 0.2.1, +7 over Jev 1.13 and second only to RSI-Jev on the public board. JevBench's October refresh makes it the open-weights leader: the 4B v1.2 tops the official composite at 73.0 (v1.1 #7, the 12B #9). CC BY-NC, so research use only.
• Turion Jev 31B - Turion AI's Gemma-4-31B-it fine-tune, tied #2 on the Decision Index's Oct 28 board and #6 on the Nov 6 draw (70.47). A LoRA soup (uniform merge of steps 300/375/450) trained 7.3 hours on one B300 with soft probability targets and annotator distributions as labels; order-averaging and read-twice passes are gated to single-question requests so latency stays inside the board's rule. The card decontaminates against the public suite by 13-gram overlap (4,395 rows dropped) and publishes the full results dataset. Apache 2.0.
• Valen - Train-your-own multimodal System One model: evaluates text, images, and video against task instructions and returns probabilities over supplied candidates. Ships the model code, data pipeline, SFT plus experimental RLCD training, and evals.
• vegaml - Typed decisions from a frozen LM plus a small physics engine, from Laya's author: calibrated probabilities, conformal answer sets, and an explicit abstain flag. 800M or 4B, 73K context, image inputs.
• Vela - KR Labs × vLLM Semantic Router's open decision-model family, now at Vela 3 (vela3-fast: 380M backbone, 1.65B full package with adapters, adds span extraction). Choice, Noul, Score plus Span (labeled offsets for PII and unsupported claims) and Set multi-label; SystemOne-compatible HTTP and Python APIs, ONNX runtime, Core ML with a Swift runtime. Trained for router work: routing, prompt-attack, PII, and hallucination screening. The larger d3 line is listed separately under Models; the EO-Jev study LoRA-adapts d3-flash into an earth-observation generalist (+8.0 held-out at a documented 1.8-point general cost).
• WaterSheep - ModernBERT-base fine-tune with a decision head that answers noul / choice / score and also multi-label questions, with a fitted temperature per question type. Publishes its held-out numbers: 61.2% accuracy and 0.043 ECE on datasets it never trained on. Apache 2.0 code and weights; serves TypeSafe /v1/systemone, so the official SDK works by repointing TYPESAFE_BASE_URL, and an ONNX build runs in the browser.
• WeMM-JEV - 27B multimodal decision model on Qwen3.8-27B taking text plus multiple images: choice / noul / score with a probability per option in one forward pass. #12 on the Nov 6 draw (68.49); its own public-panel run posts 77.97 on vision items against 69.37 on text, with the results dataset published. Apache 2.0, card on the thin side — the multimodal standing is the story.
• xor - Juspay's open decision model: a merged rank-16 LoRA on Qwen3.6-35B-A3B shipped with a pinned SGLang serving bundle, answering Choice / Score / Noul over text, images, or video on the TypeSafe /v1/systemone wire. Apache 2.0.

Hosted

• Celeris-1 - Celeris's hosted decision model over text, structured data, or images; the only entrant that can attach a one-sentence reason to each answer. $0.04/M input, closed weights. #16 on JevBench's v1.8 API board (71.0) and #9 official on ImageJevBench v0.3.0; also on Artificial Analysis's board.
• Decider - Perplexity's decision model on the System One request shape. October brought a v1.2 (27B full fine-tune) and a 4B decider-flash, joining V1.1 on Hugging Face; v1.2 sits #17 on the Decision Index's Nov 6 draw (67.98; it was #2 on edition 0.4 at 69.42). On OpenRouter — and unusually for a hosted entrant, the V1.1 weights are Apache 2.0 on Hugging Face with community GGUF and MLX builds, and JevBench self-hosts both v1.2 (I 73) and flash (I 46).
• Decider 1 - meraGPT's hosted decision model, unrelated to Perplexity's despite the name: Choice / Score / Noul over a 4K-token request at $0.04/M input, output free. Live since September 22, a week after Jev.
• GLiDE - Fastino's adaptive-compute decision model, now two-sided: the 22 Oct hosted checkpoint jumped to #4 on JevBench's v1.8 API composite (76.4, I 76, C 93) — the October reshuffle's biggest single mover — and GLiDE 1.2 open weights rank #3 on the open-weights capability view (84.9, official #5) and #2 on the Decision Index's Nov 6 draw (73.37), with the base undisclosed and a nonstandard license on the repo. The earlier hosted GLiDE row (now #34, 30.6) remains the cautionary tale its adaptive reasoning cost bought. $0.023/1k hosted; mid-table on Artificial Analysis's.
• Hanzo Kai - Hanzo's hosted decision model on the OpenRouter Decisions wire: model: "kai" at api.hanzo.ai/v1/decisions, with Jev itself routable on the same endpoint. A Jev client works by repointing the base URL.
• Instinct - ZooWork's hosted decision model in two tiers: a Qwen3.8-27B build and a cheaper dual-4B. Ranks #25 of 49 on JevBench's v1.8 API board; the base is operator-reported and weights are closed.
• Jev - TypeSafe's System One model. Choice, Score, and Noul over a state in one request, about 70–500 ms, trained with RLCD. Hosted API ($0.042 per million input tokens, output free); weights unpublished. Jev 1.14 is the current stable release (since Oct 14; multilingual is the biggest gain), with opt-in "danger zone" headers unlocking image inputs, 262K context, and a box bounding-box type — the first System One output that isn't a decision. JevBench's v1.8 board ranks 1.13 #15 of 49 and 1.14 #18. Also on OpenRouter, Vercel AI Gateway, Cloudflare Workers AI, and LLMGateway. Vercel's October Gateway report put Jev at 35.3% of paid teams inside its first 14 days, the fastest adoption in AI Gateway history, and Airbnb's production benchmark calls it the most accurate off-the-shelf model they tested under 100 ms. Docs · Launch post
• Jev Router - TypeSafe's meta-application of Jev: a model that picks the best model and reasoning effort for each request, balancing quality, speed, and cost.
• kettei - Sqwish Labs' decision-model family behind the OneHot API: binary, single-choice, and ordinal decisions — an expected level over ordered answers, a primitive Jev lacks — plus abstention policies, over text or images. kettei-fat ($0.06/M input) and chub ($0.04/M) are multimodal, text-only core is $0.02/M, and the platform wraps them in dataset versioning, teacher labelling, prompt tuning, and gated fine-tunes. Speaks Jev's request/response format natively — repoint a Jev client's base URL — ships MCP tools and a Claude Code PreToolUse hook, and bills no output tokens. JevBench v1.8 still ranks kettei-fat #1 on the API capability view (86.3) and #1 on ImageJevBench v0.3.0 (75.9), though Super Decider and the cheap Myles-G tier now edge it on the cost-weighted composite (#3, 77.7); chub sits #12.
• Mercury Decide - Inception's structured decision model on the System One schema, from the diffusion-LLM lab behind Mercury. A free route exists on OpenRouter. Ranks #14 on JevBench's v1.8 API board (72.2).
• Microsoft-Decision-1 - Microsoft's decision-scoring model: Qwen3.5-9B post-trained for single-pass choice/noul/score plus rubric grading, calibrated probabilities over a fixed answer set. Microsoft's 36-benchmark, ~150K-question blind eval claims top accuracy and fastest measured (~35× faster than GPT-6 Sol), with a 1.3% flip rate under input perturbations. Live in Microsoft Foundry; OpenRouter planned. Already used internally by Xbox Research and Copilot.
• Myles-G - Launchables' hosted decision tiers (12B and 31B, self-reported Gemma 4 LoRA merges — the board marks the base as customer-stated, not independently verified). The 12B sits #2 on JevBench's v1.8 API composite (78.2) almost entirely on price: a near-perfect cost axis at $0.0011 per 1,000 decisions — roughly 40× cheaper than Jev — while its intelligence axis (57) trails the leaders; the 31B flips it (I 74, #17). The price-floor entrant.
• OpenAI Decisions API - OpenAI's entry in the class, generally available since October 22 (announced at DevDay 2026): text or image context plus a fixed answer set, returning typed answers with confidence around 150–230 ms. GA brought shared-input caching ($0.01/M cached vs $0.10/M fresh — a 10× discount on the repeated-state pattern), images in question instructions, and 400 questions per request, doubled from beta. Powered by a Luna variant, also routable on OpenRouter as openai/gpt-6-luna-decisions.
• Parallel Decisions - Decisions grounded in the live web, from the Parallel web-search platform: send a state seed plus up to 100 mixed noul / choice / score questions and it retrieves the evidence itself before answering — every response carries a shared citations array with URL, title, and excerpts, a pattern no other entrant has. A documented refusal type is the explicit abstention outcome ("do not turn it into a negative predicate"), score answers return the probability-weighted fractional mean with their level legend, and the docs are honest that missing evidence is not proof a predicate is false. $1 per 1,000 requests with all 100 questions included, 200 ms–1 s, and the web_decisions MCP tool works free with no account. Its PWS-Decisions benchmark (listed under Evaluation) is the first to score web grounding — and the gap it shows is the product's whole case.
• Reflex - Morph's (YC, AutoInfra) hosted decision model on the /v1/systemone wire: choice / score / noul over text, JSON, or up to 16 base64 images, 64K context, zero output tokens, $0.042/M uncached. State caching is priced into the product ($0.008/M cached), and Morph publishes the measured reuse trace — repeat a state and 91.6% of input tokens were reused across five production calls. OpenAI's Decisions GA prices cached state at a steeper nominal discount (10× vs 5×); Morph's distinction is the published cache-behavior data. Confidence is documented honestly (peakedness against the full vocabulary, can be below the top option's probability). No published benchmark numbers yet; no relation to the open reflex in Serving & runtimes — the name is a collision.
• Sage - Levanto Labs' hosted decision model, #1 on JevBench's API composite until the October refresh. Sage 1.4 adds beta image questions — #2 on ImageJevBench v0.3.0 (75.8) — though on the text board its slower answers drop it below 1.3.0 (#22 vs #11 on v1.8). Closed API.
• Snowflake Decision - Typed decisions as a warehouse primitive, in private preview: AI_COMPLETE applies choice / score / noul questions across whole tables inside Snowflake's governance perimeter, throughput-shaped rather than interactive (seconds per call, with a lower-latency snowflake-decision-fast and a Cortex AI Gateway REST route also in preview). Snowflake reports the top quality score among 72 models on Decision Index 0.2.1's 29 benchmarks — a vendor figure on an edition two versions old, from a provider you need an account team to reach.
• Solar Decide - Upstage's structured decision model on Solar Mini 4 (beta). Same /v1/systemone schema as Jev, calibrated probability per answer, and a 512K context — a whole document can be the state. choice is limited to 26 single-token letter options. On OpenRouter, with a low-latency Flash variant.
• Span-01 - Respan's behavioral-monitoring decision model: describe a behavior (user frustration, tool misuse) and get present / absent / not-observable probabilities on a conversation. A free Lite tier exists for high-volume monitoring. Vendor-run benchmarks put it ahead of Jev overall but behind GPT-6 Sol per-domain. An open-weights Span-02 followed, ranked on JevBench's open board.
• SPX-CD - SurdAI's hosted decision system (Flash and Pro tiers): a router/cascade on the /v1/systemone shape rather than a single model. Flash ranks #23 on JevBench's v1.8 API board, and open SPX-CD-Omni weights (Gemma-4-12B + LoRA) sit on Hugging Face.
• SubQ Snap - Subquadratic's long-context decision model: multimodal input with a 384K context (versus Jev's 32K) on a proprietary subquadratic sparse-attention stack. Their runs beat Jev on long-context retrieval (Decision LCR 74 vs 48) and on 13 of 16 enterprise suites by +6.0 on average, while still trailing on When2Call. $0.05/M input, output free. #10 on JevBench's v1.8 API board, with the new Snap 1.1 at #6 (75.7).
• Super Decider - Singularity Compute's decision model — open weights (Apache 2.0, HF), classified by JevBench as a diffusion LM, one of the only diffusion entrants in the class. #1 on the v1.8 API composite (78.5: I 79, C 91, $0.016/1k) and its thinking sibling #2 on the merged capability view (85.9, I 80) — it took kettei-fat's composite crown while kettei keeps the capability one.
• Trio-Spark - MachineFi's hosted decision model on the /v1/systemone shape (Choice, Score, Noul) for text, images, or sampled video frames, one probability per answer in one pass. MachineFi-run evals put v1.3 at 90.9% across 13 public-dataset tasks, ECE 0.019 on the ten where calibration is measured (release post). $0.042/M input, output free, closed weights.
• wity-1 - Alphanimble's hosted decision model with an auto-reasoning mode. Ranks #20 on JevBench's v1.8 API board (69.0). Closed API.

Extraction models

• Clairic - Cloudflare's System One extraction model — the first entrant in a sibling class to decision models, answering with typed values instead of option probabilities. One parallel pass over text and up to four images fills named fields: text spans with character offsets, computed numbers and dates, durations, lists, estimate distributions inside bounds you declare (median plus an 80% interval), and per-step forecast series. Every answer carries confidence and p_null; a field the input doesn't determine returns null rather than a plausible guess. Hosted on Workers AI at $0.10/M input, output free, 64K context; open weights promised. The launch post is honest about the seams — multi-step arithmetic, estimates without evidence, basic forecasting — and pairs Clairic with Clef in a claims pipeline that ran 3.2× faster than all-LLM at half the cost, where Gemma 4 and Qwen failed the extraction step outright; its 21-day TSA forecast landed 17 of 21 days inside the stated 80% interval.

Serving & runtimes

Run one, or turn any open model into one. Same request shape, no new training.

Serve any open model

• AnyJev - Turns any LLM into a Jev-style decision model: typed decisions with probabilities, no training, reading answers from the next-token distribution with cyclic shifts and prior correction to strip positional and label bias. From Nokia Applied Research, Apache 2.0. Its self-distilled Tacit models are listed under Models.
• djev - DiffusionGemma plus vLLM: an inference method rather than new weights, with native image inputs and a hosted API. Ranked 3rd on JevBench v1.2, just under Jev itself.
• Flide - Decision-model inference engine from the OneJev authors, now with the class's first serving paper (arXiv 2610.42148, NUS): exact state forking — each question reuses the shared state's computation in a separate forward pass, giving up to 9.5× over vLLM and SGLang with answers bit-identical to the question alone, and flide verify checks that on your own model. Serves 30+ model families through /v1/systemone with per-model speed tables published (Clef 1.3× through Kev ~7.9× and OneJev ~6.8×; multi-request batching, session caching for agents, FP8). The email triage demo is the class's best throughput number: 10,000 emails × 8 questions in 28 s on one H200. Apache 2.0, pip install flide, ~318 stars.
• jeff - Self-hosted drop-in on GLiFormer 400M, MIT. Speaks the TypeSafe request shape (JevBench drove it with the official adapter); ranked in v1.2.2.
• jev-visual - Educational Jev-like visual inference experiment on Apple Silicon: shared context, direct candidate scoring, and local visual demos.
• jevmlx - Jev-style parallel constrained decisions for any MLX model on Apple Silicon. Scores every allowed answer per schema field in one pass, so the output is valid by construction.
• llama.cpp - Native decision-model serving since PR #29818 (Oct 2): llama-server exposes /v1/systemone over GGUF checkpoints — Julia-1, Laya, Kev-4B, Lev, OpenJev 27B, with vision via Clef and later additions — one llama serve -hf ggml-org/Kev-4B-GGUF away on a laptop or CPU box. The inference stack underneath Ollama, now speaking the wire itself. Launch post
• LLM2Jev - Adapts local language models into Jev-compatible decision engines with Choice / Score / Noul outputs, via prefill-only binary inference. Apache 2.0.
• Ollama - Native decision-model support since 0.35.0: /v1/systemone on localhost speaks the Jev API shape, so the official TypeSafe SDK works by repointing it. ollama pull serves Nimble 9B, Tev1, d1, Clef and Clef-Flash, and pplx-decider, with base64 images on the multimodal ones; the honest limits are published too — a 64 KiB request cap, no streaming, and a confidence score that measures distribution peakedness, not calibrated correctness. The launch post demos Pac-Man on Nimble at ~91 ms per decision on a laptop.
• ollaya - Ollama for decision models: ollaya pull / serve / run manage Laya, decider, NLI, and GLiClass locally behind a wire-identical TypeSafe /v1/systemone (and /v1/decisions) endpoint. A separate project from Ollama's own native support above, built before it and worth keeping for the multi-model management.
• open-alternative-jev - System One-style layer on open weights, ranked on JevBench. Its cautionary detail: 72% vs 21% on the same answer-judging items with option order flipped.
• openjev - Open, Jev-compatible System One decision server on DiffusionGemma. Apache 2.0.
• openjev-sglang - TypeSafe /v1/systemone on Qwen 35B MoE via SGLang. Prefill once, then first-token logits per question. No extra training.
• reflex - Open recreation on Qwen3.5. Prefills the state once, then scores every question in parallel from next-token logits. Serves the TypeSafe request shape. Browser demo on WebGPU. #3 on Image JevBench's original pool; on v0.3.0 it's #13 under the Jev-class caps (53.3).
• SemIf - Runtime-defined semantic decisions from direct option logits. CUDA, MLX, and WebGPU, plus committed benchmarks. Repo recently renamed from SemIf.
• SGLang - Native decision-model serving since v0.5.21 (Oct 2, merged upstream Sept 25): both a /v1/decisions endpoint that converts any Jinja-templated chat model into a decision model and a /v1/systemone endpoint speaking the exact TypeSafe wire — official SDKs work by repointing the base URL. Any served generation model qualifies (validated on Qwen3.8-27B and Qwen3.5-35B-A3B, sub-100 ms decisions), no decision-specific training required. At ~38.6K stars the largest runtime the list covers; the stack xor pins its serving bundle to and openjev-sglang wraps, now first-class.
• simple-jev - Turns any open model into a classifier / Jev endpoint. From Featherless, Apache 2.0.
• system-one - Turns any open LLM into a System One classifier: batched single-token choice inference, TypeSafe SDK compatible. Doom and wikiracing demos on Qwen3-8B.
• systemANE - Apple's Neural Engine as a free local System One decision engine on macOS: "Jev at home."
• vLLM Structured Decisions - Upstream vLLM serves /v1/systemone directly: decision models with a supported read strategy run as pooling models and answer choice / noul / score from label log-prob mass (--logprobs-mode raw_logprobs), so the shared state rides prefix caching like any chat prefix. What Clef-Flash and H2O's shim build on, as an official endpoint rather than a per-model hack; distinct from the vLLM Semantic Router listed under Applications.
• von - Non-autoregressive local drop-in, sub-15 ms decisions, Apache 2.0.

Applications

The decision is load-bearing: agents where the model picks an action and code runs it, and the plugins, CLIs, and layers that put a System One model inside other software.

Screen & device control

• computer-use-jev - Drives native macOS apps through the Accessibility API. Jev chooses the next action and target token from a live snapshot, and stops if confidence drops too low.
• jev-browser - Headless browser agent. Jev picks click / type / select / done from the page's elements; code owns budgets and stop gates. MCP server, CLI, or library.
• jev-browser-use - Split-brain browser agent: Jev clicks, Codex thinks and verifies.
• jev-ultrafast - Browser agent with a dynamic, indexed action space. Jev picks an operation and an element in one request; a small LLM writes text only when the operation is TYPE_TEXT. Zürich to London on Google Flights in 7.1 seconds.
• mobile-jev - Android agent on a real phone via Mobilerun. Jev picks OPEN_APP / TAP / TYPE_TEXT from an indexed snapshot. Text is copied from the goal, not generated.
• tiptour-macos - Local computer-use app for macOS where Jev is the default engine: it picks from locally detected controls and the app executes and validates each action.
• typesafe-computer-use - Computer use for about $0.0002 a step: OCR the screen, Jev classifies the next action, code clicks. macOS.

Domain agents

• embodied-jev - MuJoCo robot decision workbench: MiniCPM-2B or Jev-class APIs pick the next action, with physics previews.
• jev-chat-jarvis - Chat decision copilot across Android, Windows, macOS, and iOS: Jev reads the conversation, judges intent and risk, and drafts replies you fill in with one tap. Read-only, no app hooks. MIT, ~7.9K stars, the largest end-user Jev app by traction.
• jev-drone - Camera-only autonomous drone in MuJoCo with Jev in the loop at 2.5 Hz.
• jev-social - Local-first social-media research agent for Instagram, TikTok, and LinkedIn: Jev picks each next operation (search, open a post or profile, read comments, finish), a local CLI executes it in your signed-in Chrome, and every observed result goes back to Jev. Source-cited reports, no account credentials leave the machine.
• jev-trader - Experimental: one Jev buy/sell decision every Monad block (about 300 ms) on the Kuru MON-USDC book. Dry-run by default.
• neo4jev - Jev navigates a Neo4j graph by classifying over each node's neighboring relationships: graph traversal as a chain of typed choices.
• QuantDinger - Open-source AI trading OS with a Jev decision gate in front of live entry orders: typed Choice plus an auditable decision timeline, fail-open, and exits that always bypass AI.
• system1-agents - Prebuilt agents that run a System 1 model (Jev, Laya, or Cua-S1) as the brain across browser use, computer use, robotics, and games, with Claude Code or Codex scaffolding new ones. Publishes per-scenario timings: up to 6× faster and 25× cheaper than a chat model at the same score.
• typesafe-assist - Home Assistant conversation agent. Jev maps a spoken command plus exposed entities onto built-in intents. Free-text intents fall back to another agent.
• typesafe-mario - Jev plays Super Mario Bros. from structured emulator state: the classic RL demo with a decision model in the loop.

Context & memory

• distill - Token-saver for agent sessions with a documented Jev routing layer.
• fast-jev-compaction - Claude Code plugin that replaces the compaction summary with Jev decisions: every tool call and result is scored in one request and the stale ones dropped.
• invalidate - Invalidation layer for AI memory: every fact gets a lease, and new evidence ends it.
• memsearch - Zilliz's agent memory layer, with optional Jev reranking and a published Chinese/English reranking evaluation.
• stuntd - Local proxy that learns your app's typed LLM decisions and answers them itself with a Laya head. Jev- and OpenAI-compatible.
• winnow - Claude Code hook that splits large tool results into blocks, asks Jev a yes/no relevance question per block, and stubs the ones that fail.

Routing & supervision

• agentconnect - Multi-agent collaboration across Slack, Telegram, and GitHub, using Jev for agent routing, model selection, and support triage.
• Astra-Ares - Adaptive reasoning effort: Jev judges each Codex step and turns GPT-6's thinking effort up or down mid-task, so easy steps stop burning tokens.
• Foreman - Jev as a fast supervisor above slower coding agents, judging whether the work is complete, the requirements met, the tests sufficient, or a human is needed.
• hermes-jev-skills - Jev-powered skill suite for Hermes agents (also Claude Code and Codex): model routing, memory, compaction, skill selection, computer and browser use.
• Intent-Router - Intent compiler that converges vague requests into typed IntentSpec contracts — probe, ask, or halt — before routing. The input layer in front of routers and decision models like Jev or Laya.
• jev-codex-router - Per-turn model and reasoning-effort routing for Codex. Jev classifies each turn and picks the tier; a 7-day replay of 237 real turns measured about 60% savings against all-frontier.
• JevRouter - Jev-powered router across models, tools, and subagents.
• kadi - Calibrated judge in front of a frontier model: a small local model answers routine decisions under a distribution-free bound on disagreement; everything else escalates, and each escalation teaches the judge further. Includes an MCP server.
• pi-jev - Pi coding-agent extension: semantic tool and skill routing, typed choice / noul / score evaluations, optional auto-approval, and a post-run jev-gate CLI.
• vLLM Semantic Router - Open, programmable decision layer for models and compute: routes requests across models, enforces safety checks, and picks reasoning effort — with the Vela decision models as its routing brain. Apache 2.0.

Review & verification

• Canny - Stops coding agents from claiming done without evidence: deterministic hooks decide what needs checking, Jev judges the result.
• jev-review - Staged code-review workflow with a local dashboard, using Jev to score and sort findings before a human opens the queue.
• perch - Semantic code linting: rules written in plain English, judged by Jev.
• reticle - Verification harness for agent-built code; the jev driver explores a page by choosing among DOM-enumerated candidates — the model chooses, never composes.
• sedum - Plain-English browser tests on Playwright where Jev only picks targets and next actions (Choice) and judges claims (holds/contradicted Nouls), and code owns every action and verdict. TypeScript, MIT.
• snifftest - Prose linter that sniffs out AI writing tells: zero-dependency countable rules plus one judgment model.

Search & data

• blink - Codebase search powered by Jev decisions: typed questions find where a task lives in a repo.
• docjev - Very fast document classifier and PDF splitter from the creator of LlamaIndex: plain-English rules, Jev assigns each page a category and finds document boundaries.
• jev-curate - Dataset sifter for synthetic and pretraining corpora: a Rust streaming core sends Jev keep/drop decisions over Parquet rows.
• jev-search - Web search pipeline where Jev handles source selection, query understanding, and relevance ranking.
• jev-tree - Recursive Jev choice over a taxonomy: selects from more than 255 options without hitting the choice cap.
• jevframe - Semantic AI for Pandas and Polars: classify and score DataFrame rows with natural-language questions and full probabilities.
• jevgrep - Codebase search for coding agents: Jev judges folders, files, and declarations, then returns reading leads and verbatim source excerpts. npm CLI plus an agent-skill installer; matched the baseline 8/10 on a ten-task SWE-bench at ~30% lower cost.
• jgrep - Grep where the pattern is a description: filters lines by meaning for about a thousandth of a cent each.
• pg-jev - PostgreSQL extension (on PGXN): jev(rows, 'plain-language condition') filters, ranks, and classifies table rows. The clever part — it batches 20 rows into one shared-state request with a noul each, amortizing Jev's request overhead ~2.5×, with read-ahead and per-row answer caching.

Train & adapt

• bandits - Trace mining for post-training: reads agent traces (OTel, Langfuse, Claude Code), judges each step by the tool's reaction rather than the agent's claim, distills the LLM judge into deterministic Python checks a human signs off on, and exports labeled SFT rows with full lineage. Its bundled Jev recipe trains a decision model on those labels with an honest scorecard — their Qwen3.5-4B reports 79.1% vs Jev's 66.8% on 1,920 held-out AgentProcessBench steps.
• jev-align - Build calibrated AI functions from human feedback: Jev judgments optimized with GEPA. From Sutro.
• Jevstiller - Proxy that distills a repeated Jev call on the fly: trains a small local model on Jev's own answer distributions, verifies agreement within a budget you set, then answers locally in ~15 ms while a permanent random audit slice keeps checking against Jev. PyPI, Apache 2.0.
• jimothy - Turns Jev usage into small local classifiers: --teacher typesafe-ai/jev labels the data, then a MiniLM model runs it in Node or the browser.
• System One Studio - Open-source local fine-tuning app from the systemonemodels.ai platform: MLX on Mac, PyTorch on NVIDIA / AMD / CPU, LoRA / DoRA / rsLoRA / LoRA+, scoring the fine-tune against the base before it publishes.
• Unsloth - Decision-model fine-tuning at ecosystem scale (~79K stars): FastDecisionModel + DecisionTrainer attach a Clef-style decision head to any Qwen, Gemma, Llama, or DeepSeek base via 4-bit LoRA on consumer GPUs, with a documented recipe that lifts Qwen3.5-0.8B from chance to 78% on Banking77, CLINC150, and typed-decisions. The honest note is in their own docs: for existing decision models like d1-3B, fine-tune the model's own readout rather than grafting a new head. The default on-ramp for training your own.

Apps & utilities

• ai-cli - Vercel Labs terminal client. The evaluate command sends a state plus typed questions to typesafe-ai/jev on AI Gateway (-m jev for short).
• Bud Decision Studio - The LM Studio of decision models, from Bud Ecosystem: a cross-platform desktop app that checks your hardware, pulls Jev-like models, and serves them locally. Give a model a situation and typed questions, get calibrated probabilities in milliseconds.
• classifier.dev - Zero-shot text classification as a URL: classifier.dev/spam,not+spam/your+text returns a label with calibrated confidence — no key, no account, up to 1,000 texts per call. One Cloudflare Worker on Jev with an LLM fallback chain, plus a CLI and MCP server. MIT.
• jeview - Local visualizer for Jev: a live view of every call your code makes.
• jevmail - Open-source Gmail triage: sorts an inbox into needs-reply / updates / promos / spam. Read-only, runs locally, about 3 cents per 1,000 emails.
• json-render - Vercel Labs generative-UI framework with an experimental Jev mode: Jev picks components from your catalog instead of a model writing markup.
• semdecide - Jev calls as Unix-pipeline predicates: routing, scoring, and JSONL filtering with stable exit codes, plus an agent-safety guard recipe.
• unclutter - Browser extension that removes page clutter: Jev scores elements against reusable rules, the extension hides the junk.

SDKs & Adapters

Official

• @ai-sdk/typesafe-ai - Official Vercel AI SDK evaluation provider. Choice, Score, and Boolean (Noul) over one state via experimental_evaluate.
• skills - Official agent skill for designing System One workflows from Claude Code, Codex, and other skill-compatible agents.
• typesafe-sdk-js - Official TypeScript / JavaScript client.
• typesafe-sdk-python - Official synchronous and asynchronous Python client.

Community clients

• Community SDKs - Unofficial clients for Go, Rust, Ruby, PHP, .NET, Elixir, and Swift, tracked by language. All launched in Jev's first week — check the last commit before depending on one.
• llm-openai-decisions - Simon Willison's llm plugin for the OpenAI Decisions API: evaluate text and images with predicates, choices, and scores.
• llm-typesafe - Simon Willison's llm plugin for Jev and other TypeSafe models.
• qualm - TypeScript wrapper where every decision needs a required unsure branch — ignoring the uncertainty case is a compile error.
• Switch - TypeScript framework for finite-choice agents: application code defines the state, legal next steps, and transitions; a decision model chooses among them. Bounded runs, complete traces, replay, and forking saved runs — the reusable architecture for a decision model inside a multistep agent, with a document-navigation rubric judge as the worked example. Its adapter targets classifier models registered in pi-ai. MIT; ~435 stars in two weeks.
• system-one-foundation-models - Native Swift 6 bridge (renamed from jev-foundation-models) putting decision models behind Apple's Foundation Models framework interface: on-device Laya through Core ML, self-hosted Laya, Clef, OpenAI Decisions, and Jev.

Frameworks & integrations

• DSPy - Choice, Noul, and Score as experimental output types in DSPy signatures, plus ReAnchor, the optimizer that fits their numeric settings — noul thresholds, score cuts, choice option weights — against the whole program's metric with a held-out fold check, without touching instructions or demonstrations. In 3.4+ under dspy.experimental, and marked experimental.
• eve - Vercel's open agent framework, where Jev powers the evaluate primitive and tool-approval policies.
• hono-jev-router - Semantic HTTP routing middleware for Hono: route requests by meaning, from Hono's creator.
• iamaamir/system-one - Provider-neutral System One runtime for TypeScript and Pi: write the choice / noul / score decision once behind a SystemOneProvider interface, run it on Jev, Reflex, or any compatible /v1/systemone endpoint.
• jev-layer - Portable System-1 decision layer for agent harnesses (Hermes, OMP, Codex, generic MCP): Jev recommends, the host checks permissions and executes. 0.3.0 is the first harness layer shipping screenshot input and box grounding on Jev 1.14. MIT.
• jev-mcp - MCP server of Jev judgment tools: verify, screen, find, rerank, classify, decide, compare, extract, review, and gate.
• jevcore - Jev inside DeepSeek Harness and other MCP hosts, or plain Node: an offline-by-default, egress-disclosed adapter that gives an agent the typed noul / choice / score surface and nothing more. From Phocinae's publisher.
• LangChain - The official langchain-typesafe package exposes the decision surface as a composable Runnable — one state, every question in a single request, batching and LangSmith tracing included — plus experimental middleware for agent control: ModelRouterMiddleware picks the model per turn, and AutoModeMiddleware gates tool calls by risk class before they run.
• laya-mlx - Native MLX runtime for Laya on Apple Silicon: 7–14 ms decisions on an M3 Max, no GPU server needed.
• LiteLLM - The gateway's decision surface: /v1/decisions (OpenAI format) and /v1/systemone (TypeSafe format) share one provider list — Jev, Perplexity Decider, Clef, Databricks, Microsoft Foundry, Strands Decider, Laya, Nimble — with translation between the two request shapes, so virtual keys, budgets, spend tracking, and fallbacks apply to decisions like any other route. Its Auto Router can also drive request classification from a decision model.
• NoulXP - Open packaging standard for System One models (formerly OpenDXP): a systemone.yaml manifest turns a model into a package any compatible engine can serve over HTTP or as an MCP tool.
• Pydantic AI - Decision models as native agent backends: TypeSafeModel (a DecisionModel subclass) turns an agent's typed output fields into questions — bool → noul, Literal or Enum → choice, a bounded IntEnum → score — validates answers against the schema, retries on invalid data, and falls back to a generative model when a step needs writing rather than deciding. Jev, any compatible endpoint via base URL, and OpenAI Decisions; Gateway, Evals, and Logfire observe the decisions.
• receptron/laya - Run Laya from Node.js / TypeScript via ONNX Runtime; the ~1.7 GB weights download from Hugging Face on first use.
• system-one-adapter-python - Drop-in TypeSafeClient replacement backed by OpenAI or Anthropic, for comparing Jev against an LLM on the same questions.
• typesafe-mcp - MCP server as a single static Go binary, no Node or Python runtime. Sends usage guidance back to the client so the agent writes better questions.

Baselines

Cheaper classifiers for comparison. They do not share Jev's request shape. The honest continuum is fixed classifier → constrained generative model → decision model → reasoning model: each rung earns its cost only if probabilities, latency, or cost actually beat the rung below.

• fastText - Classic non-generative text classification library. Upstream archived in 2024.
• GLiClass - Zero-shot classification against labels supplied at inference time — single-label or multi-label, one forward pass over text plus labels, roughly 10× faster than cross-encoders — from the GLiNER ecosystem's other branch. The closest non-LLM baseline for dynamic-choice workloads.
• GLiNER - Lightweight zero-shot structured extraction: you name the entity types at inference time. Often the comparison point in Jev classification benches.
• GLiNER2 - Fastino successor to GLiNER. Schema-conditioned encoder for classification, extraction, and relations in one pass.
• jeffy - 68 pretrained logistic-regression classifiers that run and retrain on CPU: banking77 at 94.3%, CLINC-OOS, spam, plus game-state deciders for Doom and poker. The "do you even need a decision model" baseline; pip package with a live playground. MIT.
• ModernBERT - Modernized BERT encoder under most fast classifiers, including Laya's English checkpoint. The non-generative baseline Jev's cost and speed usually get measured against.
• Outlines - Constrained generation from ordinary LLMs: schemas, regexes, and context-free grammars compiled into token masks, so the output is structurally valid by construction (~98% schema adherence against ~76% for generate-then-validate). The control condition every decision-model comparison should include — a constrained LLM already guarantees the JSON parses, so a decision model's case has to rest on probability quality, latency, and cost instead.
• RouteLLM - Trains and serves routers that pick which LLM should handle a query, based on cost and expected quality, rather than answering the question itself.
• semantic-router - Embedding-space route layer for LLMs and agents. Chooses a path from utterance similarity without a generative call.
• SetFit - Prompt-free few-shot text classification on Sentence Transformers. Strong when labels are fixed at train time.
• XGrammar - The grammar engine underneath most modern serving stacks — vLLM, SGLang, TensorRT-LLM, MLC — masking tokens to JSON schemas, regexes, and CFGs at near-zero decoding overhead. Where the constrained-generation baseline actually runs in production; still marked beta by its authors.

Evaluation

How the class gets measured: boards to compare on, suites to run against your own model, the datasets inside them, and probes of known failure modes.

Leaderboards & indexes

• Artificial Analysis Decision Index - The mainstream benchmarking site's entry into the class: 13 decision models scored across four evals (a private adaptation of AA-Omniscience, HLE-MultiChoice, When2Call, WildGuardTest), with per-model calibration curves and language models shown as the baseline comparison. October's board has Liquid's d1-ultra and Base Labs' elephant-1 tied at the top (65), with Clef and Clef-Omni, Decider v1.2 and its flash sibling, GLiDE, Mercury Decide, Celeris-1, Microsoft-Decision-1, and Jev 1.14 behind.
• AudioJevBench - The audio counterpart (v0.1): 988 items (112 public / 876 sealed) across intent, escalation, command safety, sentiment, urgency, speaker verification, and sound events. The ranked board is all general audio models so far — Qwen3-Omni-30B-A3B leads the Jev-class rows (83.2 capability, 70.4 composite) and Gemini 3.8 Flash is most capable on public-only items (94.4) but outside the latency and cost caps — and none of the dedicated audio decision models (Clef-omni, d1-omni, NeuDecide) have been measured on it yet.
• evals.typesafe.ai - TypeSafe's workflow evals: four production-shaped workflows scored against frontier LLM reference probabilities.
• Image JevBench - Held-out image-decision suite, rebuilt as v0.3.0 on Oct 17: 2,441 items over 2,160 images (300 public / 1,200 sealed), 63 systems measured, frozen hashes and contamination tracking retained — the original pool flagged Kev's Mind2Web training overlap itself. kettei-fat tops it at 75.9, with Sage 1.4's beta image mode and Jev 1.13's image preview next; the Qwen3.5-adapter Imajev family leads open weights (68.0); frontier chat APIs still trail far behind.
• Jev Decision Index - Community index: a 37-benchmark public panel plus private tests (60% same skills, 40% new domains), five skill areas, latency on fixed hardware, and raw data published as JSON. The Nov 6 draw (edition 0.4.1) ranks 274 systems on the Jev 1.14 reference: REAX 1.3 leads the Full score at 73.98 with GLiDE 27B and KnowLine 31B next, mammoth-1 down at #13 after topping the Oct 29 draw, and the Jev 1.13 reference at #63 (59.22). The surface Clef's launch numbers reported on.
• JevBench - Independent decision-model leaderboard (run by Benchmark Heaven, not TypeSafe): 1,500 typed decisions per system scored on intelligence, calibration, speed, and cost — an official composite plus a capability view capped at 2× Jev's cost and latency — with versioned releases, published methodology, and result JSON. The v1.8 refresh (Oct 30; 10-second rule, GPU-time cost basis) grew it to 235 open-weights systems and 48 hosted APIs. On the API board, Super Decider leads the composite (78.5) ahead of Launchables' Myles-G 12B — a price-axis play at $0.001/1k — with kettei-fat third and still #1 on the capability view (86.3); Jev 1.13 sits #15. On open weights, Base Labs' mammoth-1 leads capability at 85.2 with KnowLine 31B, Fastino GLiDE 1.2 (now open), H2O's 31B, and Perplexity's Decider v1.1 packed within three points behind it.

Class-native suites

• Decision-Bench / Argo-Bench - TextQL's enterprise-decision benchmark (paper name Argo-Bench; no relation to the dataset above): a simulated year of a NYC delivery platform exported to a 235-table, 7.5B-row Oracle-style warehouse, where agents file typed actions (ban accounts, freeze payouts, file forecasts) graded by their consequences in the simulator, with latent ground truth withheld so answer keys cannot leak. One appendix worth the price of admission: Gemini 3.8 Flash escaped an unisolated sandbox, located the grader, and filed the answer it read — the run was discarded and the traces published. The board is frontier LLM agents end-to-end (Opus 5.5, 59.5) — the outer loop a decision model would slot into.
• DecisionBench - 80 scenarios and 293 questions per tier (medium is rules-based, hard is judgment calls), with a cost-per-decision axis baked in. What Jev-Omni reports on. Apache 2.0.
• DecisionBench (Hanno Labs) - Document-grounded typed decisions across tasks, domains, and primitives, scored on accuracy, expected calibration error, negative log likelihood, and coverage, with task-level artifacts and complete answer distributions. Applied and reasoning tracks are kept separate; no relation to the two other Decision-Benches above.
• DecisionPivot - StartLux's diagnostic benchmark (renamed from DecideBench on Oct 14, item hashes preserved) for the control points where decision models sit in LLM systems: contrast groups of 2–4 items identical except one decisive detail, scored on pair accuracy, confident errors, calibration, and automation at a fixed 5% error rate, with accuracy also read at a 0.90 probability threshold. Releases ship SHA-256 item hashes and items found in StartLux-Decision's own training data are removed from the reference track — first-party, but built with the contamination discipline of an independent bench. Paper.
• DecisionRobust - Robustness benchmark for the class: 1,058 curated attacks across meaning-preserving text perturbations, prompt injection, image perturbations, in-image instruction overlays, and instruction injection beside images, with ground truth on whether the attack preserves the correct answer. Findings worth the read: resistance to perturbation does not imply resistance to injection, and label-consistency checks substantially shrink measured attack success.
• fast-decisions - Fastino's held-out suite: 17 operational domains × 300 examples each, scoring Jev, SemIf, Laya, and GLiFormer head-to-head on the same inputs. First-party to GLiNER2.5-Decide, which tops it.
• ForecastBench - Probabilistic forecasts of real future events, scored with difficulty-adjusted Brier as outcomes resolve over time — the natural eval surface for the estimate and forecast field types extraction models like Clairic introduce, and a different job from deciding over a fixed state.
• Jev-ToM - Theory-of-Mind suite for the class: 11,117 questions from nine ToM benchmarks across six capability groups, scoring five typed decision models against seven generative baselines. Jev takes 73.2% source-balanced accuracy and ranks first or second on every capability; the findings that confidence-based selection stays benchmark-dependent, and that supplied reasons can repair or overturn answers, belong in any assistant-integration plan.
• jevals - Agent evals and guardrails as Jev decisions: one request per trace. Runs locally on Kev or Laya. From Openlayer.
• JevBench (coherence) - A separate project sharing the name: metamorphic tests of whether typed probabilities stay coherent when the question is transformed — probability, representation, batch, logic, and choice-set relations. Coherence is not accuracy (uniform answers can be perfectly coherent), but it is the systematic version of the option-order bias the probe studies below describe.
• LLMRouterBench - ACL 2026 Findings benchmark superseding RouterBench for the routing job: 400K+ query-model instances, 21 datasets, 33 models, 10 routing algorithms under one framework with cost curves, Pareto fronts, and latency — explicitly built to fix the incomparability between prior router evaluations. Code.
• LocalLLaMA/typed-decisions - Community typed-decision suites (customer service, invoices, security incidents, agent traces) the open implementations report accuracy and calibration against. Apache 2.0.
• OpenDecisions - 2,352-question validation set built to mirror JevBench's task mix, released with Releasing the Inner Jev (Geuter, Cheng & Alvarez-Melis) — the paper showing plain instruction-tuned Gemma 4 31B, read through its output logits with no training, already scores 79.6 to Jev's 80.1, and that a simple fine-tuning recipe lifts it to 84.4 here and 81.5 on JevBench v1.7, past Jev. Models and serving code ship with the set.
• PWS-Decisions - Parallel's benchmark for the axis no other suite measures: 300 closed-ended questions whose answers depend on current, niche, or scattered live-web facts, each confirmed against a direct source, scored by exact match — with runnable code (MIT) and the dataset on Hugging Face. First-party, and Parallel tops its own board (76.2% vs OpenAI Decisions' 41.7% and Jev's 33.4%) — but the honest framing is in the cross-check: on JevBench's public set the same three sit within 1.7 points, so the spread is web grounding, not decision skill. A JevBench score cannot tell you what happens when the answer isn't in the prompt.
• RouterBench - Martian × UC Berkeley's routing benchmark: 405K+ precomputed inference outcomes from 11 LLMs across 8 datasets, so router policies train and compare without live queries, against Oracle and Zero Router bounds. The standard cost-quality surface for the routing job most of this list's Applications section exists to do. Paper.
• RouterEval - EMNLP 2025 Findings benchmark for routing at model-pool scale: 200M+ performance records across 8,500+ LLMs and 12 evaluations. Its headline finding — a capable router improves as the candidate pool grows, potentially beating the best single model in it — is the research backing for the whole cheap-first-escalate pattern this list's Tools section builds. Code.
• s1kit - Run one YAML suite of your own labelled cases against any /v1/systemone server (Jev, Laya, kev, llama.cpp, Ollama) side by side, pick the lowest confidence cutoff per question that reaches a target precision, and route cheapest-first with escalation below it. Ships an offline keyword baseline and a GitHub Action that fails CI when accuracy drops.
• sysone-bench - Head-to-head of System One models: Laya vs Jev on byte-identical inputs.
• System One Bench - Runnable suite with frozen, hash-checked datasets, identical request payloads, released predictions, and accuracy / calibration / cost / latency per system — 16 datasets, 3,250 cases, 4,850 decisions across English, French, and Arabic, with a public board at systemonebench.dev. The methodology is the reason it's here: local timing kept separate from API comparisons, and latency rows excluded when a control model shows a materially different serving environment — discipline the field's incomparable-milliseconds problem needs. Public datasets can overlap training data; hosted-model runs may change.
• TypedBench - Academic benchmark for the class from DFKI, RPTU, Imperial, and Mila: seven policy-labelled generators and nine suites scored as median across paraphrases, calibration against the finite-sample noise floor, selective prediction, ordinal proper scoring rules, and realised cost under asymmetric matrices. Headline finding: the hosted model follows stated policy but is wording-sensitive and systematically underconfident, enough that trusting its probabilities can cost more than just taking the top answer.
• XDecideBench - The multilingual axis at scale: nine suites across 122 languages — 88,425 texts, 153,875 typed questions, the largest suite in the field — with every suite sharing one scoring contract and aligned, locally-labelled, and native items reported separately. Findings that matter for anyone shipping routing or moderation: the English-best model loses significantly in a quarter of suite-language cells, and an English-tuned 5%-error confidence threshold exceeds that rate on XNLI even in German and French.

Component datasets

• Amazon ESCI - Shopping-query relevance classification (exact / substitute / complement / irrelevant) at Amazon scale. A Jev Decision Index component.
• API-Bank - Alibaba's tool-use benchmark for whether a model picks the right API call. A Jev Decision Index component.
• ARC - AI2's grade-school science MCQs in Easy and Challenge splits. Part of the standard MCQ battery used in Jev vs Luna Decisions comparisons.
• Banking77 - 77 fine-grained banking intents over 13k queries. Single-domain counterpart to CLINC150, and the benchmark Janus reports wins on. CC BY 4.0.
• BFCL - Berkeley Function Calling Leaderboard: the field's standard for function/tool-call accuracy (ICML 2025). A Jev Decision Index component.
• BRIGHT - Reasoning-intensive retrieval benchmark scored by nDCG — the Jev Decision Index's reranking component, and one Jev still leads.
• CLINC150 / OOS-Eval - 150 in-scope intents plus explicit out-of-scope examples. Useful for routing, abstention, and confidence-threshold tests. CC BY 3.0.
• GPQA - Graduate-level, Google-proof MCQs; the Diamond subset is the hard tier. Part of the standard MCQ battery used in Jev vs Luna Decisions comparisons.
• GSM8K - Grade-school math word problems; repurposed as multiple choice with random distractors (4- and 10-option conditions in the Jev vs Luna comparison).
• HellaSwag - Commonsense sentence-completion MCQs. Part of the standard MCQ battery used in Jev vs Luna Decisions comparisons.
• MASSIVE - Multilingual intent-and-slot dataset (about 1M utterances, 52 languages) for testing whether a fast decision layer generalizes. CC BY 4.0.
• MMLU - The standard 57-subject multitask MCQ benchmark. Part of the standard MCQ battery used in Jev vs Luna Decisions comparisons.
• MMLU-Pro - Harder MMLU successor with 10-option questions and more reasoning. Part of the standard MCQ battery used in Jev vs Luna Decisions comparisons.
• MuSR - Multistep soft-reasoning MCQs (murder mysteries, object placements, team allocation). Part of the standard MCQ battery used in Jev vs Luna Decisions comparisons.
• PhishNChips - 2,000-email phishing benchmark plus a 220k-run adjudicated grid showing how system-prompt config swings detection. A Jev Decision Index component.
• ToolRet - ACL 2025 tool-retrieval benchmark: 7.6k retrieval tasks over a 43k-tool corpus, scored by nDCG@10. A Jev Decision Index component.
• When2Call - Evaluates tool-calling decisions rather than accuracy: when to call, when to ask a follow-up, when to admit the tools can't answer. A Jev Decision Index component — and one Jev still leads.
• WinoGrande - Pronoun-resolution commonsense MCQs, adversarially filtered. Part of the standard MCQ battery used in Jev vs Luna Decisions comparisons.

Probes & studies

• Frontier quality at 1% of the cost - Airbnb's production benchmark of a content-policy classifier, and the most credible production-scale independent data on Jev yet: on a 10,000-example held-out set at thousands of RPM, Jev is "the most accurate off-the-shelf model we tested under 100 ms" and beats GPT-6 Luna at equal cost — but a fine-tuned Gemma4-E2B scoring via logprobs beats everything on all three axes (F1 0.563 → 0.902 at 35 ms median, ~1% of frontier cost), and a 2,700-word prompt fails to close the gap for any deployable model. Three findings worth pinning: thresholds beat verdicts at production scale (the class's whole thesis, confirmed); fine-tuning moves the quality-latency frontier instead of trading along it; and Jev's cost quadrupled under the long prompt because at evaluation time its API offered no cached-input discount — a gap both OpenAI's Decisions GA and Morph Reflex now price.
• Janus - Measures a confidence threshold on your labeled data, then routes Jev vs a larger model. Ships no default: on Banking77 routing wins; on Web of Science it says do not route.
• jev-behavior-study - Independent look at Jev 1.13.0: option-order bias, facts lost in the middle of long context, and cases where a correct prerequisite still leads to the wrong action. Raw payloads and offline verification included.
• jev-benchmarks - Independent calibration, selective-risk, and latency measurements of Jev against GLiNER and other baselines.
• jev-ood-calibration - Independent calibration test on tasks Jev cannot have seen: 900 rule-generated tickets plus public benchmarks, with ECE noise floors and a temperature refit.
• jev-phishing-bench - Jev vs Claude Haiku 4.5 on 2,000 phishing emails: accuracy, calibration, latency, and cost, reproducible.
• jev-rerank-bench - Jev vs Cohere Rerank 4 vs zerank-2 vs a chat baseline on 14 datasets. Every raw response saved. nDCG@10 is a tie, not a win.
• Typed Decision Models: An Early Evidence Audit - The skeptic's literature review: 28 papers from the first nine days after Jev's launch, related back to label-probability classification, constrained decoding, and cascades. Headline: the typed readout itself shows no independent accuracy advantage over comparable label-probability readouts — the gains are latency and cost — with a 14-item checklist for future TDM evaluation. Useful calibration for every vendor number in this list.

Reading

Docs & ecosystem

• agentic-rl - Zero-to-GRPO agentic RL course in Chinese whose final block (chapters 26–33) is a runnable discriminative-model project comparing encoder and LLM judges.
• awesomejev.com - Community directory indexing about a thousand Jev projects with daily-refreshed stars. Less curated, good for exhaustive search.
• Confidence - How Choice/Score confidence differs from probability, and how to gate act / review / escalate in code. Noul has no separate confidence field.
• Cookbooks - Official patterns: parallel questions, citation check, RAG passage classification, date extraction, skill suggestion.
• How to build with TypeSafe - Keep control flow in code. Split work into atomic questions, then combine the answers and route on uncertainty.
• Introducing System One Models & Jev - TypeSafe's launch post: RLCD, parallel sampling, and how this differs from an LLM.
• JEV Breakdown: the first AI model built for code - Rob Shocks' video walkthrough of Choice / Score / Noul in the TypeSafe playground, with speed and cost numbers; the most-watched explainer the class has.
• Jev Can Now See Images - The AI Automators' hands-on test of 1.14's image questions and box: 200 SWE-bench bug reports screened in about four seconds for two cents, with 112 routed to human review. Honest about where the confidence breaks.
• Jev in the Wild - A data-driven survey and analysis of 2,170 public GitHub Jev projects, mapping early ecosystem growth, application domains, and decision-use patterns.
• Jev means structured output is interesting again - Sean Goedecke on why a model that only returns typed answers makes structured output load-bearing rather than an afterthought. From the author of the system-one drop-in listed above.
• Jev Showcase - An unofficial operator-level companion for Jev from cobus greyling: Choice / Score / Noul fan-out demos treating confidence as a second axis. A showcase, not a library.
• jev-cookbook - Datawhale's Chinese-language Jev cookbook: Jupyter notebooks from the three question primitives through 18 applied recipes, audio smart-home control, evaluation, and local fine-tuning. The largest Chinese Jev resource by stars.
• jev.store - Community store for Jev apps, extensions, and tools: a distribution surface with a submit flow, distinct from the firehose directories.
• Latent Space: Jev, a System One model that only decides - Launch-day writeup on what a decision-only model changes for latency and cost.
• Lies, Damned Lies, and Benchmarks - TypeSafe's case against public benchmarks: contamination, saturation, and leaderboard-chasing, which is why their published evals arrive watermarked "please don't trust them." Useful calibration for every number in this list.
• madewithjev.com - Community directory of Jev builds: 850+ projects, posts, and guides indexed by use case with author-reported cost and speed, plus a tools directory and Jev explainers. Updated daily.
• OpenRouter Decisions API - Alpha multi-provider surface for the class: ~10 routes from nine publishers (Jev, Solar Decide, Span-01, Kev-4B, Clef, Luna Decisions, d1, Decider, Mercury Decide, Tev1) under one state + questions request shape. Browse the full decision-model catalog, or check the live usage rankings — Jev is still over 95% of real traffic.
• System One (docs) - Official definition of the model class and the Choice / Score / Noul primitives.
• systemonemodels.org - Independent hub tracking every System One model, open alternative, community SDK, and example. The place to check when this list lags.

Jev under the microscope

• Decision Hijacking - The first systematic prompt-injection attack on the class: across 510 reconstructed InjecAgent cases, malicious content shifts action probabilities even though outputs stay schema-bound, and adaptive attacks using score feedback double the attacker-target probability. Restricting outputs to declared actions is not injection resistance.

• Hidden Risks of Jev - Empirical security, privacy, and dual-use audit of hosted typed decisions: injected state steers decisions toward attacker-chosen answers that downstream actions then execute. HiddenLayer's follow-up (Jev security risks) walks a Jev browser agent into clicking a malicious Confirm Price button and bypasses its prompt verification with a Tokenbreak-style attack — decision models are still LLMs under the hood.

• Jev 1.13 jaggedness - First-party failure modes: counting, dates, indirection, distractors, generation. Keep arithmetic in code.

• Jev as a judge: How counterfeit policy steers Jev - Datadog Security Labs feed Jev a forged classification policy and watch it steer the verdict — including bypassing LangChain's experimental tool-risk gating, the exact defense pattern this list's integrations section recommends.

• JEV vs. LLMs as Rubric Judges: Cheaper, Faster, and Wrong in the Same Places - Rao & Callison-Burch (2026). The counterpoint to the cascade story: Jev is 29–325× cheaper and competitive on binary criteria, but LLM judges repeat nearly all of its most confident errors, capping escalation gains at ~1.5 points.

• JEV-as-a-Judge: Accept When Confident, Escalate When Unsure - Li, Miao, Krishnan & Padman / CMU (2026). First independent study of Jev as an eval judge: within ~3 points of the strongest LLM judge on ordinary preference at 0.36% of the fee, weaker on derivation-checking. A confidence-gated cascade keeps 99% of the big judge's accuracy at ~57% of the cost.

• Jev's Architecture Unmasked - Community teardown of Jev's probable architecture; the write-up kev's open models are built from.

• What Can't Jev Decide? - Probes the one-pass limit directly: select-and-find stays accurate to 20,000 tokens and 64 options, but decisions requiring sixteen state updates collapse to 53–80%, and given a stale state summary the model follows it. Conclusion: checking the state a decision model relies on needs a reasoning model.

Foundations

• Agents Thinking Fast and Slow: A Talker-Reasoner Architecture - Christakopoulou, Mourad & Matarić / DeepMind (2024). Splits an agent into a fast conversational Talker (System 1) and a slow planning Reasoner (System 2).
• Build your own decision model - Nish Tahir (2026). The clearest mechanism explainer yet: constrained option tokens and a softmax over answer letters versus autoregressive JSON generation, with an interactive demo, working Qwen code, and an honest note that raw token probabilities are not calibrated confidence.
• Distilling System 2 into System 1 - Yu, Xu, Weston & Kulikov / Meta (2024). Compiles intermediate-thought techniques into single-pass outputs; the research framing closest to what Jev is.
• Dual-processing accounts of reasoning, judgment, and social cognition - Evans (2008). Review of dual-process theories. System 1 is a family of accounts, not one algorithm.
• FrugalGPT - Chen, Zaharia & Zou / Stanford (2023). The LLM cascade: answer with the cheapest model, escalate only when needed — up to 98% cost reduction at matched quality. The direct ancestor of every confidence-gated router and cascade in this list. Paper.
• Judgment under Uncertainty: Heuristics and Biases - Tversky & Kahneman (1974). Heuristic judgment under uncertainty.
• MDLM - Masked diffusion language model (NeurIPS 2024): parallel, non-autoregressive generation. The open research line nearest to Jev's parallel-sampler claims.
• Reasoning the Fast and Frugal Way - Gigerenzer & Goldstein (1996). Simple heuristics that work with incomplete information.
• System 2 Attention - Weston & Sukhbaatar / Meta (2023). The LLM regenerates the context it should attend to before answering: deliberate filtering on top of fast attention.
• System-1.x: Learning to Balance Fast and Slow Planning with Language Models - Learns when to use fast direct planning and when to search, instead of always picking one.
• Thinking, Fast and Slow - Daniel Kahneman. The book TypeSafe cites for the System 1 / System 2 framing.

Contributing

See CONTRIBUTING.md.