System One AI · Typed decisions

Decision Models: AI that decides, not drafts

A new class of model takes your application state and a structured question and returns a typed answer — a choice, a score or a yes/no — with a calibrated probability, in one fast pass.

System One · decision model

Fast, typed, calibrated

Returns a valid answer and a confidence, so code can act on it or escalate to a person.

System Two · LLM

Slow, free-form, flexible

Writes text token by token — great for reasoning and writing, heavier for simple decisions.

How a decision model works

Three inputs and outputs, whatever model sits underneath.

  1. Give it the state

    Pass the text or data the decision depends on, such as a support ticket, an email or a record.

  2. Ask a typed question

    Define the question and the allowed answers: an enum, a yes/no or a rating scale.

  3. Get a decision and a probability

    Receive the chosen answer plus calibrated confidence for each option, in a single pass.

Choice

one of N labels

Classify or route: pick the right category, queue or action.

Yes / No

probability 0–1

A boolean with a probability, for example “does the user want a refund?”.

Score

ordinal level

Rate on a scale such as urgency, sentiment or quality.

What Thoughtworks says

An independent view from the Technology Radar, summarised in my own words.

Technology Radar Vol 35: Assess

In its November 2026 Technology Radar, Thoughtworks lists decision models as a platform to assess. It describes them as a new class of model that appeared since the previous volume, names Jev, Laya, Nimble and Kev, and contrasts them with deliberative reasoning models: instead of writing text, they return predefined structured values.

  • Calibration: the entry says Jev is trained with reinforcement learning from calibrated decisions (RLCD) rather than RLHF, so that predicted probabilities match how often an outcome actually occurs.
  • Question types: a model receives a state and questions of three types: Noul (yes/no, returning the probability of yes), choice (categories) and Score (an ordered scale).
  • Use cases it lists: Jev as a judge instead of an LLM as a judge, model and tool routing, policy gates and bulk labeling.
  • Advice: avoid overenthusiastic LLM use, and set evaluation criteria to decide whether a decision model can replace an LLM for classification. The entry links to Radar items for LLM as a judge (Assess) and overenthusiastic LLM use (Hold).
Read the Radar entry → The ring and use cases come from the Radar entry published on 4 November 2026.

The references: Jev and Drex

Jev is the model most open projects set out to match. Drex is a second family of decision models from Nace.AI that keeps Jev's request format.

Jev by TypeSafe AI

TypeSafe AI's first public System One model, built for “decisions inside software” rather than text generation. It returns typed decisions with calibrated probabilities so automation can tell when to act and when to hand off.

  • Trained with TypeSafe's Reinforcement Learning for Calibrated Decisions (RLCD) approach; see the RLCD page for the calibration ideas behind it.
  • TypeSafe claims it runs about 194× faster and 445× cheaper than LLM alternatives on comparable tasks.
  • Listed at $42 per billion input tokens.
Visit typesafe.ai →

See how a decision model can sit between retrieval and generation: RAG vs. Jev + RAG.

Performance and price figures are TypeSafe's own claims. Jev is a hosted service; the projects below are open alternatives.

Drex by Nace.AI

A family of decision models that read a state and typed questions (choice, yes/no, ordinal score) and return a probability for every option in one forward pass, with nothing generated. Drex keeps the Jev request and response format, so the TypeSafe SDK and the /v1/systemone endpoint work with it, and the weights can be run on your own hardware.

  • Drex v2.0: the flagship, built on Qwen3.6-35B-A3B, a mixture of experts with 35B parameters and about 3B active per token, with a Kev-style pointer head.
  • Drex v1.5: a 9B model built on MiMo-V2.6-Distill-Qwen-9B, described in the paper Towards Foundation Decision Models: Drex.
  • Drex Max: a hosted variant listed on OpenRouter; the open checkpoints are v1.5 and v2.0.
  • Licence: Nace.AI Open RAIL-M, an open-weights licence with use restrictions, not Apache-2.0 or MIT. Read it before commercial use.
  • Run it: Python with a CUDA GPU, or llama.cpp and Ollama forks for Apple silicon and CPU. The model cards give about 70 GB for v2.0 in bf16 and 37 GB as a Q8_0 GGUF, and about 18 GB and 9.5 GB for v1.5.

