Jev and the decision-model wave, explained — and how to run one on your own machine

Decision models are language models that never write. You give one some text and a list of typed questions; it gives back a probability for every allowed answer, all at once, in well under a second. TypeSafe AI launched the idea as a product called Jev on 15 September 2026. Two weeks later there are about 70 open reproductions, and since Ollama 0.35 you can run three of them locally with one command. This post explains how they work, what the benchmarks do and don't show, and where they fit next to the chat models you already run.

If you only want to get one running, skip to the setup guide.

---

Two weeks that created a model category

The speed says something. The idea — score a fixed set of answers instead of generating one — is not new. What Jev did was package it as a clear interface with a name, a pricing story and a claim that it beats chat models at their own automation game. The open-source community reproduced the interface within a day.

Why "System One" and why "Jev"

The names are a thesis. Daniel Kahneman's Thinking, Fast and Slow splits thinking into fast, intuitive System 1 and slow, deliberate System 2. Chat and reasoning models are drifting further toward System 2: long chains of thought, minutes per answer. TypeSafe's bet is that most automation needs System 1 — thousands of quick, narrow judgments per minute — and that a model built only for those can be far cheaper and faster.

Jev is named after William Stanley Jevons, whose paradox says that making a resource cheaper to use increases total demand for it. TypeSafe's founder, Diogo Almeida, who worked on the instruction-following research behind ChatGPT at OpenAI, argues that every order-of-magnitude drop in the cost of a decision unlocks new uses for them.

How a decision model works

A chat model answers by generating: one token at a time, each conditioned on the last, until it stops. The result is a string. If your software needs a label, you parse the string, validate it, and handle the times it says something off-list, refuses, or wraps the answer in a paragraph.

A decision model answers by scoring. You declare the possible answers up front. The model reads your state and question once and computes how likely each allowed answer is. There is nothing to parse: the output is a probability distribution over exactly the options you listed.

TypeSafe hasn't published Jev's architecture. The open reproductions document theirs, and most follow the same recipe: render the state, question and options into a prompt; run one forward pass of a fine-tuned language model; read the logits at the answer position; and take a softmax over only the allowed options. Some read every question's answer slot from one pass; others, like Winnow, process the shared state once and branch per question. Either way, ten questions about the same ticket cost far less than ten separate chat calls.

That's also where the famous claim comes from. Jev "can't hallucinate" in a precise, narrow sense: it can't return an answer that isn't on your list. It can absolutely return the wrong one from your list. Keep those apart and most of the marketing gets easier to read.

Anatomy of a request

Every decision request has two parts:

• State — the text you want judged. A string or a JSON object: a ticket, an email, a log line,

an LLM's draft reply.

• Questions — named, typed questions about that state. There are three types:

"Noul" is TypeSafe's own word for a yes/no question. It returns a number, not a boolean — your code chooses the threshold.

What decision models are good for

TypeSafe describes them as smart if-statements: your code stays in charge of the workflow, and the model answers narrow questions where hand-written rules are too brittle.

• Ticket and email triage — route, prioritise, detect refund or churn intent.
• Guardrails — screen an LLM's input for injection and its output for policy violations before

a user sees it.

• Agent tool choice — pick one tool or skill from a fixed catalogue.
• Model routing — send easy prompts to a small local model and hard ones to a big one.
• Map-reduce over data — turn millions of rows of free text into labelled features.
• Real-time apps — Ollama's own demo has Nimble 9B playing Pac-Man at an average of 91 ms per

decision on an M5 Max MacBook Pro; TypeSafe's demo plays Doom.

They're the wrong tool for anything that needs words out. They can't summarise, draft, explain or chat. TypeSafe says so plainly: Jev isn't trained to generate text.

What the benchmarks actually say

This is where I want you to slow down, because two sets of numbers are circulating and they tell different stories.

Benchmark 1: Bespoke Labs' public suite. Thirteen public datasets with human labels, 3,880 decisions. This is what Ollama quotes on its model pages:

Read on its own, it says a free 9B model running on your laptop matches Jev.

Benchmark 2: the community Decision Index 0.2.1. Maintained on Hugging Face by multimodalart and contributors, unaffiliated with TypeSafe. It scores entrants on a frozen panel of 38 benchmarks in five equally weighted areas — Knowledge & Reasoning, Language Understanding, Retrieval & Classification, Tools & Automation, and Arts & Human Taste — and reports a chance-corrected index where 0 is random guessing and 100 is perfect:

Read on its own, it says Nimble is 18 points behind Jev.

Both are right. The Bespoke suite is mostly the everyday classification that small decision models were trained for. The Decision Index includes graduate-level science questions, tool retrieval, chess positions and forecasting, where model size and base-model knowledge matter much more. My rule for this site: we show both, always labelled with the benchmark's name, and never on the same axis. The only benchmark that decides which model you should use is 100 of your own labelled examples — here's how to run one.

Two more cautions from the Index's own notes. Reproductions were run on one RTX PRO 6000 GPU, while Jev was called over its hosted API, so latency numbers aren't comparable across the two. And the best open models' calibration varies wildly — their expected calibration error ranges from 0.014 to above 0.5, against Jev's 0.074.

The open reproduction wave

Three patterns stand out in the 70 Decision Index entrants.

• Everyone builds on the same two bases. Most strong entrants are built on Qwen3.5, Qwen3.6 /

Qwen3.8 or Gemma 4. The top eight are all 25–33B-parameter models: six on Qwen 27B bases and two on Gemma 4.

