Jev Suddenly Goes Viral: No Chatting, No Coding, Just Judgments

Author: Zhu Xueying

In the past few days, an unusual AI model has suddenly gone viral.

It's called Jev.

It doesn't chat, doesn't write code, and doesn't generate long answers like ChatGPT. It only does one thing: make judgments.

Yet, this model, which seems to have "had its capabilities cut by more than half," has suddenly become popular in the developer community.

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

What's even more impressive is its speed and cost.

In tests released by TypeSafe, Jev achieved a speed increase of about 193.6 times, with costs reduced by up to 444.6 times. It costs only $0.042 for every million tokens input, and output tokens are even free.

Why has an AI that seems to have fewer capabilities become so popular?

Because in the era of Agents, what AI truly needs may not just be "thoughtful consideration," but also massive, rapid, and inexpensive judgments: what to do next, which tool to call, whether a task is completed. More importantly, these judgments need to be made by AI itself in the background in the future, without requiring humans to sit in front of the screen all the time. Jev focuses on these small decisions that may occur millions of times a day.

Interestingly, Jev's founder, Diogo Almeida, has participated in RLHF and is now reflecting on it: the training method that made ChatGPT useful may not be suitable for AI to truly achieve automation.

A month ago, Almeida gave a speech. Looking back now, that speech was almost Jev's "manifesto."

Why Can AI Do Advanced Mathematics but Not Customer Service?

Diogo Almeida has a unique background.

He previously worked at OpenAI, participating in the development of GPT-4, ChatGPT, and InstructGPT/RLHF. In other words, he was directly involved in building one of the most important post-training paradigms for today's large models.

However, in that speech, he humorously pointed out that he was one of the few people at OpenAI who openly criticized ChatGPT.

His speech's theme was more direct: What's Next After RLHF?

Diogo first posed a seemingly contradictory question.

Today's large models can tackle very difficult math problems, and their performance in coding, reasoning, and various benchmarks is continuously improving.

Yet, in many businesses where automation is truly desired, humans still cannot be removed.

For example, customer service.

AI can look up information, summarize documents, and draft replies without any issues.

But if AI has to decide for itself: should this money be refunded? Should this user be compensated?

Companies become cautious all of a sudden.

Clearly, these tasks seem much simpler than advanced mathematics, so why are they hesitant to hand them over to AI?

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

Today's AI is great at helping you work, but it still struggles to complete tasks on its own.

These two things may seem similar, but they are fundamentally different.

No matter how strong Claude Code is, you usually still sit in front of the computer. It writes code while you watch; it modifies files while you check; if it makes a mistake, you have to ask it to correct it.

Thus, in Diogo's view, Claude Code still belongs to the "assistance era" initiated by ChatGPT.

What does true automation look like?

Humans are not present at all.

AI makes judgments and executes tasks in the background, potentially running hundreds of thousands or even millions of times a day, and you may never see what it has done.

The question arises: why is today's AI so smart yet still dependent on humans?

Diogo points the finger at something he is very familiar with—RLHF.

When We Train AI, We Put Humans in the Loop

This situation is somewhat ironic.

Because RLHF is precisely one of the technical routes that Diogo helped promote back in the day.

The basic logic of RLHF is not complicated: collect human preferences and make the model increasingly align with those preferences.

So Diogo provided a very straightforward explanation in his speech: why do today's large models always need humans in the loop?

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

From the beginning, the model has been learning: what kind of answers do people prefer?

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

Diogo gave a rather amusing example on stage.

Someone sent ChatGPT a recording of flatulence, telling it that this was a piece of music they created and asking for a "sincere and candid" evaluation.

As a result, ChatGPT seriously praised it, saying it was a piece of environmental music with a very eerie and strange atmosphere.

Diogo even summarized it with a phrase: "Overpromising is a feature."

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

For chat products, this may not be fatal. Users are still in front of the screen and can correct mistakes.

But a true automation system is completely different.

Machines do not care whether your answer sounds good; they only need to know two things: what to do and how confident you are?

This also explains why Jev, released over a month later, appears so unusual.

So, Jev Simply Doesn't Let AI "Talk"

Even ordinary large models, when they only need to answer "A or B," often go through the process of generating tokens.

Jev cuts this part out entirely.

It currently mainly does three things:

• Noul, answers Yes or No;

• Choice, selects one from several options;

• Score, rates according to standards.

Then it directly returns judgments and probabilities.

It doesn't write essays for you or chat with you.

The official end-to-end latency is as low as 70 to 500 milliseconds, which is 20 to 200 times faster than cutting-edge models, and costs 40 to 400 times less.

But the truly critical aspect is not "speed"; it's the probability behind it.

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 that something has an 80% probability of happening, can you trust that 80%?

Ideally, a batch of things judged by the model to have an 80% probability should end up occurring about 80% of the time.

This is very important in automated systems.

99% confidence can be executed directly.

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

The real problem is not that AI doesn't know; it's that AI doesn't know that it doesn't know.

So what Jev truly wants to change is the target of AI's output.

In the past, the answers generated by ChatGPT were mainly for humans to read. The judgments and probabilities provided by Jev are meant to be directly used by software.

In the Era of Agents, What May Be Needed Is Not a Bigger Brain

This also explains why Jev has become popular now.

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

Which tool to call next? Which button to click on this webpage? Is this information still useful? Is the task completed? Does the result need to be rechecked?

Each of these questions seems easy on its own, but an Agent may need to make judgments hundreds of thousands or even millions of times a day.

If each time it calls the strongest large model, taking a few seconds to "think deeply" and then spitting out a long string of tokens, the costs and delays will quickly add up.

What Jev aims to capture is this layer.

Hand over a large number of high-frequency small decisions to Jev, while truly complex reasoning tasks can be handed over to large models.

This is also why TypeSafe refers to Jev as the System One Model.

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

Jev's name even comes from the "Jevons Paradox":

When a resource becomes cheaper, people may not use it less; instead, they might use it more.

If calling AI is very expensive, you will only use it for the most important tasks.

But what if AI judgments become so cheap that they are almost negligible?

An email, a log, a tool call, a webpage button, every step executed by an Agent could incorporate an AI judgment.

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

Its so-called "zero hallucination" means it won't deviate from the prescribed answer types; it does not mean it won't make mistakes; extreme data like 193.6 times and 444.6 times mainly comes from TypeSafe's own testing.

But what makes Jev's sudden popularity truly worth noting may not be whether it can challenge GPT or Claude.

Rather, it is that a person who participated in creating ChatGPT is now re-examining a more fundamental question:

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

But if what is truly needed in the future is billions of machine-to-machine judgments, why does AI have to "say a paragraph" every time?

ChatGPT taught machines how to talk to humans.

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