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.
• 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.
• 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. Cloudflare's runs put Clef first on the Jev Decision Index, 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.
• 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. Tops JevBench's open-weights capability view at 85.3 (I 80, C 91); the card is honest that most decisions are one pass but some take a short extra pass (p95 23.5 s), and its official composite lands #26 because each decision costs 1.55× Jev. Own 720-item held-out replica published. Apache 2.0.
• 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; d1-3B scores 48.57 on the Decision Index public split — best under 10B, on par with Decider 35B-A3B at 12× its size — at ~8 ms on an RTX 4090, 16 ms on Jetson AGX Thor. 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).
• decider - Qwen3.5 fine-tunes (0.8B up to a 35B MoE), a Gemma-4-12B variant whose v2 ranks #6 on JevBench's official open-weights composite (70.9), 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): JevBench's official open-weights composite ranks the 31B #3 of 192 (its v1.6.1 figure of 71.69 tied Jev and Quyet inside overlapping intervals; it leads Jev on sealed-set intelligence, 73.3 vs 61.6). 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.
• 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). Siblings JEV-27B-VL and JEV-9B trade speed for embodied precision, and the GuruSearch demo runs 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 #2 on the Decision Index's late-October draw (73.13 Full, behind only mammoth-1), 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.
• 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.
• 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).
• 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 ranks #1 of 27 under 1B on the Decision Index board; both models are on the board. 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.
• 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) but ranked #83 on the 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 on the Decision Index's October draw — Gen1.5 35B-A3B at #9 (70.72) and a Gen2.5 26B-A4B, three checkpoints in the top 25. Apache 2.0.
• 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 (52.3 on the Decision Index). 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.
• 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.
• 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 the 9B beside it. 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 tops the Jev Decision Index at 75.34 on the Oct 29 draw — #1 of 247, two points clear — and leads JevBench v1.8's open capability view at 85.2, while elephant-1 is the strongest under 15B there and 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).
• 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.
• 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.
• 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.
• 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. Apache 2.0, ships a CLI.
• 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.
• 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 #7 on the Decision Index (71.68) with the v2 27B also top-25. Thin on write-ups, thick on checkpoints — the evidence is the board.
• 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.
• 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.
• 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.
• Vela - KR Labs × vLLM Semantic Router's open decision-model family (0.3B–9B, bidirectional ModernBERT encoder, 17 languages, Apache 2.0). Choice, Noul, and Score plus two new question types: Span — labeled text spans with offsets for PII and unsupported claims — and Set multi-label. SystemOne-compatible HTTP and Python APIs, ONNX runtime, and a Core ML port with a Swift runtime for Apple silicon. Trained for router work: routing, prompt-attack, PII, and hallucination screening. The same org now also ships the six-size d3 line and Decision-2.0 builds (Vega-27B, Nox-4B) — and an EO-Jev study LoRA-adapts d3-flash into an earth-observation generalist (+8.0 across 12 held-out settings, at a documented 1.8-point general-decision cost), the first domain-adaptation recipe published for the class.
• 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.
• 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.
• 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 #2 on the Jev Decision Index 0.4 (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), 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. JevBench's API board ranks 1.13 #15 of 49 and the 1.14 preview #18. jev-1.14.0 is in preview (multilingual is the biggest gain), and opt-in "danger zone" headers unlock image inputs, 262K context, and a new box bounding-box type — the first System One output that isn't a decision. 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. 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).
• 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. The differentiator is state caching priced into the product: repeat a state and 91.6% of input tokens measured were reused at $0.008/M — the first entrant to bill cached decisions at a fifth of the fresh rate, which changes the economics of the ask-many-questions-over-one-document pattern the class exists for. 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.
• 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, announced at DevDay 2026: text or image context plus a fixed answer set, returning one answer with a confidence score around 150–230 ms. 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.
• 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.
• 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.
• 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.
• 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 - Open-source inference engine for decision models from the OneJev authors: claims up to 9.4× faster than LLM inference frameworks while preserving exact answers, with exact state forking and 19 model families served through /v1/systemone. Apache 2.0, pip install flide.
• 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.
• 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.
• jev-visual - Educational Jev-like visual inference experiment on Apple Silicon: shared context, direct candidate scoring, and local visual demos.
• LLM2Jev - Adapts local language models into Jev-compatible decision engines with Choice / Score / Noul outputs, via prefill-only binary inference. Apache 2.0.
• 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
• 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.
• 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.
• 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.
• 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.
• 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.

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.
• 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.
• jeview - Local visualizer for Jev: a live view of every call your code makes.
• 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.
• jev-foundation-models - Native Swift 6 bridge that puts Jev behind Apple's Foundation Models framework interface.
• 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.

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.
• 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.
• 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.
• 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.
• 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.
• 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 — 247 models on the Jev 1.14 reference in the Oct 29 draw. mammoth-1 leads the Full score at 75.34, with Jeffan-31b and StartLux v1.1 next; Jev 1.14 itself sits at 60.7. The surface Clef's launch numbers report 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

• 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.
• 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 (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.
• 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.
• jevals - Agent evals and guardrails as Jev decisions: one request per trace. Runs locally on Kev or Laya. From Openlayer.
• 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.
• 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.
• 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.
• 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.
• 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

• 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

• 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 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.
• System One (docs) - Official definition of the model class and the Choice / Score / Noul primitives.
• awesomejev.com - Community directory indexing about a thousand Jev projects with daily-refreshed stars. Less curated, good for exhaustive search.
• 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.
• 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.
• 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.
• 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.
• systemonemodels.org - Independent hub tracking every System One model, open alternative, community SDK, and example. The place to check when this list lags.
• 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 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.
• 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.
• 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.
• 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.
• 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 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 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 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'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-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.
• 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.
• Thinking, Fast and Slow - Daniel Kahneman. The book TypeSafe cites for the System 1 / System 2 framing.

Contributing

See CONTRIBUTING.md.