The Jev That Only Answers Multiple-Choice Questions—Yet Is the Most Distinctive LLM I’ve Seen This Year

If you ask what the hottest large language model has been over the past couple of days, there’s likely only one name:

Jev.

This model comes from TypeSafe AI, founded by Diogo Almeida.

Diogo Almeida @CompleteSkeptic · Sep 16
After co-inventing ChatGPT, I kept asking myself: why have superhuman chat models not led to AGI?
I’ve spent the last 2 years in stealth building a new way to train models (RLCD), and a new type of frontier AI model that we are releasing today: Jev
• 20-200x faster
• 40-400x … Show more 3.5K 12K 67K 32M

This guy used to work at OpenAI, where he helped create RLHF and InstructGPT—the key methods that eventually taught GPT to communicate naturally and led to ChatGPT and GPT-4.

Then, in early 2024, he left OpenAI to start his own company. After two years in stealth mode, he finally unveiled his brand-new model: Jev.

This thing is genuinely something different from what I’ve seen in the past year.

Really, it reignited a lot of my imagination about AI. Trust me, Jev is unlike any large language model you’ve encountered before.

Because this model does only one thing: high-frequency decision-making.

That’s right—a new model released in September 2026 that can’t chat with you, can’t write code, and can’t even generate text.

It only helps you make decisions and judgments—it’s a completely universal classifier.

It might still sound a bit abstract, but there’s a case on X these days that I think perfectly explains what Jev really is.

Developer Marcel Pociot integrated Jev into a browser extension.

Marcel Pociot 🧪 @marcelpociot · 23h
I built a browser extension with Jev @typesafeai that can hide/collapse posts on X based on natural language.
It’s so fast that it’s not noticeable and insanely cheap…this must be the future of “ad blockers” and content firewalls. 555 11K 62K

The functionality is extremely simple.

The extension connects to Jev in the background, and Jev filters out the content on X that you simply don’t want to see.

For example, you could set it up to hide deliberately provocative posts meant to bait replies, or content about cryptocurrency and NFTs, or political debates—whatever you prefer.

You could even say: “Collapse anything that’s obviously just trying to make me angry, make me reply, or drag me into an argument.”

Then you just scroll through X as usual.

Every time a new post appears, Jev makes a rapid judgment in the background:

Does this post match any of the categories we want to avoid?

If yes, it’s instantly collapsed; if not, it’s displayed normally.

This judgment takes on average only 380 milliseconds.

That is, the moment Jev sees a post, it inputs it, completes its judgment, and outputs whether to collapse it—all within 380 milliseconds.

Previously, if we encountered this kind of problem with large language models, you could certainly have the LLM make the judgment. But even with JSON output enabled, it would be slow. And if you enable reasoning, it’s even slower—possibly taking tens of seconds, even dozens of seconds, to complete a single judgment.

But we don’t actually need all that. We just need the model to output Yes or No as quickly as possible.

We don’t need it to generate any content; we just need it to make a judgment.

That’s exactly what Jev does.

This is the most peculiar—and the most appealing—aspect of Jev.

The large language models we’ve seen in the past have all been trying to learn one thing: how to better answer humans.

Jev took a completely different direction. It aims to solve:

What if the one who truly needs the answer is just a piece of code?

Code doesn’t require elegant prose or lengthy explanations.

It just wants to know: yes or no, A or B, continue or stop, etc.

What it needs is a directly executable judgment.

And honestly, not just for code—in this world, even for us humans, the vast majority of things are essentially decision-making judgments.

Should you buy this outfit? When facing the boss, do you block or dodge? When you’ve run out of tokens, do you reset or give up? When getting married, do you pay the bride price or not… There are countless such cases.

Often, even in our own lives, we don’t need lengthy text or analysis—we just need a decision. That’s all.

So Jev sprinted toward this goal. To optimize decision-making, they eliminated text generation entirely.

As a result, it’s 20 to 200 times faster, nearly real-time. When Jev plays a game, it can make 10 decisions per second, and it’s 40 to 400 times cheaper—just $0.042 per million tokens (output tokens are even free because only one decision is output, which consumes so few tokens they decided not to charge for it).

The tech community online has been having a blast with it.

For example, some people have used it to play Mario, because Mario is essentially about button-pressing decisions…

Faadil Shaik @faadilhshaik · Sep 16
got @typesafeai’s new model Jev to play Super Mario Bros.
fast inference + structured outputs makes it surprisingly good for real-time use cases.
I’m excited to see what can be done with these new models! 833 482.7K 537K

The results were surprisingly good.

Others have used it to control a browser to search for flights, finishing the entire task in just 7 seconds. After all, browser control is fundamentally about decision-making.

Gregor Zunic @gregpr07 · Sep 17
Breaking: Browser Use + Jev = Ultrafast ⚡
Finding flights took 7s and cost only $0.0039 🤯

new action space every step
DOM state space
small LLM fallback to type
(this video is at 1x speed btw)
Built a tiny open-source browser agent. try it below ↓ 223 753 7.6K 2M

And some experts have built trading bots with it, because trading is also fundamentally about decisions—buy or sell.

Jarrod Watts @jarrodwatts · Sep 17
I built a trading bot with Jev!
Jev decides if it should “buy” or “sell”, given the price feed of an asset pair, and executes real trades.
It uses Monad to place the orders on Kuru’s on-chain order book in every 300ms block.
Demo link → https://jev-trader.vercel.app 251 2814.5K 937K

There are many more examples.