Reported results, from Nace.AI's own runs. On the public Decision Index 0.3.1, the Drex v2.0 model card lists 61.25 against 57.96 for Jev 1.13.0, with v1.5 at 58.08. On JevBench Jev scores 86.6% and Drex v2.0 85.7%, and on DecideBench v1.1 Jev scores 98.0% and Drex v2.0 96.5%. Drex v2.0 reports an email-classification AUC of 0.984 against 0.981 for Jev, and a 60.9% score against Jev in an eight-game arena. The cards say these are not official leaderboard submissions, and I found no independent reproduction, so treat the figures as leads to check on your own data. Jev leads on some benchmarks and Drex on others.

Drex v2.0 model card →

Repository · Hosted API docs · Drex v1.5 · Decision Index leaderboard · nace.ai

Performance figures are Nace.AI's own, from the Drex model cards read on 7 November 2026. Hosted prices differ between listings, so check the current pricing page.

Try decision models online

Two browser playgrounds, plus a Cloudflare-hosted decision model you can call through an API, so you can run typed decisions without installing anything.

AMulti-model playground and API

Decisions API

A single playground and API for comparing decision models. Its site lists Jev, Laya, Kev, Solar and Span, with a workbench where you define typed questions and preview the request, and an example library that includes support triage, content moderation and lead scoring.

The site says the online playground is free to use. Check its pricing page for API access.

BIndependent Jev playground

Jev playground and developer tools

A playground, API guide and examples for Jev, the TypeSafe AI decision model. It offers a free in-browser demo, use cases, integrations and an agent skill.

This site describes itself as independent, so it is not TypeSafe AI's own site. The official Jev site is typesafe.ai, linked above.

CCloudflare-hosted decision model

Clef on Cloudflare Workers AI

by Cloudflare

A 27B multimodal decision model that turns a state and a schema of typed questions into decisions. It reads the state as text, JSON, images or video, and returns a probability for every allowed option of every question.

Size
27B parameters
Context window
65,536 tokens
Access
Workers AI API (@cf/cloudflare/clef)

Best forTyped decisions over text, JSON, images or video on Cloudflare's platform.

Hosted on Cloudflare, so it is a managed alternative to Jev rather than an open-source one. Check the model page for current pricing and licence terms.

14 open Jev alternatives

Three design families: small encoders that score options directly, LLMs read through their logits, and LLMs with dedicated decision heads.

01Encoder + decision head

Laya

by NandhaKishorM (Convai Innovations)

A non-autoregressive decision engine that scores the question and its options together in one forward pass. Supports choice, score and yes/no questions across 100+ languages, with calibrated probabilities and optional abstention.

Base
ModernBERT-large (English), mmBERT-base (multilingual)
Size
322M–421M parameters
Licence
Apache-2.0

Best forFast multilingual decisions on small models.

Ships an HTTP server compatible with Jev's, plus LangChain and MCP integrations. Its package page reports about 7.8× lower latency than Jev on its own benchmarks and notes Jev does better on label sets of 50+ options.

02LLM logit readout

Nimble

by Bespoke Labs

Adds Jev-style behaviour to an existing open LLM: it reads the model's scores for the permitted answer tokens and turns them into probabilities, instead of generating text.

Base
Qwen3.5-9B with rank-16 LoRA
Size
9B parameters
Licence
No license listed on GitHub

Best forTraining, research and studying the data-curation recipe.

Publishes the model, training recipe, evaluation setup and data-curation pipeline.

03LLM + decision heads

Kev

by Jared Palmer

A family of small decision models you can train and run yourself. Handles yes/no, multiple-choice and rating questions in one request, and its server is designed so the TypeSafe Python SDK works against it unchanged.

