The whole thing kicked off on September 15 when the startup TypeSafe AI released a model called Jev, which I already wrote about here. Jev returns probabilities over answers that you dictate to it yourself, and it costs a fraction of what a regular language model does. By early October, competition had arrived from Fastino Labs, Cloudflare, Perplexity and AWS, OpenAI had announced its own version, and the community had released a pile of open imitations. A new category was born, and it’s worth understanding, because it fits into agentic systems better than anything we’ve had so far.

What a decision model is

Input like an LLM, output like a function. You send the model a state (text, JSON, and with some models an image) and typed questions. The model returns a probability for each allowed answer, that is, the probability that the data you sent answers your question in exactly that way. Your application can branch on it directly and doesn’t have to parse anything.

Three question types that became the standard. Jev introduced them and the others adopted them:

• Choice picks one of the options; Jev handles up to 255 of them.
• Score places the state on a scale, for example from “all good” to “the customer is furious”.
• Noul returns the probability that a statement is true. The name is short for the Bernoulli distribution (yes, marketing was less successful with this one).

How it works inside. A language model generates its answer token by token, and every additional token is another pass through the network. A decision model processes the input once (prefill) and then scores all the predefined options in parallel. The vendors remove the head that normally generates text and replace it with a head that only scores the choices. AWS describes it exactly this way for its model. In plain terms: a language model writes an essay, while a decision model circles an answer on a multiple-choice test with options a, b, c. And next to each option it also writes how sure it is.

That’s why you only pay for input. The output is a handful of numbers, so all the vendors charge for input tokens and give you output for free. And because the questions are evaluated in parallel over the same state, ten questions take practically as long as one.

Is it new? Honestly, the principle isn’t, not much. Zero-shot classifiers, rerankers and cross-encoders have been doing a similar thing for years. What’s new is the packaging: you invent the categories right in the query without retraining, you have a large modern model behind it, and above all there’s a common API.

The common API is the best news of this whole wave. Cloudflare Clef, Perplexity Decider, the community’s kev and the SGLang inference server all speak the same “System One API” as Jev. So you can swap vendors by changing the URL and the model name. In an AI market where everyone is building their own walls, that’s rare.

Pros and cons

Prices in pennies. A thousand decisions over a short email come to about a quarter of a koruna (roughly one US cent) with the cheapest models. You’ll find the details in the table below.

Speed in tens of milliseconds. A decision can go right into the agent’s loop, and the user doesn’t wait for it.

Output that doesn’t blow up. The model can’t return a nonsensical category or broken JSON. An entire layer of code that handles “what if the LLM answers with nonsense” goes away.

Confidence on every answer. This is the most important thing for agents. When the model is sure, the code acts on its own. When it isn’t, it hands the matter to a human or a more expensive model.

Now the worse side.

It can’t write. No explanation, no justification. You won’t find out why the model decided what it did.

It only picks from a menu. It won’t propose a new option. In my test of Jev on Vibecoding.cz, it erred mostly by omission: occasionally it overlooked the correct answer.

It’s bad at math and data. Jev’s documentation itself admits arithmetic, counting and working with data as a weakness.

Calibration is disputed. TypeSafe promises honest probabilities, meaning that 90% confidence means a 90% success rate. But Alex Molas showed that Jev assigned a fair coin a 92% chance of heads, even though the correct probability was stated right in the prompt. Practical advice: treat the output as a score and recalibrate it on a few hundred of your own labeled examples.

Quality drops as the number of options grows. An independent test on Towards Data Science gave Jev 79% on 77 intent categories, while OpenAI models scored 84 to 86%. When narrowed to 7 categories, the difference disappeared.

Five families of decision models

In as short a time as two weeks, roughly five families of decision models appeared. Let’s go through both the families and their main players.

Closed hosted APIs

That is, what we know from today’s LLMs. You get an API endpoint, an API key is generated for you, and you pay for usage that runs somewhere in someone’s cloud. Only God knows what happens to your data in that cloud, and the documentation is usually a flimsy proof of anything.

Jev from TypeSafe AI founded the category. By its own account, the company worked on it in secret for two years, hasn’t published the architecture, and offers the model only through an API in the US. It has a 32K-token context and takes text only. Its strong point is the ecosystem: Vercel reports that almost 13% of paying teams started using it within 24 hours. The weak point: according to Flavio Copes, Jev has had new registrations paused since September 22, and the prices appear to be subsidized.

GLiDE from Fastino Labs is a “thinking” decision model. Fastino is a San Francisco lab behind the open source GLiNER family of models. For uncertain cases, GLiDE adds a bit of reasoning, which improves results on complex tasks. But an independent measurement showed that on harder problems a decision takes up to 6.6 seconds and comes out roughly nine times more expensive than Jev. That turns fast decision-making into ordinary slow decision-making.

Decisions API from OpenAI was announced at the end of September. It’s built on the GPT-6 Luna model and takes images too. OpenAI hasn’t yet published the price or detailed parameters, so for now just keep an eye on it.

