Decision Models: Jev, OpenAI Decisions, and Local Alternatives
An article already has a summary; the next decision is whether it is worth reading now. A support ticket has entered the system; the next decision is which team should handle it. These questions require language understanding, yet their answers consist of just a few options. Judgments like these can be split out of a large model and handed to a cheap component with typed output that can be tested on its own: a decision model.
A decision model takes the material to judge and questions defined in advance, then returns choices, scores, or probabilities for code to process. It does not generate summaries, explanations, or code. Jev, released by TypeSafe AI in September 2026, was the first; the company calls this class System One, borrowing Kahneman's distinction between fast intuition and slow reasoning (release announcement). By late October, OpenAI, Vercel's gateway, and several local runtimes offered the same kind of interface, and the way of asking and reading results below applies to all of them.
What a Request Needs
A request has two parts: the material and the questions, called state and questions in the interface. The first holds the information the model needs to see; the second says what to judge and which answers are allowed. One request can contain several questions that share the material and are evaluated independently (question definitions). If a later question depends on an earlier answer, the program must sequence the calls.
For reading recommendations, the material is a summary plus the reader's current interest, the question is “Is this worth reading now?”, and the allowed answers are:
- Read now: directly helps with the current problem.
- Keep: useful background, but not urgent.
- Skip: unrelated to the current interest.
- Unsure: not enough information for a reliable judgment.
The options need clear definitions. If “Keep” and “Read now” are both explained only as “useful,” the model has trouble distinguishing them; without “Unsure,” material with too little information gets pushed into another category. The model can also judge only the material it receives: if it gets a title, its conclusion applies only to the title.
Three Output Types for Different Questions
A Score value is the probability-weighted average of the level indices, starting at 0. Define three levels, “unrelated,” “background,” and “directly relevant,” with indices 0, 1, and 2. If the model assigns probabilities 0.2, 0.5, and 0.3, the score is 0×0.2 + 1×0.5 + 2×0.3 = 1.1, between “background” and “directly relevant,” closer to the former. It has no natural percentage meaning; change the level descriptions and the number changes meaning too.
A low Noul probability is useful as well. A probability of 0.02 for “Is the body text missing?” means the model leans toward the body being present. Reading it as “the model is only 2% sure” confuses the probability of a proposition with uncertainty about the judgment.
Probability, Confidence, and Accuracy
A Choice can assign 0.51 to “Read now” and 0.49 to “Keep,” or 0.97 and 0.03. The top choice is the same, but the first result has almost no clear advantage. Keeping only the final category discards that difference.
TypeSafe's confidence is a 0–1 statistic computed from the full Choice or Score distribution, summarizing how concentrated it is. It is not a second independent judgment, nor the top option's probability; Noul has no such field. A high probability alongside a high confidence is therefore two descriptions of one output distribution, not two pieces of evidence.
Whether probabilities are accurate shows only across many predictions with known outcomes: if a batch of predictions all give an event about 80% probability, good calibration means about 80% of those events occur. A single output cannot show this; how to test calibration and set thresholds by the cost of errors is in Probability Calibration, Decision Thresholds, and Abstention. Showing “Unsure” when the top probability falls below some value is a rule the application sets, and the threshold has to be tuned on real material.
How to Interpret “Zero Hallucinations”
Defining the answer space in advance removes one class of problem: when the program requires one of the listed options, the model cannot invent a separate response. That makes the interface easier to check and errors easier to locate.
A correctly typed answer can still be wrong. A classifier can return a valid category and still send a complaint to the wrong team. Format constraints settle whether the result matches the interface; whether it is reasonable is still for the application to judge. That is the difference between tool contracts and task correctness.
TypeSafe lists known weaknesses for Jev 1.13; the page was last reviewed on October 2, and 1.14 has no page of its own yet. The weaknesses fall into nine groups: literal reading, numbers and counting, date and time comparison, indirection, irrelevant detail in long material, adversarial content, contradictory instructions and criteria, choice option order, and generation.
This affects use directly. Leave amount comparisons to code and give body-text relevance to the model. A sentence supplied by a reader should not become permission to rewrite classification rules. When a result needs explanation, return to the input evidence instead of letting another model invent a plausible reason.
The “193.6× faster, 444.6× cheaper” figures on TypeSafe's homepage come from its own workflow evaluation, whose reference answers average the judgments of two flagship models; treat them as a reason to try it.
Decision Interfaces Available Now
Checked on 2026-10-29:
Ollama's post on Clef relays Cloudflare's numbers. On the 10 evaluations of the Jev Decision Index, Clef beats Jev on 8; its median latency is 209 ms against Jev's 524 ms. These are the vendor's own comparisons and need retesting on your own samples. When labels are fixed and labeled data exists, a small trained classifier is often enough as a baseline; embedding and reranking models answer a different kind of question, as explained in Embeddings, Rerankers, and Classifiers.
Trying Jev Through the AI SDK
By default, a Jev request holds at most 64k tokens, and state plus any one question at most 32k. The header TypeSafe-Danger-Zone-Long-Context: true raises both limits to 262k, but the model documentation says this is slower and less accurate. English is the primary training language; Chinese and other languages are accepted but not handled equally well, so validate on your own samples.
Through Vercel AI Gateway, ai 7.0.128 and later use experimental_decide; earlier AI SDK 7 releases use experimental_evaluate, now a deprecated alias for the same interface. The fictional reading scenario below shows the request shape. The key comes from AI_GATEWAY_API_KEY in the server environment, and the example enables the prompt-training restriction:
import { experimental_decide as decide } from 'ai';
const result = await decide({
model: 'typesafe-ai/jev',
state: {
interest: 'Local speech tools and privacy',
excerpt: 'A fictional offline speech tool caches audio locally.',
},
questions: {
reading: {
type: 'choice',
instructions: 'How relevant is this excerpt to the current interest?',
criteria: {
read: 'Directly useful now',
keep: 'Useful background for later',
skip: 'Unrelated',
unsure: 'Not enough information',
},
},
},
maxRetries: 0,
providerOptions: {
gateway: { disallowPromptTraining: true },
},
});
console.log(result.answers.reading);
Without the AI SDK, send the same model, state, and questions fields to https://ai-gateway.vercel.sh/v1/evaluate. TypeSafe's confidence sits in providerMetadata.typesafe.confidence, keyed by question ID, and should be read separately from the probability distributions in answers.
A first cost estimate: if 10,000 requests use 20 million input tokens in total, the bill is about 0.84 USD at Jev's price and about 2.00 USD with OpenAI Decisions. That covers model usage only; longer material, extra requests, and human review all change the real cost.
No Training and Zero Data Retention Are Different Requirements
The gateway, the model provider, and the application can all handle the same request. Vercel's disallowPromptTraining is available to all users at no extra charge and routes requests only to providers that do not train on the data; it does not promise that nothing is retained, and requests with your own provider key (BYOK) are outside it. zeroDataRetention requires zero data retention and is available only to Pro and Enterprise teams; TypeSafe is on the Gateway's ZDR provider list.
What This Means for Dividing Work in Agents
The interface contract of material plus typed questions, returning a probability distribution, spread within about a month to OpenAI, Vercel, Ollama, vLLM, SGLang, and LM Studio. For people building agents, frequent small judgments such as “should this go to a person?”, “which tool comes next?”, or “should this context stay?” can be split out of the main model and handed to a cheap, replaceable component. Each split-out judgment has its own test set and threshold and can be regression-tested alone when the model changes. The cost is one more component to calibrate and monitor, and thresholds do not carry over between model versions.
When a Decision Model Is Worth Considering
A good starting point is one frequent, clearly bounded judgment in an existing system whose errors can be corrected. First see whether it reliably reduces manual work, then decide whether to expand it. Rather than letting one model response decide an entire workflow, keep exact computation in the program and use language understanding only for the step that needs it.
This division of labor fits with bounded agent loops and helps with model selection: who receives the output and what an error costs often matter more than whether a model is the strongest available.