Jev Is the Model That Only Makes Decisions — and That’s the Point

What if the model never wrote a sentence?

For the last couple of days, one name has been everywhere in AI circles: Jev. It comes from TypeSafe AI, founded by Diogo Almeida, and it takes a very odd approach to being a model.

Jev cannot chat with you. It cannot write code. It cannot draft a paragraph. In fact, it cannot generate natural language at all. Its job is much narrower: make a decision, quickly and in a form a program can use.

That sounds less impressive until you notice how much of an AI product is made of tiny decisions. Show this item or hide it? Route this request to search or SQL? Keep going or stop? Ask the user or take the next action?

This is an English adaptation of a Chinese field article by 数字生命卡兹克. I’ve kept its central argument and reported experiments, then tightened a few transitions so the piece works as an English technical essay. The benchmark figures below belong to the original author’s tests; they are not independent Jev Fieldnotes measurements.

The X filter is the easiest way to get it

A developer, Marcel Pociot, connected Jev to a browser extension that filters posts on X. The idea is almost comically simple: tell the extension which kinds of posts you do not want to see, and let Jev check each new post in the background.

Maybe you want to hide engagement bait, crypto and NFT threads, or political arguments. Maybe the rule is more personal: fold away anything that is obviously trying to make you angry, pull you into a reply, or keep you stuck in a fight.

The feed still behaves like a normal feed. A post arrives, Jev checks whether it matches one of those categories, and the extension hides it only when the answer says it should.

The reported average decision time was about 380 milliseconds. A regular LLM could do the same classification, but JSON output still takes generation time, and a reasoning model takes longer again. For this job, you do not need a witty explanation. You need a fast yes or no.

post = read_new_post()
answer = jev_decide(post, question="Should this post be folded away?")
if answer.probability > threshold:
    hide(post)
else:
    show(post)

Jev is betting that code is the real customer

Most models are trained to answer people better. Jev starts from a different question: what if the final consumer of the answer is a piece of code?

Code does not need elegant prose. It needs “yes” or “no,” “A” or “B,” “continue” or “stop.” It needs a value that can go straight into a branch.

That is why the model feels so different. The goal is not to make the answer longer or more human-sounding. The goal is to make a bounded judgment quickly enough that it can sit inside a live loop.

Once you look for these loops, they are everywhere: should I buy this shirt, should the game block or dodge, should the agent reset its context, should a workflow ask for approval? Humans use richer reasoning when the stakes are high, but many everyday actions still begin with a compact choice.

The speed and price come from throwing text away

The source article reports a 20× to 200× speed advantage over conventional LLM calls for this style of task, and a 40× to 400× cost reduction. It cites a price of $0.042 per million input tokens, with output free because the model returns only a small decision. Treat those as the author’s reported figures and check the current official pricing before budgeting.

The point is not that every Jev call will be 200 times faster. Network distance, batching, prompt size and the competing model all matter. The point is that a model which never has to write a paragraph has a much smaller job to do.

Why people are using it for games and browsers

The demos make the idea memorable. One project uses Jev to play Mario, where the loop is essentially: inspect the screen, decide which button to press, then inspect the next frame. Another controls a browser to search for a flight from Zurich to London; the reported run completes in roughly seven seconds. A third experiment applies the same decision pattern to trading.

These are not proofs that Jev is ready to run your business. They are good mental models. A game controller, a browser agent and a trading bot all spend a lot of time choosing the next action from a bounded set. Jev can make those choices without pretending to be a general-purpose assistant.

System One, plus a training goal called RLCD

TypeSafe calls Jev a System One Model, borrowing the fast-thinking and slow-thinking distinction from Daniel Kahneman’s Thinking, Fast and Slow. System One is automatic and intuitive; System Two is deliberate and analytical.

GPT, Claude and today’s reasoning models increasingly look like powerful System Two tools. Jev is a bet on the other side: there are huge numbers of useful decisions that do not need a chain of thought.

The company describes a parallel sampler and a training approach called RLCD, or Reinforcement Learning for Calibrated Decisions. RLHF rewards answers people prefer. RLVR rewards answers that can be verified. RLCD is meant to reward decisions that are correct and probabilities that mean what they claim.

That calibration is the part I would watch most closely. If a system is going to automate a branch, a confidence value has to be useful. A practical policy might send high-confidence answers to a rule-gated action, medium-confidence answers to a stronger model, and low-confidence answers to a person. The exact cutoffs are application policy, not universal truths.

The output is small, but you can ask several questions at once

A Jev response can be a typed boolean with a probability, a choice from a fixed set, or a score on a defined scale. That makes the result easy to consume and easy to validate.

The other trick is parallelism. Give Jev one AI news item and you can ask several questions together: is it about AI, is it an advertisement, is it a funding announcement, which category does it belong to, and should it be recommended?

That is a different shape from a text model producing one token after another. You are not asking for a single answer that explains everything. You are asking a bundle of small questions that a program can use immediately.

The most useful test is often the cheap pre-screen

The source author describes using Jev in AIHOT to pre-screen thousands of monitored items before sending the survivors to a larger, more expensive model. The first question is basic: is this item actually related to AI?

That is exactly the kind of task where a small decision model earns its keep. A cheap first pass removes obvious misses, while the larger model keeps the world knowledge and editorial judgment needed for the final selection. Jev is not replacing the stronger model; it is reducing the number of times that model has to wake up.

The reported comparisons below are useful as a shape of experiment: hold the task fixed, compare accuracy, errors, latency and cost, then check what happens when you ask many questions in parallel. They should not be read as a universal leaderboard.

What the benchmark suggests

In the first 100-question pre-screen, the source report says GLM 5.3 Flash was the only model to get every item right, while Jev came second on accuracy and cost less than the larger options. Qwen 3.7 Flash was cheapest, but its accuracy was lower.

On a larger parallel-decision run, the report puts Jev first on accuracy, fastest on a single decision and second-lowest on cost. That combination is the interesting result: Jev does not have to win every column to be valuable. It has to be good enough, fast enough and cheap enough for the specific decision loop.

The tables are rendered from the numbers shown in the original article. They are here so you can inspect the trade-offs instead of taking a headline like “best” at face value.

Jevons is the name for the long bet

The name Jev comes from William Stanley Jevons and the Jevons paradox. When steam engines became more efficient, coal became cheaper to use. Instead of society burning less coal, more industries adopted steam power and total coal consumption went up.

The same possibility sits behind TypeSafe’s naming choice. If a useful semantic decision becomes cheap enough, people may use far more decisions. Lower cost does not necessarily shrink the market; it can make entirely new loops affordable.

That is the larger question Jev raises: why does intelligence always have to generate something? Intelligence can create. It can also classify, filter, route and decide. The second category has been easy to overlook because ChatGPT made the first category so visible.

My read: this is a missing layer, not a replacement

Jev is not a better chatbot. It is not a cheaper way to write an essay. It is a specialized component for systems that already know what kinds of answers they can accept.

That makes it a plausible missing layer for agents: rules handle the obvious cases, Jev handles high-volume bounded judgments, a stronger model handles the hard cases, and a person still owns the decisions that carry real risk.

The source article is excited about where a second-generation Jev might go. That excitement is fair as a prompt for experimentation, but the engineering path is still the same: define the categories, build a labeled test set, measure the fallback rate, and keep a switch that turns the model off.

AI does not always need to generate. Sometimes the most useful answer is a clean decision that arrives before the next screen refreshes.