Large open models (9 to 27 billion parameters)

This is where the most is happening. Everyone took Alibaba’s open Qwen model, froze it, and trained a decision head on top of it. That’s why it took the competition only two weeks.

Perplexity Decider (pplx-decider-v1-27b) is the biggest surprise for me. It has 27 billion parameters, an Apache 2.0 license, a 250K-token context, and takes images. Perplexity also offers it hosted for $0.04 per million tokens and has announced a further price cut. It uses the model itself to monitor its own model training.

Cloudflare Clef and Clef-flash are the first models the Workers AI team trained itself. Clef has 27 billion parameters and Clef-flash 9 billion; both have an Apache 2.0 license, a 64K-token context, and take images. Clef-flash decides with a median of around 40 milliseconds. Cloudflare also offers fine-tuning on your own data.

kev by Jared Palmer started as a weekend reproduction of Jev, and its 9-billion-parameter version came within half a percentage point of Jev in one comparison.

Small models for a laptop and your own server (0.5 to 4 billion)

For when something smaller is enough and you don’t have that much room on your hardware.

Strands Decider 2B from AWS is built on a 2-billion-parameter Qwen and decides in under 100 milliseconds on an RTX 3090 gaming card. AWS also publishes the training data and scripts, which makes it the most open piece of the whole wave. It’s hooked into the Strands agent framework, where it decides whether to let an action run, reject it, or ask the user.

Community reproductions like kev-0.5b, JevK5, OpenJev or Tev1 from Together are more for experiments. kev-0.5b answers six questions in roughly 160 milliseconds on a MacBook with an M5.

Encoders (hundreds of millions of parameters)

GLiNER2.5-Decide from Fastino has 340 million parameters and runs even on an ordinary CPU without a graphics card. It handles linked questions that never contradict each other, such as “is it safe?” and “what type of harm is involved?”.

Laya from Convai Innovations exists in an English version and in a multilingual version for over a hundred languages. On a graphics card it handles a question in roughly 33 milliseconds. But on more complex tasks it lags significantly behind the large models.

A layer on top of any model

open-alternative-jev and OpenJev are a technique for reading a decision out of any open language model in a single pass. A spicy detail: in one comparison, open-alternative-jev had the best calibration of all, exactly the property that Jev sells as its main strength. Anyone with their own graphics card can build a decision model in an afternoon.

How much this fun costs

With decision models you pay only for input, so the price is determined by the length of the state. For comparison, I’m assuming 300 tokens per decision, which corresponds to a short email or ticket. I convert to CZK at a rate of 21 CZK per dollar.

* Fastino’s pricing is inconsistent in its documentation, and it also charges for the internal “thinking” passes. An independent measurement came out to roughly $213 per million decisions.

Among the cheapest, the difference is negligible. Perplexity and Jev are at practically the same price, and even the twice-as-expensive Clef-flash comes to just under 600 CZK per million decisions. Price thus stops being an argument, and quality on your specific task decides. In my view, the price of a hosted decision will approach zero and the money will shift to fine-tuning on your own data. Cloudflare and Fastino have already set off in that direction.

Is your own hardware worth it? For a freelancer or a small company, almost never because of price. Nadir calculated that an H100 graphics card at $2.50 per hour would have to process roughly 17 thousand tokens per second nonstop to beat Perplexity’s price. Against the more expensive Clef, around 2,900 tokens per second is enough. So running locally makes sense when the data MUST NOT leave your network. The exception is small encoders, which will run on a server you already have anyway.

How they do in benchmarks

There is no unified independent benchmark yet. Every vendor measures on its own tests and against its own versions of its rivals, so take the tables as a rough guide.

Cloudflare’s comparison is the most detailed, but it was measured by Cloudflare:

** Jev measured over the internet against TypeSafe’s API, Clef on Cloudflare’s own infrastructure. The latency comparison is therefore unfair.

Other claims from vendors and independent tests:

Where Jev holds its lead. On knowledge-heavy tests like GPQA Diamond, Jev leads Clef 78 to 48. That’s so far the only hard evidence that TypeSafe built something more in two years of development than the others did in two weeks. For typical routing and sorting, though, that lead doesn’t show.

Three players worth considering

Perplexity Decider, when you’re starting a new project. It has Jev’s price, plus open weights, a quarter-million tokens of context, and images. If the API ever stops suiting you, you download the model and run it yourself without rewriting code. For me, the best default choice. Caveat: it’s the freshest of them all and has no track record in production.

Jev, when you need the widest tool support. It’s the reference, has integrations in Vercel, OpenRouter, Langfuse and Arize, and leads on knowledge-heavy decisions. But don’t underestimate the risks: paused registrations, a subsidized price the company can raise at any time, and data only in the US. If you’ve signed with a client that the data won’t leave the EU, Jev is out of the question for you. I use Jev myself, but through the OpenRouter API, because I missed the chance to sign up directly for their company API and I’m too lazy to switch elsewhere when I have everything debugged.