Base
Qwen3.5 (0.8B, 4B, 9B) and Qwen3.8-27B
Size
0.8B to 27B parameters
Licence
Apache-2.0

Best forJev-compatible local deployment and fine-tuning on your own data.

Runs on CUDA, ROCm or Apple Silicon (MLX); the largest model handles up to 65,536 tokens of state.

04LLM logit readout

SemIf

by Theo Lee (independent)

A research experiment that needs no fine-tuning: it reads the logits for the allowed answers straight from an open model. The demo compares that direct readout with asking the model to write probabilities as JSON.

Base
Qwen3 0.6B, MiniCPM5 2B or Qwen3.5 4B
Size
Model-dependent
Licence
MIT

Best forExperiments and trying System One ideas on models you already have.

Formerly called OpenJev; independent and not affiliated with TypeSafe. Not the same project as lookski's OpenJev, listed below. The demo runs fully in your browser via wllama.

05LLM logit readout

Rizzo Flow

by Rizzo AI Academy

The open, local take on Jev: it limits each decision to a set of answer tokens, reads their logits and converts them to probabilities, without generating any text.

Base
Open Spark-X2.5 models served with llama.cpp
Size
About 1.7B–4B parameters
Licence
Apache-2.0

Best forLocal deployment on varied hardware, with a Jev-like HTTP interface.

Change the base URL to point existing Jev clients at a local server.

06Encoder + decision head

Von

by wfzyx

A compact, non-autoregressive System One model that uses option markers to produce scores for choice, yes/no and score decisions directly.

Base
ModernBERT (about 395M parameters)
Size
~395M parameters
Licence
Apache-2.0

Best forSmall, fast inference on CPU or modest GPUs.

Targets sub-15 ms decisions; runs on CUDA, ROCm, Apple Silicon and CPU.

07LLM + decision heads

NanoJev

by Tianyu (TianyuCodings)

A small, trainable Jev-style replica with parallel decisions, dynamic candidates and an end-to-end training pipeline.

Base
Qwen3-0.6B
Size
0.6B parameters
Licence
MIT

Best forLearning how Jev-style architectures are built and trained.

Designed as a nano-scale replica for experimentation.

08LLM + decision heads

Strands Decider

by Strands Labs

A small, fast decision model for agentic workflows. It picks between options or rates something on a scale, returning a calibrated confidence with every decision, and ships a command-line tool and an inference server.

Base
Qwen3.5-2B-Base with the language head replaced by a pointer head, plus a rank-16 LoRA adapter
Size
About 1.9B parameters
Licence
Apache-2.0

Best forDecisions inside agents built with the Strands Agents SDK.

The project reports that answers at a confidence of 0.9 or higher were right about 95% of the time on short classification tasks it had not seen; treat that as the authors' own evaluation.

09Encoder + decision head

Verdict

by Heman10x-NGU

A non-autoregressive decision engine that evaluates several typed questions in one forward pass and returns calibrated probabilities, inspired by Jev and trained with an RLCD-style calibration approach. Includes an in-browser WebGPU playground.

Base
ModernBERT with a GLiClass backbone
Size
151M parameters
Licence
Apache-2.0 (per its README; GitHub shows no detected licence)

Best forCompact, fast decisions, including in the browser.

Its README reports its own JevBench results and describes inference fixes, such as automatic calibration and a shorter context budget, that changed outputs without retraining.

10LLM logit readout

AnyJev

by Nokia Applied Research (Jiamu Zhang and colleagues)

Turns an existing LLM into a Jev-style decision model with typed answers and real probabilities and no training. It also offers Tacit, self-distilled decision models that need one forward pass per decision. Its reader tries rotated option orders to reduce position bias.

Base
Any open LLM; Tacit models are distilled from open bases
Size
Tacit models 1.7B to 9B parameters
Licence
Apache-2.0

Best forAdding calibrated decisions to a model you already run.

The README reports a Decision Index leaderboard result for the training-free reader on an unchanged Gemma model; treat leaderboard and benchmark claims as the authors' own.

11LLM logit readout

Simple Jev

