Author: Zhu Xueying
Over the past couple of days, an unusual AI model suddenly went viral.
His name is Jev.
Can't chat, can't write code, and won't generate long answers like ChatGPT. It does only one thing: make decisions.
But this model, which seems to have had half its capabilities stripped away, has suddenly become popular among developers.
Some use it to analyze 724 real-time ads in 40 seconds, making a total of 8,724 judgments; others connect it to Claude Code to clean up irrelevant context; some even use it as a "referee" for AI agents to verify whether tasks have truly been completed. LangChain has also begun testing Jev’s performance as an agent evaluator.
Even more striking are the speed and price.
In TypeSafe's tests, Jev achieved a maximum speedup of approximately 193.6 times and reduced costs by up to 444.6 times. Input costs just $0.042 per million tokens, while output tokens are even free.
Why has an AI that appears to have fewer capabilities become popular?
Because we’ve entered the agent era, what AI truly needs may no longer be just “careful deliberation,” but rather massive, fast, and low-cost decision-making: what to do next, which tool to invoke, and whether a task has truly been completed. More importantly, these decisions will need to be made autonomously by AI in the background, without requiring humans to constantly monitor screens. Jev is attracted to these small decisions, which can occur millions of times per day.
Interestingly, Diogo Almeida, the founder of the Jev model, was involved in RLHF—and now he is reflecting on it: the training approach that made ChatGPT so effective may not be suitable for AI’s true path toward automation.
More than a month ago, Almeida gave a speech. Looking back now, that speech was almost Jev’s “instruction manual for thought.”
AI can solve advanced mathematics, so why can't it handle customer service well?
Diogo Almeida's resume is unique.
He previously worked at OpenAI and contributed to GPT-4, ChatGPT, and InstructGPT/RLHF projects—meaning he directly helped develop the most important post-training framework for today’s large models.
But in that speech, he began by joking that he was one of the few people inside OpenAI who publicly criticized ChatGPT.
His speech topic was more direct: What's Next After RLHF?
Diogo first raised a question that seemed contradictory.
Today's large models can already tackle extremely difficult math problems, with performance in coding, reasoning, and various benchmarks continuously improving.
Yet, in many business processes that companies truly want to automate, humans remain indispensable.
For example, customer service.
Having AI look up information, summarize documents, and draft responses is fine.
But if you let the AI decide: Should this money be refunded? Should this user be held liable for compensation?
Businesses immediately became cautious.
These things seem much simpler than advanced math, so why are we hesitant to entrust them to AI?
Diogo's answer was simple: Today's AI is incredible at assistance, not automation.
Today’s AI is great at helping you get things done, but it still isn’t quite able to finish tasks on its own.
These two things may seem only slightly different, but they are actually completely different.
No matter how powerful Claude Code is, you're still sitting in front of your computer. It writes code, and you watch; it modifies files, and you review; if there are errors, you ask it to fix them.
Therefore, in Diogo’s view, Claude Code still belongs to the “assistance era” initiated by ChatGPT.
What is true automation?
The person was not even present.
The AI autonomously makes decisions and executes actions in the background, potentially running hundreds of thousands or even millions of times per day—you may never see what it does.
The question arises: why is today’s AI so intelligent, yet still so dependent on humans?
Diogo turned his attention to something he knows very well—RLHF.
When we trained the AI, we included humans in the loop.
There's a certain irony to this.
Because RLHF is precisely one of the technical approaches Diogo helped promote back then.
The basic logic of RLHF is actually straightforward: collect human preferences and then train the model to better align with those preferences.
So Diogo gave a very straightforward explanation in his talk: why do today's large models always require human involvement?
Because during training, we literally put humans into that loop.
The model has been learning from the start: what kinds of responses do people prefer?
This also explains a characteristic of large models that we are already very familiar with—even without knowing, they often sound remarkably convincing.
Diogo gave a rather cutting example on site.
Someone sent ChatGPT a recording of flatulence and told it that it was a piece of music they had composed, asking for an “honest and frank” evaluation.
ChatGPT seriously praised it, saying it was an ambient music piece with a dark and eerie atmosphere.
Diogo even summed it up in one sentence: "Overpromising is a feature."
Overpromising isn't a bug; it's a feature.
For a chat product, this isn’t necessarily fatal—users are still at their screens and can correct mistakes.
But a true automated system is completely different.
The machine doesn't care how pleasant your answer sounds—it only needs to know two things: exactly what to do, and how confident you are.
This also explains why Jev, released over a month later, appeared so unusual.
So, Jev simply prevented the AI from "speaking."
Even a general-purpose large model typically goes through the token generation process, even if it ultimately only needs to answer "A or B."
Jev cut this part out entirely.
It currently focuses on three main things:
New, answer Yes or No;
Choice: select one from several options;
Score according to the standard.
Then return the judgment and probability directly.
I won't write you an essay or chat with you.
The officially announced end-to-end latency ranges from 70 to 500 milliseconds, making it 20 to 200 times faster than state-of-the-art models and 40 to 400 times more cost-effective.
But what really matters isn't "speed"—it's the probability that follows.
To this end, TypeSafe proposes a new training method: RLCD, Reinforcement Learning for Calibrated Decisions.
It addresses a very real problem: If an AI tells you there’s an 80% chance something will happen, can you really trust that 80%?
Ideally, events that the model predicts with an 80% probability should actually occur about 80% of the time.
This is very important in automated systems.
99% confidence, ready to execute directly.
With 51% confidence, you can hand it off to a more powerful, more expensive model—or even to a human.
The real problem isn't that AI doesn't know—it's that AI doesn't know it doesn't know.
So what Jev really wants to change is the target of AI output.
Past answers generated by ChatGPT were primarily intended for human consumption. The judgments and probabilities provided by Jev, however, are designed to be used directly by software.
In the agent era, what may be needed is not a bigger brain.
This also explains why Jev has become popular precisely now.
Once the Agent is fully operational, it will generate a vast number of small decisions:
Which tool should I call next? Which button should I click on this webpage? Is this message still useful? Has the task been completed? Should the results be rechecked?
Individually, these questions are not difficult, but an agent may need to make hundreds of thousands or even millions of such judgments in a single day.
If every response requires calling the strongest large model, spending several seconds to "think deeply," and generating a long sequence of tokens, costs and latency will quickly rise.
What Jev wants to grab is this layer.
Delegate large volumes of high-frequency, minor decisions to Jev, and reserve tasks requiring complex reasoning for the large model.
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 responsible for fast, intuitive judgments, and the other for slow, deliberate thinking.
Jev's name even comes from the "Jevons Paradox":
When a resource becomes cheaper, people may not use less—it might actually be used more.
If calling AI is expensive, you'll only use it for the most important tasks.
But what if AI judges it to be so cheap that it’s almost negligible?
An AI judgment may be incorporated into every email, log entry, tool call, webpage button click, and each step executed by the Agent.
Of course, it's still too early to say that Jev represents the next generation of AI.
Its so-called "zero hallucination" means it won't fabricate answers outside predefined types, but it doesn't guarantee correct selections; extreme figures like 193.6x and 444.6x primarily come from TypeSafe's own testing.
But what's truly noteworthy about Jev's sudden popularity may not be whether it can challenge GPT or Claude.
but rather someone who helped create ChatGPT is now re-examining a more fundamental question:
Over the past few years, the entire industry has been thinking about how to make AI think longer and speak more.
But if what the future truly requires is billions of judgments between machines, why must AI always "say a paragraph" each time?
ChatGPT taught machines how to communicate with humans.
And Jev’s next bet is: when people are no longer sitting in front of screens, can machines make decisions on their own?