Cloudflare Clef-flash, when you run on Cloudflare or want speed. It decides in tens of milliseconds and you don’t need another vendor or another API key. The open weights also let you host the model in the EU. It’s twice as expensive as Jev, but in absolute numbers it’s still small change.

And what about running locally? Anyone who needs to decide inside a company network should reach for AWS Strands Decider 2B with its completely open recipe, or for GLiNER2.5-Decide, which will run even on an ordinary server without a graphics card. With Czech, though, test both first.

What decision models are good for

The rule is simple: if your code needs a constrained answer that it branches on, you have a candidate for a decision model. If a human will read the output, you need a language model. Here are the tasks where I see the most value.

Sorting mail and tickets. A city hall’s registry office, an e-shop’s customer support, a freelancer’s overflowing inbox. Over each message you ask several questions at once: where it belongs (Choice), whether it’s urgent (Noul), how angry the writer is (Score). You get the answer in a tenth of a second, and a thousand messages cost you a quarter of a koruna. A language model would want ten to a hundred times more for the same work.

Routing between models. Before every call to an expensive model, ask: can the cheap one handle this? Send simple queries to a small model and complex ones to a large one. The savings multiply with every query, which is why Fastino and OpenRouter both list this as the main use.

A gate before an agent’s action. Should the agent continue, retry, ask the user, or stop? May it delete a file, send an email, pay an invoice? AWS built the entire intervention mechanism in the Strands framework on this. For Claude Code users, something similar is available through hooks: instead of brittle regular expressions in PreToolUse, you ask a decision model whether the command is safe.

Tool selection. An agent with dozens of tools doesn’t have to call an expensive model every time to figure out which one to use. A single Choice question over the task description solves it in tens of milliseconds.

Reranking search results. Vector search or BM25 finds you a hundred candidates, the decision model scores each by relevance, and the code sets a threshold. Simon Willison replaced an expensive reranker this way. I find related articles on Vibecoding.cz like this, and it came out roughly 17× cheaper than with Claude Haiku. A pattern that has worked for me: the code prepares, the model decides, the code picks the threshold.

Evaluating the outputs of other models. Does the generated answer match the sources? Did the code fulfill the assignment? Is the summary factually correct? Langfuse and Arize already have evaluators built on Jev, and Langfuse generally calls them decision-model evaluators, so others can be plugged in there too. The same principle works as a gate in CI: a deployment goes through only if the model gives a sufficiently high score.

Moderation and guardrails. An attempt to bypass the model’s rules (jailbreak), a toxic comment, personal data in text. Dozens of checks in parallel over one message for the price of one. For Czech websites, this is the most practical use: moderating discussions under articles without having to pay a language model for every comment.

Bulk data processing. Tagging 50 thousand products in a catalog, sorting an archive of invoices by cost type, flagging duplicate records in a CRM. With a language model the cost here adds up to thousands of koruna; with a decision model, to tens.

Context pruning. Which parts of a long conversation history should you keep before the next model call? The decision model scores each piece and you pass on only what matters. For Claude Code there’s already a plugin, fast-jev-compaction, that replaces summarization this way.

Decisions over images. Clef and Perplexity Decider take images too. Is the goods in the customer’s photo really damaged? Does the photo of the reported defect match the description? Does the screenshot look like a fraudulent login page? As a demo, Perplexity had its model play chess from just a screenshot of the board, and it handled a move in roughly 140 milliseconds.

Games and simulations. TypeSafe had Jev play Doom at ten decisions per second and calculated the cost at roughly $7 per hour of play. The practical significance is small, but it shows well how cheap fast decision-making is.

When not to use a decision model. When you need text, an explanation or a justification. When the task rests on computation or working with data. And above all when the decision affects people: selecting job applicants, assessing benefit or loan applications. The model won’t say why it decided, and hidden bias is very hard to find in it. I wouldn’t allow this at a government office even if it cost zero koruna.

What to take away

Decision models are here to stay. Technically, they’re old principles in new packaging, but practically it’s the first time we have a general, cheap and fast decision tool with a common API. For agentic systems, it’s exactly the missing piece.

Jev’s lead is small. It caught me off guard how quickly its approach could be copied. In two weeks all the big players caught up with it, and one of them even overtook it on price. For you that’s good news, because you can swap vendors by changing a single URL.

And now the most important part. Don’t trust the vendors’ benchmarks, not even the ones I’ve listed here. Take two to five hundred of your own cases, label them by hand, run them through two or three models, recalibrate the probabilities and set the thresholds. It takes you an afternoon and saves months. I’m starting with Perplexity Decider and Clef-flash, and I’ll bring you the results on Czech here.

And what do I use Jev and decision models for? I’m writing about it here…

---

Sources and validity: prices and availability are valid as of October 5, 2026, and in this category they change by the day. Most of the performance figures come from the vendors themselves. Main sources: announcements from TypeSafe, Cloudflare, Fastino, Perplexity documentation, The New Stack on AWS Strands Decider, the overview from MarkTechPost, the pricing analysis from Nadir, and the independent test of GLiDE.