by Featherless AI

Turns compatible open Hugging Face models into classifier endpoints without training a separate classifier head. It sends shared context and questions, reads the model's next-token logits and builds the JSON response itself, so the model does not write JSON. A public demo API is available.

Base
Compatible open models from Hugging Face (the demo serves a Gemma classifier)
Size
Model-dependent
Licence
Apache-2.0

Best forTrying a logit readout on open models with a ready HTTP endpoint.

The public demo has a 2k-token context limit and a rate limit of 2 requests per second, according to its README.

12LLM logit readout

OpenJev (lookski)

by lookski

A local decision engine that turns a small LLM, or any OpenAI-compatible API, into a typed decision service using masked-logit softmax: it masks the answer-token logits and returns raw probabilities in one forward pass.

Base
Any local LLM (its demo uses Qwen3-0.6B)
Size
Model-dependent
Licence
MIT

Best forRunning typed decisions fully on your own machine.

Not the same project as SemIf, which used the OpenJev name earlier. The repository is small and young, so check its activity.

13LLM + decision heads

Drex

by Nace.AI

Open-weight decision models that return a probability for every option of every typed question in one forward pass, using a pointer head on an LLM backbone. They serve the same /v1/systemone API as Jev, so existing Jev clients can point at a Drex server.

Base
Qwen3.6-35B-A3B (v2.0), MiMo-V2.6-Distill-Qwen-9B (v1.5)
Size
35B total, about 3B active (v2.0); about 9B (v1.5)
Licence
Nace.AI Open RAIL-M (open weights, use restrictions)

Best forTeams that want a Jev-compatible model they can host themselves and are comfortable with the RAIL licence.

Results come from Nace.AI's model cards and are not independently reproduced. The weights are large compared with the encoder models above, and the Python server needs a CUDA GPU.

14LLM + decision heads

Perplexity Decider

by Perplexity

Decision models that read text, JSON or images plus typed questions and return a probability for every answer: yes/no, multiple choice or an ordered score. Version 1.3 adds locate, which returns the matching text spans from the state with character offsets. Perplexity says Decider is inspired by Jev.

Base
Qwen3.8-27B (Decider v1.3); Qwen3.5-4B, distilled from the 27B model (Decider Flash v1.3)
Size
About 27B and 4B parameters
Licence
Apache-2.0

Best forTeams that want an open-weight, multimodal decision model with a hosted API, or span extraction for entity, PII and extractive question answering.

Perplexity released v1.3 on 12 November 2026. Its post reports 91.6% mean accuracy on 63 query-classification tasks and gains over Jev 1.14 in its own tests; these are Perplexity's figures and I found no independent reproduction. The hosted Decisions API uses its own /v1/decisions endpoint and is listed at $0.02 per million input tokens for v1.3 and $0.01 for Flash, so check the current pricing page. The model card lists about 49 GiB of BF16 weights for v1.3 and 8.5 GiB for Flash.

A hands-on test: decision models vs. a prompted LLM

On 15 October 2026 Lambert Leong published a test on Towards Data Science that compared seven of these projects with a plain JSON-generation baseline from Qwen3-0.6B. It used banking requests from the BANKING77 dataset in two settings: the same eight routes for every request, and a fresh menu of four candidate routes for each request. The figures below are his and cover a small test, so treat them as leads to check, not a ranking.

ConfigurationFixed routes (200 requests)Changing candidates (100 requests)
Kev 0.8B98.0%98.0%
Laya92.0%74.0%
Verdict86.5% (8 abstentions)89.0% (3 abstentions)
LLM baseline: Qwen3-0.6B writing JSON83.0%66.0%
AnyJev L0 + Qwen3-0.6B79.5%56.0%
Simple Jev + Qwen3-0.6B79.0%58.0%
OpenJev (lookski) + Qwen3-0.6B79.0%60.0%
NanoJev52.0%17.0%