Jev’s sub-second response time and ability to handle massive batches of judgments make it both super practical for real-world applications and boundless for expanding imagination.

This is how they define their model category: the System One Model.

The name “System One” comes from Daniel Kahneman’s famous book Thinking, Fast and Slow.

Kahneman roughly divided human thinking into two systems.

System 1 is fast thinking—automatic and intuitive.

For example, if I ask you “What’s 1+2?”, you’re not going to lower your head and ponder for three minutes before answering “3,” right?

System 2 is slow thinking.

It requires step-by-step analysis, like mathematical proofs or writing complex code.

Current models like GPT and Claude—especially the various Reasoning Models—are increasingly resembling a very powerful System 2.

Jev, however, is betting on the other side. They believe there are countless intelligent tasks in this world that simply don’t require lengthy reasoning.

So they built a new model architecture, a parallel sampler, and a training method they call RLCD—short for Reinforcement Learning for Calibrated Decisions.

Roughly translated:

Reinforcement Learning for Calibrated Decisions.

Just as RLHF optimizes for which answer humans prefer, and RLVR optimizes for whether an answer can be verified—leading to the rapid progress in mathematics and coding models in recent years—RLCD aims to optimize for whether a decision is correct, and whether the model’s stated “90% confidence” is actually close to 90%.

Because if you truly want to integrate AI into an automated system, the probability must be meaningful.

For example: if Jev outputs a confidence score > 0.90, execute it directly.
If 0.7 < confidence < 0.90, hand it off to a stronger LLM for review.
If confidence < 0.7, let a human decide.

So I think in Jev’s approach, the most important word isn’t just “fast” or “cheap”—this “calibration” is the real core.

When you connect Jev and get its output, you’ll see it looks like this:

That’s very satisfying.

And the best part is, all these judgment queries can be made in parallel at once.

For example, if I feed in an AI news article, I can simultaneously ask: Is it AI-related? Is it an ad? Is it about funding? Which category should it go into? Is it worth recommending to users? etc.

Jev can make all these judgments in one go, at incredible speed—it’s a game-changer.

This is a completely different approach from traditional LLMs generating one token at a time.

So this thing is essentially like:

A super if-else with world knowledge and semantic understanding capabilities.

You can currently apply for access on their official website; approval should come pretty quickly.

Here’s the link: https://typesafe.ai/

But if you’re eager to test it out, you can also use it on the aggregator platform Vercel, which has integrated Jev as a first adopter.

I also immediately tested some of the task judgment needs in AIHOT using Jev.

For example, a very basic pre-filtering task: every day, tens of thousands of pieces of monitored content are scraped and scored. The model responsible for final curation is a slightly larger, more expensive one—ensuring sufficient world knowledge and good taste.

But if we fed all those tens of thousands of items into that model, it would be very costly. So we use a cheaper model upfront for pre-filtering, removing all content unrelated to AI first. This saves a lot of money.

This pre-filtering task is very simple: just judge whether the current content is AI-related.

I tested 100 questions simultaneously on GLM-5.3 Flash, DeepSeek V4.1 Flash, Qwen 3.7 Flash, and Jev.

The results were quite surprising.

GLM 5.3 Flash was the only one to get everything right, but it was also the slowest and most expensive.

Jev currently seems the most balanced—second-highest accuracy and much cheaper. It’s even cheaper than DeepSeek V4.1 Flash during idle periods, though due to domestic network latency, Jev’s response time and speed are impacted.

Qwen 3.7 Flash remains the cheapest with the highest cost-performance ratio—only half the cost of Jev—but its accuracy is on par with DeepSeek V4.1, falling slightly behind.

On another task involving same-event clustering, Jev maintained roughly second-highest accuracy. This time, because the content volume was larger, it finally became the fastest option.

And if you let it handle a task better suited for Jev—parallel judgment, such as answering ten questions simultaneously about a news item—then its advantages really shine.

Highest accuracy, fastest speed, second-lowest cost.

For classification and judgment scenarios that require precision, Jev is currently the most cost-effective solution. Qwen 3.7 Flash is cheap, but once the task gets slightly more complex, its accuracy can drop by 7 points—making it unusable.

And this is only the first-generation model. If Jev releases 2.0 in a few months, I can’t imagine how much higher its accuracy will get, how much faster it will run, and how much cheaper it will become.

The name Jev comes from a famous concept in economics: the Jevons Paradox.

Its proposer was named William Stanley Jevons.

In the 19th century, as steam engines became more efficient, theoretically the same amount of coal could do more work—so wouldn’t humanity use less coal?

The opposite happened. As steam engine efficiency improved, using coal became more cost-effective, so more and more industries started using it.

In the end, total societal coal consumption actually increased.

Efficiency improves, per-use consumption drops, but total consumption soars—that’s the Jevons Paradox.

And TypeSafe gave their model this name.

The implication is clear: they’re betting that intelligence will also experience a Jevons Paradox.

The models we use today are getting more expensive, with rising costs. But do we really need such high-intelligence models for our daily tasks? Aren’t there countless judgments, decisions, and tasks that only require a model like Jev?

But what if one day, a judgment with fairly good semantic understanding becomes nearly free? What would happen then?

Why must AI always generate something?

Intelligence can certainly be used for creation.

But it can also be used purely for judgment.

Jev might indeed represent another crucial piece of the Agent era’s puzzle—a direction we’ve overlooked because ChatGPT was so successful.

The outline of the future seems to be gradually coming into focus.

If you’ve read this far and found it valuable, please like, comment, and share—it helps a lot!

Thank you for reading. See you next time.