Jev Goes Viral Overnight: No Chatting, No Coding, Just Judgment

Original author: Zhu Xueying

Original source: Wall Street Journal

These past two days, a somewhat unusual AI model suddenly went viral.

It's called Jev.

It can't chat, doesn't write code, and won't even generate a long answer for you like ChatGPT. It does exactly one thing: make judgments.

But it's precisely this model, which looks like its "capabilities have been cut in half," that suddenly became a hit in developer circles.

Some used it to analyze 724 real-time ads in 40 seconds, making a total of 8,724 judgments; some plugged it into Claude Code to specifically clean up useless context; others had it act as a "referee" for AI Agents, checking whether tasks were actually completed. LangChain has also begun testing Jev's performance as an Agent evaluator.

What's even more striking is the speed and the price.

In tests published by TypeSafe, Jev achieved up to roughly 193.6x speedup and up to 444.6x cost reduction. Input costs just $0.042 per million tokens, and output tokens are even free.

Why did an AI with seemingly fewer capabilities become popular instead?

Because in the Agent era, what AI truly needs may not just be "deep deliberation," but also massive, fast, and cheap judgments: what to do next, which tool to call, whether the task is actually complete. More importantly, these judgments will need to be made by AI itself in the background in the future, no longer requiring a person to sit in front of the screen watching. What Jev targets is exactly these small decisions that may occur millions of times a day.

What's even more interesting is that Jev founder Diogo Almeida was himself involved in RLHF, and now he has begun to reflect on RLHF: this training approach that made ChatGPT useful may not be suited for AI truly moving toward automation.

More than a month ago, Almeida gave a talk. Looking back now, that talk was almost Jev's "manifesto."

AI can do advanced mathematics, so why can't it do customer service well?

Diogo Almeida's background is unusual.

He once worked at OpenAI and was involved in work related to GPT-4, ChatGPT, and InstructGPT/RLHF. In other words, he personally helped build one of the most important post-training paradigms for today's large models.

But in that talk, he started by joking about himself, saying he was one of the few people inside OpenAI who publicly "trashed" ChatGPT.

The topic of his talk was even more direct: What's Next After RLHF?

Diogo first raised a seemingly contradictory question.

Today's large models can already tackle very difficult math problems, and their performance in code, reasoning, and various benchmarks keeps rising.

Yet in many businesses that companies genuinely want to automate, humans still can't be removed.

Take customer service, for example.

Letting AI look up information, summarize documents, and draft replies is no problem.

But if you let AI decide on its own: should this money be refunded or not? Should this user be compensated?

Companies immediately become cautious.

These things are clearly much simpler than advanced mathematics, so why are companies afraid to hand them over to AI?

Diogo's answer was simple: Today's AI is incredible at assistance, not automation.

Today's AI is very good at helping you do work, but still not quite able to finish the work on its own.

These two things seem only slightly different, but in reality they are completely different.

No matter how powerful Claude Code is, you're usually still sitting in front of the computer. It writes code, you watch; it edits files, you check; if it's wrong, you have it fix it again.

So in Diogo's view, Claude Code still belongs to the "assistance era" that ChatGPT started.

What is true automation?

The human isn't present at all.

AI judges and executes on its own in the background, potentially running hundreds of thousands or even millions of times a day, and you may never even see what it did.

And so the question arises: why is today's AI so smart, yet still unable to function without humans?

Diogo pointed the finger at something he knows very well—RLHF.

When we trained AI, we put humans into the loop

This is somewhat ironic.

Because RLHF happens to be one of the technical paths Diogo helped advance back in the day.

The basic logic of RLHF is actually not complicated: collect human preferences, then make the model increasingly align with human preferences.

So in his talk, Diogo gave a very blunt explanation: why do today's large models always need a human in the loop?

Because when we trained it, we literally put humans into that loop.

From the very beginning, the model was learning: what kind of answer do people prefer?

This also explains a characteristic of large models that we are already very familiar with—even when it doesn't know, it can often sound extremely convincing.

Diogo gave a rather savage example on stage.