What stood out. The trained scorers returned answers without generating any answer tokens, where the JSON baseline wrote about ten per request. The author recorded median request latencies of 125 to 130 ms for Kev and 17 to 18 ms for Verdict against 331 to 357 ms for the baseline, measured on Colab GPUs at batch size one with different timing boundaries. All nine of the baseline's failures on the changing menus were valid JSON wrapped in markdown fences that a strict parser rejected. The three training-free Qwen readouts did not beat plain JSON generation on accuracy, and NanoJev's game-trained checkpoint accepted new menus but scored only 17% on banking requests, so a flexible interface does not guarantee accuracy.

Limits. The test used twelve BANKING77 intents and 300 requests per run, one small baseline model, and did not test calibration, confidence thresholds, long documents, other languages or production tool use. Run the same comparison on your own routes before choosing. Sources: the article, its starter notebook and the BANKING77 dataset.

Side-by-side

Licences for the first eight projects were read from each GitHub repository on 3 October 2026, for the four added on 17 October 2026, and for Drex from its Hugging Face model cards on 7 November 2026.

ProjectApproachBase modelLicence
LayaEncoder + decision headModernBERT-large (English), mmBERT-base (multilingual)Apache-2.0
NimbleLLM logit readoutQwen3.5-9B with rank-16 LoRANo license listed on GitHub
KevLLM + decision headsQwen3.5 (0.8B, 4B, 9B) and Qwen3.8-27BApache-2.0
SemIfLLM logit readoutQwen3 0.6B, MiniCPM5 2B or Qwen3.5 4BMIT
Rizzo FlowLLM logit readoutOpen Spark-X2.5 models served with llama.cppApache-2.0
VonEncoder + decision headModernBERT (about 395M parameters)Apache-2.0
NanoJevLLM + decision headsQwen3-0.6BMIT
Strands DeciderLLM + decision headsQwen3.5-2B-Base with pointer headApache-2.0
VerdictEncoder + decision headModernBERT with a GLiClass backbone (151M)Apache-2.0 per README
AnyJevLLM logit readoutAny open LLM; Tacit models 1.7B to 9BApache-2.0
Simple JevLLM logit readoutCompatible open Hugging Face modelsApache-2.0
OpenJev (lookski)LLM logit readoutAny local LLM or OpenAI-compatible APIMIT
DrexLLM + decision headsQwen3.6-35B-A3B (v2.0), MiMo-V2.6-Distill-Qwen-9B (v1.5)Nace.AI Open RAIL-M

Frequently asked questions

What is a decision model?

A decision model, also called a System One model, takes application state and a structured question and returns a typed decision — such as a choice, a score or a yes/no — together with a calibrated probability. It answers in a single fast pass instead of generating text token by token.

What is Jev?

Jev is TypeSafe AI's first public System One model, built for decisions inside software rather than text generation. TypeSafe describes it as returning typed decisions with calibrated probabilities so software can decide when to act automatically and when to escalate to a person.

What is Drex?

Drex is a family of decision models from Nace.AI. Like Jev, it reads application state and typed questions and returns a probability for every option in one forward pass instead of generating text. Drex v1.5 is a 9B model and Drex v2.0 is a 35B mixture-of-experts model with about 3B active parameters. Both use Jev's request format and are released as open weights under the Nace.AI Open RAIL-M licence.

Is Drex better than Jev?

Not clearly. On the Drex v2.0 model card, Drex scores higher than Jev 1.13.0 on the public Decision Index 0.3.1 (61.25 against 57.96) and on an email-classification test, while Jev scores higher on JevBench (86.6% against 85.7%) and DecideBench (98.0% against 96.5%). These are Nace.AI's own runs, not official leaderboard submissions, and I found no independent reproduction. Test both on your own decisions.

How is a decision model different from an LLM?

An LLM writes free text that your code must parse and may get wrong. A decision model is built to return only valid, typed answers with confidence, which makes it faster, cheaper and easier to wire into automation. LLMs remain better for open-ended writing and complex reasoning. Thoughtworks' November 2026 Technology Radar lists decision models as Assess and advises defining evaluation criteria before replacing an LLM for classification.