• A strong base does most of the work. The top downloadable models — Rune 26B-A4B (57.4) and

AutoJev-27B (56.4) — sit within about 1.5 points of Jev. Some "inference technique" entries that add no new weights at all, just a scoring method on a stock model, score above 50.

• What's still missing matters more than what's there. The tracker lists it plainly: nobody has

Jev's weights, nobody has published the RLCD algorithm, and no open model yet matches Jev's calibration claims. The Index's news page also notes that studies of the best open scorers found their confidence does not reliably flag their own errors.

So the open models have caught up on accuracy with remarkable speed. Whether any of them has caught up on the thing TypeSafe says matters most — probabilities you can trust at face value — is an open question you should test rather than assume.

Calibration: the part the marketing skips

TypeSafe's pitch rests on calibrated probabilities: when Jev says 90%, it should be right about 90% of the time. That's what would let you automate the confident 90% of decisions and escalate the rest. Its training method is literally named for it — Reinforcement Learning for Calibrated Decisions.

Now read Ollama's API reference for the local version. Its confidence field is defined as one minus the normalised entropy of the probabilities — a measure of how peaked the answer is — and the spec says in so many words that it is not calibrated correctness. That's honest documentation, and it's the most important sentence in this whole topic for anyone building on local models. A model can be peaked and wrong.

Bespoke's own Nimble README says the same thing differently: a probability of 0.9 still doesn't mean the answer is right 90% of the time; test your thresholds on your own data.

The Decision Index publishes per-model reliability data, and it's worth a look. On its calibration sample, even Jev is somewhat overconfident at the top end: when it gave its answer about 85%, it was right 71% of the time. Tev1 4B behaves almost identically. Nimble v2 tracks the diagonal more closely, with an expected calibration error of 0.024 against Jev's 0.074 — while being less accurate overall. One suite, one sample; but it's a reason to verify calibration even for the hosted model, not only for the open ones.

What decision models are bad at

TypeSafe publishes a candid list of Jev 1.13's failure modes. Smaller open models share all of them, usually more strongly:

• Literal reading — scoping words, negations and implied conditions taken at face value.
• Numbers — not a calculator; unreliable counting; hex and RGB values.
• Dates — compared as text, not as ordered quantities.
• Indirection — double negatives and multi-hop reasoning.
• Distraction — accuracy drops as irrelevant detail is added to the state.
• Injection — instructions hidden inside the state aren't treated as hostile.
• Contradictions — confusion when instructions and criteria disagree.
• Inconsistent opposites — a question and its reworded negation don't necessarily sum to 1.
• Generation — it can't write.

The practical rule that falls out: do the arithmetic, date logic and document extraction in code, and give the decision model only the judgment calls.

Which one can you run?

The quick version, by what you'd download:

¹ Index score for the Bespoke-Nimble-9B-v2 repository.

The decision-models hub has the full table matched to your saved hardware profile, and the analyzer gives you a fit verdict for any of them.

My take

I teach local LLM workshops, and the most common question I get from engineers is some version of "how do I get a reliable yes/no out of a chat model?" The honest answer until now was: with a lot of prompt engineering, output parsing and retries. Decision models are a better-shaped tool for that job, and Ollama making them a one-command install is the moment they become a normal part of a local stack.

I'd still hold three things loosely. The category is two weeks old, so model versions and limits will move under you. The benchmark that matters is your own. And "can't hallucinate" should be translated, every time, into "can't answer off-schema" — which is valuable, and different.

What I'll watch next: Ollama's promised MLX acceleration on Apple Silicon, more specialised decision models in its library, and whether anyone publishes an open implementation of calibration-focused training that holds up on data it wasn't tuned on.

Get started

• Run Nimble or Tev1 in Ollama — step by step
• Build a valid request without writing JSON
• Open reproductions beyond Ollama: Winnow, Decider, JevK5, AutoJev, Laya
• Set thresholds you can trust
• Fix /v1/systemone errors

Frequently asked questions

What is a Jev-style decision model? A model that takes a state and typed questions and returns a probability for every allowed answer in one scoring pass, without generating text. "Jev-style" refers to the interface TypeSafe AI introduced with Jev; the open models reproduce the interface, not Jev itself. Is Jev open source or available in Ollama? No. Jev is TypeSafe AI's hosted model with closed weights. Ollama runs open models — Nimble and Tev1 — that use the same request format, so code written for one works with the other. Is a decision model the same as a classifier? Close. A classic classifier is trained for one fixed label set. A decision model takes new questions and new options at request time, described in plain language, so one model handles routing, moderation and scoring without retraining. How is this different from structured outputs or JSON mode? JSON mode constrains a chat model's generated text to a schema, but you still get one sampled answer. A decision model returns a probability for every option at once, answers many questions per request, and doesn't generate at all — which is also why it's faster. What hardware do I need? The smallest one, Tev1 0.8B, is an 812 MB download and runs on a CPU. Nimble 9B is 9.5 GB. The strongest open model, AutoJev-27B, needs a workstation-class GPU. Check your machine in the analyzer.

---

Sources: TypeSafe AI launch post and documentation (typesafe.ai, docs.typesafe.ai); Ollama blog, 29 September 2026, and API reference (docs.ollama.com/api/systemone); Bespoke Labs Nimble repository and public benchmarks; Jev Decision Index 0.2.1 data (Hugging Face Space multimodalart/jev-decision-index, generated 28 September 2026); Hugging Face model cards read 30 September 2026. The Decision Index is community-maintained and not affiliated with TypeSafe AI.