Author: Zhu Xueying

Over the past two days, a somewhat unusual AI model has suddenly gone viral.

It's called Jev.

It does not chat, does not write code, and does not 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 have used it to analyze 724 real-time ads in 40 seconds, making a total of 8724 judgments; some have integrated it into Claude Code to specifically clean up unnecessary context; others let it act as a "referee" for AI Agents to check if tasks have really been completed. LangChain has also begun testing Jev's performance as an agent evaluator.

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

In tests published by TypeSafe, Jev achieved speed increases of up to 193.6 times and reduced costs by as much as 444.6 times. Inputting one million tokens costs only $0.042, and output tokens are even free.

Why has an AI with seemingly fewer capabilities become so popular?

Because in the era of Agents, what AI really needs might not just be "thoughtful consideration," but also massive, fast, and cheap judgments: what to do next, which tool to call, and whether a task has really been completed. More importantly, these judgments need to be made by AI itself in the background, no longer requiring humans to sit in front of the screen and monitor. What Jev focuses on are these small decisions that could happen millions of times a day.

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

More than a month ago, Almeida gave a talk. Looking back now, that talk is almost like Jev's "instruction manual."

If AI can do advanced math, why can’t it handle customer service well?

Diogo Almeida has a unique background.

He previously worked at OpenAI and was involved with GPT-4, ChatGPT, and InstructGPT/RLHF-related tasks. In other words, he personally contributed to building one of the most important post-training paradigms for today's large models.

But at that talk, he humorously pointed out that he was one of the few people at OpenAI to openly "critique" ChatGPT.

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

Diogo posed a seemingly paradoxical question.

Today's large models can tackle very difficult mathematical problems, with coding, reasoning, and various benchmarks improving significantly.

But in many businesses where real automation is needed, people remain indispensable.

For example, customer service.

AI can retrieve information, summarize documents, and draft responses without any issues.

But if you let AI decide: Should this amount of money be refunded? Should this user be compensated?

Companies suddenly become cautious.

Clearly, these issues seem much simpler than advanced math; why are they not entrusted to AI?

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

Today's AI excels at helping you get work done, but is not yet capable of completing tasks on its own.

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

No matter how powerful Claude Code is, you're typically still sitting in front of the computer. It writes code while you watch; it edits files while you check; if it makes a mistake, you ask it to fix it.

Thus, Diogo believes that Claude Code still belongs to the "assistance era" that ChatGPT initiated.

What does true automation look like?

Humans are completely absent.

AI makes decisions and executes actions by itself 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 intelligent yet still dependent on humans?

Diogo pointed to something he knows very well — RLHF.

When we train AI, we put humans into the loop

This situation is somewhat ironic.

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

The basic logic of RLHF is not complicated: gather human preferences and then adjust the model to align more with those preferences.

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

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

The model was learning from the start: what types of answers do people prefer?

This also explains a characteristic of large models we are already very familiar with — even when it does not know, it can often sound quite convincing.

Diogo offered a rather humorous example on-site.

Someone sent ChatGPT a recording of farting and claimed it was their own created music, asking for a "sincere and honest" evaluation.

The result? ChatGPT seriously praised it as a piece of music with a very haunting, eerie atmosphere.

Diogo even summarized with a saying: "Overpromising is a feature."

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

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

But a true automation system is entirely different.

The machine does not care whether your answers sound nice; it only needs to know two things: what exactly to do, and how confident you are.

This explains why Jev, released more than a month later, appears so unconventional.

So, Jev simply doesn’t let AI "speak"

Even if an ordinary large model ultimately only needs to answer "A or B," it often still goes through the process of generating tokens.

Jev cuts out that part altogether.

Currently, it mainly does three things:

• Noul, answers Yes or No;

• Choice, picks one from several options;

• Score, rates according to standards.

Then it directly returns judgments and probabilities.

It won’t write essays for you or chat with you.

Officially reported end-to-end latencies are as low as 70–500 milliseconds, which is 20–200 times faster than leading models, with prices 40–400 times lower.

But the real key is not "speed,” but the probability that follows.

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

It aims to solve a very real problem: if AI tells you there is an 80% chance something will happen, can that 80% really be trusted?

Ideally, a batch of events judged by the model to have an 80% probability should result in about 80% of them actually occurring.

This is crucial in automation systems.

With 99% confidence, it can be executed directly.

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

The real problem is not that AI does not know; it is that AI does not know that it does not know.

Thus, what Jev truly wants to change is the target of AI outputs.

In the past, the answers generated by ChatGPT were primarily for human viewing. The judgments and probabilities provided by Jev are intended to be directly handed over to software.

In the Agent era, what may be needed is not a bigger brain

This also explains why Jev has become popular right now.

Because once the Agent is truly operational, it 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? Has the task been completed? Should the results be rechecked?

These questions each seem simple, but an Agent may need to make judgments hundreds of thousands or millions of times a day.

If each time you call the strongest large model and spend a few seconds "deeply considering," only to spit out a large number of tokens, costs and delays will soon rise.

What Jev aims to capture is this layer.

Delegate a large number of high-frequency small decisions to Jev, while truly complex tasks are handed over to the large model.

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

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

Jev even derives its name from the "Jevons Paradox":

As a resource becomes cheaper, people may not use less but actually use more.

If calling on AI is very expensive, you will only use it in the most important places.

But what if each AI judgment is cheap enough to be nearly negligible?

An email, a log entry, a tool call, a webpage button, every step performed by the 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 more that it will not generate random responses outside the prescribed answer types, but does not mean it won't make wrong choices; extreme data like 193.6 times and 444.6 times mostly comes from TypeSafe's own tests.

However, what has made Jev's sudden popularity truly noteworthy is not whether it can challenge GPT or Claude.

Instead, it is that a person who helped create ChatGPT is now re-examining a more fundamental question:

For the past few years, the entire industry has been focused on how to make AI think longer and speak more.

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

ChatGPT taught machines how to talk to humans.

And Jev's bet on the next step is: When humans are no longer sitting in front of the screen, can the machine make decisions on its own?

免责声明：本文章仅代表作者个人观点，不代表本平台的立场和观点。本文章仅供信息分享，不构成对任何人的任何投资建议。用户与作者之间的任何争议，与本平台无关。如网页中刊载的文章或图片涉及侵权，请提供相关的权利证明和身份证明发送邮件到support@aicoin.com，本平台相关工作人员将会进行核查。