Within weeks of TypeSafe releasing Jev, OpenAI, Microsoft, Cloudflare, and Perplexity had shipped decision models of their own, and open-weight versions kept arriving behind them. Most share the same idea and a similar API: send a state and typed questions, and get typed answers with probabilities back.
That similarity makes choosing harder, not easier. Each vendor benchmarks against Jev on its own tests, so the headline numbers rarely line up, and a model's accuracy on someone else's benchmark says little about how it handles your decisions.
The useful comparison is the one closest to like-for-like, with who ran it stated plainly, alongside what each model costs per call. For agents in production, the other half of the job is checking the decisions after they're made.
Here are the 10 best AI decision models compared in 2026, with the strongest available head-to-head result and the price for each.
TL;DR: Best AI decision models
Each of these models makes a typed decision in a single call, but they differ in where they run and how they've been tested against Jev.
- Judging agent traces - Span-01, which scores plain-language behaviors across a full trace and beat Jev 0.806 to 0.716 on Respan's behavior benchmark.
- A hosted baseline - Jev, at 0.932 accuracy in Respan's decision-model eval.
- Azure deployments - Microsoft-Decision-1, deployed through Microsoft Foundry.
- Image input with open weights - pplx-Decider, which offers a hosted API and Apache 2.0 weights.
- Audio, video, or edge - Clef, on Cloudflare Workers AI or self-hosted.
- Running Jev's API yourself - Kev, which the TypeSafe SDK works against unchanged.
- Small and multilingual - Laya, at 421M parameters with a version covering 100+ languages.
OpenAI's Decisions API, Tev1, and Strands Decider round out the ten for teams already on OpenAI, training their own model, or building on Strands Agents.
What are AI decision models?
An AI decision model takes a state, which can be text, JSON, or for some models an image, along with questions you define, and returns a typed answer with probabilities instead of generated text. Questions come as a choice between options, a score on an ordered scale, or a yes-or-no probability, which TypeSafe, Microsoft, Cloudflare, and Perplexity call a noul and OpenAI calls a predicate.
TypeSafe calls this class System One models, after the fast, intuitive System 1 thinking in Daniel Kahneman's work, and several vendors now use System One as the name of the API their models implement. Decision models are a narrower form of LLM classifier models, defined by an API contract rather than a training technique, so the questions you'd otherwise encode in a prompt become structured fields.
How Jev caused the flood of new models
Jev turned a decision into an API call: a state and typed questions in, typed answers with probabilities out, at a price low enough to run on every request. Interest in the Jev AI model built quickly, and within weeks other teams had shipped their own versions.
Together AI published Tev1 on September 22, and Jared Palmer's Kev-4B followed two days later. Cloudflare's Clef and Amazon's Strands Decider arrived on October 1, Perplexity's pplx-Decider came in early October, and Microsoft-Decision-1 launched on October 9, while OpenAI opened its Decisions API as a public beta.
Most of them start from a Qwen base. Microsoft says its model is post-trained from Qwen3.5-9B, and Clef, pplx-Decider, Strands Decider, Tev1, and Kev all list Qwen models as their bases, which goes some way toward explaining how fast they appeared. Some adopted the interface as well, since Clef and Kev implement Jev's API directly, so moving between them is closer to changing an endpoint than rewriting an integration.
10 best AI decision models
Vendors benchmark these models on their own tests, so the result column shows the closest head-to-head available for each model and names who ran it.
| Model | Benchmark result | Run by | Price (per 1M input) |
|---|---|---|---|
| Span-01 | 0.806 vs Jev 0.716 | Respan | $0.02 (Lite free) |
| Jev | 0.932 accuracy (baseline) | Respan | $0.042 |
| OpenAI Decisions API | 0.15s vs Jev 0.19s | OpenRouter | $0.10 |
| Microsoft-Decision-1 | Index 54 vs Jev 58 | Artificial Analysis | $0.042 |
| pplx-Decider | 85.71% vs Jev 84.51% | Perplexity | $0.02 |
| Clef | Ahead on 8 of 10 | Cloudflare | $0.038 to $0.240 |
| Tev1 | 0.901 vs Jev 0.932 | Respan | $0.042 |
| Strands Decider | 0.779 on JevBench | Strands Labs | Self-hosted |
| Kev | 0.833 vs Jev 0.932 | Respan | Self-hosted |
| Laya | 0.542 vs Jev 0.932 | Respan | Self-hosted |
The results come from different tests, so they compare best within a row rather than across rows:
- Respan decision-model eval - Accuracy on decision tasks, judged by Span-01, which also reports paired flip rate, injection attack success rate, and calibration error. Higher accuracy is better, and the full results are in Span-01's launch benchmarks.
- Respan behavior benchmark - F1 on detecting agent behaviors in production traces, where higher is better.
- Artificial Analysis Decision Index - A composite of knowledge, reasoning, tool calling, and safety classification, run by Artificial Analysis on every model it covers.
- OpenRouter latency - Median end-to-end latency with requests sent straight to the vendor, where lower is better.
- Vendor panels - A vendor's own tests against Jev, not independently run.
Where Respan's eval covers a model, it's the closest to like-for-like, since every model in it faced the same tasks as Jev.
Because hosted decision models price input only, cost scales with how much state and question text you send. At 1 million decisions a day with 500 input tokens each, that's 500 million input tokens daily:
| Model | Per day | Per 30 days |
|---|---|---|
| pplx-Decider | $10 | $300 |
| Clef-flash | $19 | $570 |
| Jev | $21 | $630 |
| Microsoft-Decision-1 | $21 | $630 |
| Tev1 | $21 | $630 |
| OpenAI Decisions API | $50 | $1,500 |
| Clef-omni | $75 | $2,250 |
| Clef | $120 | $3,600 |
Self-hosted models replace that line with GPU time, and Kev-4B and Laya each fit on a single GPU, from a 24 GB card for Kev-4B down to a T4 for Laya.
1. Span-01
Span-01 is Respan's classifier for agent traces, and it works at a different point in the stack from the other nine. They decide something about a single request, while Span-01 reads the whole trace and scores whether behaviors you define in plain language happened.
On Respan's behavior benchmark, which scores detection of agent behaviors in production traces, Span-01 scored 0.806 overall against Jev's 0.716. It answers in one forward pass without generating text, so it's cheap enough to run across live traffic rather than a sample.
- Plain-language behaviors - Describe a behavior like "the agent routed a billing question to support," and Span-01 scores it, including definitions it hasn't seen before.
- Many behaviors in one pass - Each definition runs as its own branch over the same trace, with no per-request limit on how many you check.
- Answers you can threshold - Every behavior comes back as present, absent, or not observable, so a trace without enough evidence reads as unknown instead of a false negative.
- Built-in and custom behaviors - Respan's Behaviors feature ships built-in behaviors such as refusals, instruction misses, and incomplete answers, and you can add your own.
- Connected to the rest of the platform - Span-01 runs on the traces Respan already captures, so a bad score opens straight onto the trace behind it, and those traces can become the test set for the next fix.
Benchmark: 0.806 vs Jev's 0.716 on Respan's behavior benchmark (Respan-run)
Price: Span-01 Lite is free within a daily cap, and Span-01 costs $0.02 per 1M input tokens with free output
2. Jev
Jev is TypeSafe's hosted decision model and the reference point most of the category benchmarks against. You send a state as text or JSON with typed questions, and choice questions can carry up to 255 options, with larger option sets scored in two stages.
In Respan's decision-model eval, Jev scored 0.932 accuracy with a 0.021 paired flip rate, a 0.063 injection attack success rate, and 0.045 calibration error, which is the baseline the other Respan-run results sit against. Input costs $0.042 per million tokens with output free, though TypeSafe's own launch post says it can't yet show that this pricing isn't subsidized, which is worth factoring in for teams weighing Jev alternatives.
Benchmark: 0.932 accuracy in Respan's decision-model eval (Respan-run baseline)
Price: $0.042 per 1M input tokens, output free
3. OpenAI Decisions API
OpenAI's version, the OpenAI Decisions API, is in public beta and runs only on GPT-6 Luna. It answers predicate, choice, and score questions over text, or text with inline base64 images, and OpenAI lists zero data retention and HIPAA use for eligible customers, with data residency in the US and Europe.
OpenAI publishes no accuracy results for it, so the available comparison is speed, where OpenRouter measures a 0.15-second median latency against 0.19 seconds for Jev, both served direct from the vendor. At $0.10 per million input tokens with free output, it costs more than twice as much as Jev per token, and it uses its own API rather than Jev's.
Benchmark: 0.15s vs Jev's 0.19s median latency (OpenRouter)
Price: $0.10 per 1M input tokens, output free
4. Microsoft-Decision-1
Teams on Azure can deploy Microsoft-Decision-1 from Microsoft Foundry, and it's also available on OpenRouter. Microsoft says the model is post-trained from Qwen3.5-9B, and it takes text or JSON and answers noul, choice, and score questions through Microsoft's own System One-style endpoint.
On Artificial Analysis's Decision Index, which runs every model through the same knowledge, reasoning, tool-calling, and safety tests, it scores 54 to Jev's 58, while posting a higher non-hallucination rate (40% vs 35%) at a lower cost per million tasks ($31 vs $42). Microsoft prices it at $0.042 per million input tokens with free output, and deploying through Foundry means working within Azure's deployment and quota model.
Benchmark: Decision Index 54 vs Jev's 58 (Artificial Analysis)
Price: $0.042 per 1M input tokens, output free
5. Perplexity pplx-Decider
Perplexity ships pplx-Decider, a model built on Qwen3.8-27B, both ways: as Apache 2.0 weights on Hugging Face and through a hosted Decisions API. The hosted version takes text, JSON, or base64 images, accepts inputs up to 262,144 tokens with up to 128 questions per request, and is rate-limited to 10 requests per second per organization.
Perplexity reports the first version beating Jev 85.71% to 84.51% across an 11-test panel run through its API, though Jev led on several of those tests, including BBH and TruthfulQA. Self-hosting takes more work than the license suggests, since the reference inference code caps each decision at 8,192 tokens, well below the hosted limit. At $0.02 per million input tokens with free output, the hosted API costs less than half as much as Jev per token.
Benchmark: 85.71% vs Jev's 84.51% across 11 tests (Perplexity-run, v1)
Price: $0.02 per 1M input tokens, output free
6. Cloudflare Clef
Clef is a family of three from Cloudflare, available on Workers AI and as Apache 2.0 weights: Clef (27B) for precision, Clef-flash (9B) for latency-critical calls, and Clef-omni, which adds audio and video input. Cloudflare says all three are fully Jev-API compatible, so code written against Jev's API should carry over.
Cloudflare's own 10-test panel has Clef ahead of Jev on eight, with Jev leading on When2Call and BRIGHT, and it reports Clef-flash at a 38.8 ms median latency against Jev's 524.1 ms at launch. Pricing varies widely by variant, from $0.038 per million input tokens for Clef-flash to $0.240 for Clef, and media is billed as input tokens, so audio and video add up quickly. The hosted Clef-flash context window is also 24K tokens, down from the 64K advertised at launch.
Benchmark: Ahead of Jev on 8 of 10 tests (Cloudflare-run)
Price: $0.038 (Clef-flash) to $0.240 (Clef) per 1M input tokens, output free
7. Tev1
Tev1 scored 0.901 accuracy against Jev's 0.932 in Respan's decision-model eval, with an injection attack success rate of 0.042 compared with Jev's 0.063. Together AI built it as a 4B experiment on Qwen3.5-4B and published the training recipe, which Together says cost about $17 to run.
It's narrower than the others, though. Tev1 answers multiple-choice questions only, with 2 to 24 options, returns a single label without a calibrated confidence, and runs through chat completions with settings the caller has to set. Together lists it at $0.042 per million input tokens while its model page still says the endpoint is launching soon, and the weights license hasn't been finalized, so check both before building on it.
Benchmark: 0.901 vs Jev's 0.932 accuracy (Respan-run)
Price: $0.042 per 1M input tokens, output free
8. Strands Decider
Amazon's Strands Labs, the experimental arm of the Strands Agents project, released Strands Decider as Apache 2.0 weights, with a 2B reference model on Qwen3.5-2B and larger variants on Gemma 4. There's no managed version, so you run it yourself, and its local server exposes a /v1/systemone endpoint that binds to localhost with no authentication.
Strands Labs reports 0.779 accuracy on JevBench's public set for the reference model, without a Jev score on the same tasks to compare against. Its calibration guidance is practical: answers at 0.9 confidence or above were right about 95% of the time on unseen short classification tasks, and below that the README suggests confirming the answer or asking a person. It also lists long multi-step documents as a weak spot.
Benchmark: 0.779 accuracy on JevBench's public set (Strands Labs-run)
Price: Self-hosted
9. Kev
Jared Palmer's Kev implements TypeSafe's System One API, so the TypeSafe SDK works against it unchanged, and it comes as Apache 2.0 weights in 0.8B, 4B, 9B, and 27B sizes on Qwen bases. Kev-4B fits on a 24 GB GPU or a 32 GB Mac, while Kev-27B needs an 80 GB GPU, and every size is text-only and English-only.
Respan's eval scored Kev-4B at 0.833 accuracy against Jev's 0.932, with a 0.078 injection attack success rate. Palmer's own held-out index puts the 27B model at 52.3 to Jev's 54.0, though he notes the 27B checkpoint was selected after seeing test results, so its margins may be optimistic. There's no first-party hosted option, which makes the cost your GPU time.
Benchmark: 0.833 vs Jev's 0.932 accuracy (Respan-run, Kev-4B)
Price: Self-hosted
10. Laya
Laya, from ConvAI Innovations, is a 421M-parameter ModernBERT-large encoder rather than an adapted LLM, released under Apache 2.0 with a 322M multilingual version covering 100+ languages. It answers choice, score, and noul questions in a single forward pass, at about 33 ms per question in ConvAI's GPU tests, and you can fine-tune it on your own data.
Out of the box, it scores 0.542 accuracy in Respan's eval with a 0.396 injection attack success rate, and ConvAI's model card says base checkpoints score near chance zero-shot on its typed-decisions benchmark. Fine-tuning changes the picture, since ConvAI reports its fine-tuned checkpoint at 0.766 against Jev's published 0.727 on that benchmark, which is the tradeoff at the center of how Jev and Laya compare.
Benchmark: 0.542 vs Jev's 0.932 accuracy (Respan-run)
Price: Self-hosted
FAQ
What is a System One model?
A System One model is TypeSafe's name for a model that makes fast, structured decisions instead of generating text, after the fast, intuitive thinking Daniel Kahneman called System 1. Jev was the first, and Microsoft, Cloudflare, Kev, and Strands Decider all use a System One-style API. Span-01 works the same way on agent traces, scoring behaviors in a single pass without generating text.
Which AI decision model is the most accurate?
No single model wins every benchmark, and most published results are vendor-run. For judging agent behavior across a trace, Span-01 scored 0.806 against Jev's 0.716 on Respan's behavior benchmark. For decision tasks, Jev scored 0.932 in Respan's eval with Tev1 at 0.901, while Microsoft-Decision-1 trails Jev 54 to 58 on Artificial Analysis's Decision Index and Clef leads Jev on 8 of 10 Cloudflare-run tests.
How much do AI decision models cost?
Hosted decision models charge for input tokens only, from $0.02 per million for pplx-Decider to $0.240 for Clef, with output free across the board. Span-01 Lite is free within a daily cap, and Span-01 costs $0.02 per million input tokens. Open-weight models like Kev, Laya, and Strands Decider cost only the hardware you run them on.
Can you run an AI decision model locally?
Yes. Kev, Laya, Strands Decider, Clef, and pplx-Decider all publish open weights under Apache 2.0, and Kev-4B and Laya each fit on a single GPU. Tev1's weights are on Hugging Face too, but Together hasn't finalized their license.
