Former OpenAI Researcher Launches Jev, Calls Pre-Jev AI World a Tragedy

On September 22, TypeSafe CEO and Jev founder Diogo Almeida appeared on the Latent Space podcast to talk about his newly released Jev. He called the release "in some sense, yes, exactly" a low-key research preview, and said the most accurate label right now is a System 1 model, which could also be called a machine-native model or a large programmable model. His definition: the goal of this class of models is to make code the direct consumer of model outputs.

Almeida's background includes work on OpenAI's InstructGPT. He distinguishes Jev from Claude Code and Codex: in his view, Claude Code and Codex essentially still belong to the same stage, where AI's main role remains providing assistance around a human, and "the next era is not the Claude Code era." His more direct phrasing: "In my view, the AI world before Jev appeared was simply a tragedy."

Jev's optimization objective is "intelligence per dollar," with the name taken from the Jevons paradox. Almeida says the name Jev will in the future represent a series of frontier models that lead on intelligence per dollar. He acknowledges that in machine learning everything is a trade-off, and the team has decided to go all-in on this direction.

Almeida's core criticism of RLHF is "mode dropping." He says almost no one notices this drawback: RLHF's mode dropping biases the model toward generating safer, more common answers at the expense of true calibration of the probability distribution. This both masks error accumulation in long text and explains why text models are bad at decision-making.

He uses Yann LeCun's slide about sequence length as a contrast: if every generation step has a probability of error, the longer the text, the higher the probability of at least one mistake—yet the model's actual behavior does not simply follow that trend. His explanation is that if a model tries to cover the entire distribution and the probability distribution is well calibrated, it will not be over-penalized for producing a few outlier results; a GAN, by contrast, suffers mode collapse, discarding very small categories entirely and generating only the most common ones.

From this he derives a judgment: to generate very long text that is unlikely to contain obvious errors, the model must be extremely conservative, because once it makes a mistake, people easily notice; conversely, an answer that looks fine but actually omits subtle points is very hard to detect. He argues this relationship explains both why that intuitive error-accumulation inference did not come true and why text models are bad at decision-making.

The difference between RLCD and RLHF, he first attributes to the optimization objective: RLHF focuses on making the model follow human instructions and give answers that win approval, whereas RLCD wants the model to become a capability that software can reliably call. Jev aims to output choices, scores, and probabilities that code can use directly, letting developers set thresholds based on uncertainty and decide when to execute and when to hand off to a human.

Almeida states plainly that he is not against safety itself, but argues that specific value judgments should not be written directly into the base capabilities of a general-purpose model; instead, the boundary between technical capability and specific usage responsibility should be drawn like a database. He distinguishes capability alignment from safety alignment: capability alignment means making the system complete the user's task as much as possible, whereas safety alignment often means the model, beyond following the current user's instructions, must also prioritize another set of rules set by the model provider—and these two sets of requirements sometimes conflict.

He compares a model called by a program suddenly refusing to answer to a type error. If the model is a software dependency running in the background, and some call suddenly refuses, the user calling it may have no idea there is even such a model underneath; should the entire software pipeline randomly break just because a special message appears in the input? He argues this design inherits the imagination of "AI as a chat colleague" and fails to fully consider what requirements a model must meet as a software component.

To the counterexample of "what if someone uses this API to kill people," he responds that he too does not want technology used to harm people, but that enterprises can take a stance for practical reasons, and he does not think these preferences should be written directly into the base capabilities of general-purpose technology. He prefers to think of intelligence as a database rather than an "AI colleague": we normally do not require a database to judge on its own, when executing a query, whether the user will ultimately use the results for something bad.

He also mentions a scenario he finds strange: a developer told their team on Slack that they were preparing to deploy an application, and asked, "Can we use Jev this way?" His first reaction was that we provide an API, you are the developer, and how the specific application is designed should not require our approval on every point. Ideally, complex tasks would be broken into many smaller calls, and as an underlying service provider, we should not even need to know the full task of the downstream user.

Asked whether developers can trust that the same version's behavior stays stable, Almeida says he values robustness more: if the meaning of the question has not changed, adding irrelevant characters should not drastically change the judgment—not merely pursuing identical outputs for identical inputs. He promises that already-deployed models will not be silently modified, because the API is a dependency in other people's programs; but new versions will be released quickly, and for now he cannot promise to maintain every old version forever.

He states plainly that he dislikes public benchmark leaderboards, and that gaming scores is one reason. He is not against evaluation; he is against optimizing around leaderboards, which detaches scores from real value. He mentions the team uses internal evaluations to compare cost and capability, pursuing stronger performance at the same cost and cheaper performance at the same capability.

Regarding terms that previously caused misunderstanding, he mentions the relevant restrictions were left over from preview-period terms and were not removed in time at official release; the team plans to revise them and has asked the team and lawyers to confirm. He says they obviously do not intend to stop users from testing and comparing models, but that is a different matter from how he views public benchmark leaderboards.

His advice to developers: break complex tasks into the smallest semantic units that can be judged independently, provide necessary information through structured input, and let code control the final behavior. Choice corresponds to selecting branches, Noul corresponds to conditional judgments, and Score corresponds to scoring, ranking, and filtering; each step can be evaluated separately, thresholds adjusted, and when capability is insufficient, handed off to a human or simply not deployed.

Almeida lays out four categories of enterprise application directions: analyzing "dark data" left idle because processing costs are too high; providing fast judgments for real-time processes; checking other models' calls and outputs; and embedding intelligent judgment into the core logic of software. He says he is especially bullish on dark data analysis and coding agents, but how exactly to combine models still depends on whether it can lower costs and solve problems that were previously unsolvable.

On discussions of frontier AI risk and slowing down, he argues such discussions often assume everyone must continue increasing investment along the existing RLVR path, but research goals and technical routes can both be chosen anew. How much action space to give a model in order to improve performance is itself a design decision and should not be treated as an inevitable premise.

Regarding Jev itself, several things remain undecided: Almeida says he did not expect this release to attract so much attention, and he still has things in hand he has not revealed; he says Jev is still far from the ideal state, and he hopes to improve reliability by several orders of magnitude, ultimately making calling intelligence as natural as executing a database query. He also does not promise to maintain every old version forever, and says that on whether Yann LeCun's JEPA direction is already practical enough, he does not want to judge for now.

In the first week after release, he describes his emotional state as "never been worse," like an exhausted walking corpse, yet psychologically he actually feels more in tune with reality. He decided to prioritize public community communication rather than spending time on VIPs and investors, hoping that engineers and developers are the ones who truly get most of his attention.