The Jev Model That Gave Up Chatting: Why a Decision-Only Model Is Faster and Cheaper

The new model Jev made a striking debut. It runs 20 to 200 times faster than a general-purpose large language model and costs 40 to 400 times less. But it cannot chat with you, and it cannot write articles for you. When the author tried to sign up, the official site had temporarily stopped registrations because demand was so high.

So how does it manage to be so fast and so cheap? And after giving up chatting, what can it still do?

The model comes from TypeSafe AI. Its founder, Diogo Almeida, is one of the co-authors of InstructGPT—the work that taught large models to understand human instructions and act on them, and one of the key foundations of ChatGPT. After leaving OpenAI, he and his team spent two years building Jev.

1. It returns only one thing: a decision and its probability

Let's start with a small example of how it works.

Xiao Wang has invited a friend over for dinner. The dishes have just reached the table when the friend arrives. Smiling, Xiao Wang says, "You really know how to pick your moment." Now: is Xiao Wang expressing displeasure?

Give that question to a general-purpose LLM, and it answers "No," then adds a paragraph explaining its reasoning. Give the same question to Jev, and the answer is a single word—"No"—along with the probability that the conclusion holds. There is no extra explanation at all.

That is exactly what Jev is designed for: structured decisions inside software. You give it the background, tell it what to judge, and define which answers are allowed; it returns a result and a probability. The call itself is simple. It needs only two things: state, the context you want it to analyze, and question, the question you want it to answer. Once you have the question, you also have to specify how it is allowed to answer.

Jev currently supports three answer types:

• Noul: judges whether a statement holds and returns the probability that it does. "Is Xiao Wang expressing displeasure?" falls into this category.
• Choice: selects from preset options and returns the chosen option, a confidence level, and the probability distribution over the options.
• Score: rates against a preset scale—say, one to five—and returns a score plus the probability of each level.

2. Why it is faster and cheaper: it does not write an essay, it computes probabilities over the options

At this point you might ask: can't I just tell an LLM to answer in this format? Of course you can. But what Jev sets out to prove is whether it can do the same judgments faster and more cheaply.

A traditional LLM output is an essay question. It writes text token by token; even if you only ask for a yes or no, it first generates text and then converts that text into your required format. Jev works differently. Around the predefined answers, it outputs a probability distribution directly over the allowed options instead of generating text word by word.

For a single question, you may not notice the difference. But when a system contains a large number of repeated judgments—every email, every customer-support message, every agent action—Jev's value of low latency and high accuracy starts to show. In official tests, it is up to about 193.6 times faster than a general-purpose LLM and about 444.6 times cheaper, at $0.042 per million input tokens with free output. The company does note that not every task sees the same improvement.

3. The key is the training objective: from "satisfy people" to "calibrate decisions"

So how does Jev achieve this? The answer goes back to the model's training objective.

The usual approaches for general-purpose LLMs are RLHF and RLVR. RLHF, reinforcement learning from human feedback, can be understood roughly as having people compare several answers and then adjusting the model based on that feedback, so it learns which answers people tend to approve of. RLVR rewards the model with verifiable outcomes—whether an equation was solved correctly, whether the code it wrote passes the tests.

TypeSafe calls Jev's training method RLCD: reinforcement learning for calibrated decisions. It trains the model both to make judgments and to output the probability attached to each judgment. That probability does not just tell you which option is more likely; it tries to tell you how likely it really is. Calibration means that when the model assigns an 80% probability to many judgments, the events should actually occur close to 80% of the time. So the number can be used directly. For routing, for example: if the probability that a customer wants a refund is around 80%, handle it automatically; below 50%, send it to a person.

Why did the founder choose this direction? The author watched one of his talks on YouTube, and his stance was somewhat radical. He asks: why can AI solve hard math problems while some apparently simple decisions in customer service still need a human watching?

Behind that is the difference between satisfying people and running automatically. Reinforcement learning from human feedback was designed from the start to match human preferences. That is why when you chat with an AI or have it write code, a person always has to be in the loop: you can judge whether the answer is good, and if you are unhappy you can ask for changes. But true automation should ideally run in the background and not require checking every step. This explains why Jev cares so much about decisions. It wants the model not only to give an answer but also to express its uncertainty clearly, so software can decide: keep executing, gather more information, or hand it to a person.

4. How it differs from a traditional classifier

You might also ask: can't traditional classifier machine learning output probabilities too? What makes Jev different?

The difference is again in how it is trained. The common approach in the past was to take a labeled dataset of spam and normal email and train a model specifically to detect spam. Such a model is usually trained around a fixed task, so when the business scenario or labels change, you often need to re-label data and retrain. Jev's difference is that it retains the semantic understanding and generalization of a large model. Developers can describe different judgment tasks with prompts, without retraining the model for each new task.

5. Where it is used: an intelligent branch inside software that can read context

Jev cannot chat, but it has plenty of use cases, and that is one reason it survives. Think of it as an intelligent branch statement inside software that can read context. It can be used wherever a decision has to be made.

• Classifying messages
• Content quality checks for large models
• Scoring content generated by large models
• Serving as the decision middleware for an agent: deciding which tool to use, judging operational risk, and so on

Many projects on GitHub have already integrated it, and some fun uses have appeared.

The Browser Use team built a browser agent that completed a flight search on Google Flights in 7.1 seconds for only about $0.003. Jev chooses which page element to operate; when text input is needed, a small language model generates it.

There is also a WeChat reply assistant. It reads the chat text on a computer screen, and Jev judges the other person's intent and emotion. Working with a large model, it drafts three replies, and Jev ranks them. Pick one, and it can be dropped straight into the WeChat input box.

Even more playful is a museum infiltration game. Players can change clothes, obtain credentials, and make noise. When the guard notices a disturbance nearby, Jev judges whether the person is suspicious and whether there is a threat; then the game decides what action to take next.

6. How to get an API key

Because it became so popular, the official site temporarily paused registrations. Aside from that, you can get access through OpenRouter or the Vercel AI SDK. The simplest way is the official Playground: enter the context and the question on the left, and read the result on the right.

7. Will it replace large models?

The projects above already give one answer: they are experimenting with a division of labor—Jev makes judgments, a large model generates text, and ordinary code executes actions.

Some commentary frames it as a trade-off between capability and efficiency. The industry has long chased higher intelligence, while underinvesting in the direction of "good enough capability, very short output, and speed." The attention Jev has received shows that this demand has been there all along.

TypeSafe calls models like Jev System 1 models, inspired by Daniel Kahneman's Thinking, Fast and Slow. Kahneman divided human thinking into System 1 and System 2: System 1 is fast, automatic, and intuitive; System 2 requires focused attention and works step by step. Agents, too, need to know which things call for a quick judgment and which call for slow reasoning.

When we look at AI, we often ask how hard a problem it can solve. Once agents actually do work for people, we have to ask one more question: can it spend its time and compute where they are really needed?