Someone sent ChatGPT a recording of a fart and told it that this was a piece of music they had created, asking it to evaluate it "sincerely and candidly."

As a result, ChatGPT praised it earnestly, saying it was an ambient music piece with a very eerie and strange atmosphere.

Diogo even summed it up in one sentence: "Overpromising is a feature."

Overpromising is not a bug, it's a feature.

For chat products, this isn't necessarily fatal. The user is still in front of the screen, and mistakes can be corrected.

But truly automated systems are completely different.

A machine doesn't care whether your answer sounds good; it only needs to know two things: what exactly should be done, and how confident are you really?

This also explains why Jev, released more than a month later, looks so unusual.

So Jev simply stopped letting AI "speak"

Even if an ordinary large model ultimately only needs to answer "A or B," it often still has to go through the token generation process.

Jev cuts that part out entirely.

It currently mainly does three things:

• Noul, answering Yes or No;
• Choice, selecting one from several options;
• Score, assigning a score according to criteria.

Then it directly returns judgments and probabilities.

It won't write you an essay, nor chat with you.

Officially published end-to-end latency is as low as 70–500 milliseconds, 20–200x faster than frontier models, and 40–400x cheaper.

But what's truly key is not actually the "speed," but the probability that comes after.

To this end, TypeSafe proposed a new training method: RLCD, Reinforcement Learning for Calibrated Decisions.

The problem it aims to solve is very practical: if AI tells you something has an 80% chance of happening, can that 80% really be trusted?

Ideally, among a batch of things the model judges to have an 80% probability, about 80% should actually happen in the end.

This is extremely important in automated systems.

With 99% confidence, it can execute directly.

With 51% confidence, it can be handed off to a stronger, more expensive large model, or even to a human.

The real trouble is not that AI doesn't know, but that AI doesn't know that it doesn't know.

So what Jev really wants to change is the object of AI's output.

In the past, the answers generated by ChatGPT were mainly for people to read. The judgments and probabilities Jev provides are meant to be handed directly to software to use.

The Agent era may not need a bigger brain

This also explains why Jev became popular right now.

Because once Agents actually start running, they generate a massive number of small judgments:

Which tool to call next? Which button to click on this webpage? Is this piece of information still useful? Is the task actually complete? Should the result be checked again?

Individually, none of these questions is difficult, but an Agent may need to make these judgments hundreds of thousands or millions of times a day.

If every time it calls the strongest large model, spending a few seconds to "deliberate" and then spitting out a long stretch of tokens, costs and latency quickly add up.

What Jev wants to capture is exactly this layer.

A large number of high-frequency small decisions go to Jev, while tasks that truly require complex reasoning go to large models.

This is also why TypeSafe calls Jev a System One Model.

The concept comes from Daniel Kahneman's "System 1" and "System 2": one is responsible for fast, intuitive judgments, and the other for slow, complex thinking.

Jev even takes its name from the "Jevons paradox":

When a resource becomes cheaper, people don't necessarily use less of it—they may actually use more.

If calling AI once is expensive, you'll only use it for the most important things.

But if one AI judgment becomes so cheap that it's almost negligible?

An email, a log entry, a tool call, a webpage button, every step an Agent executes—all of them could incorporate an AI judgment.

Of course, it's still too early to say Jev represents the next generation of AI.

Its so-called "zero hallucination" mainly means it won't break out of the prescribed answer types and make things up; it doesn't mean it won't choose wrong. Extreme figures like 193.6x and 444.6x also mainly come from TypeSafe's own tests.

But what's truly worth paying attention to in Jev's viral moment may not be whether it can challenge GPT or Claude.

Rather, it's that a person who helped create ChatGPT is re-asking a more fundamental question:

Over the past few years, the entire industry has been thinking about how to make AI think longer and say more.

But if what the future truly needs is billions of judgments between machines, why should AI have to "say something" first every single time?

ChatGPT taught machines how to talk to people.

And the next step Jev is betting on is: when people are no longer sitting in front of the screen, can machines make decisions on their own?