Jev: Why an AI That Only Makes Decisions Is Blazingly Fast and Absurdly Cheap

Not a Chatbot — A "Decision Model"

If you're tired of the endless flood of chatbots, an AI called Jev might just reignite your interest. It's not another large language model — you can't have a conversation with it, ask it to write a quicksort algorithm, or discuss the meaning of life. It does exactly one thing: make decisions.

The video's author uses a classic analogy to explain how it works — "System 1 thinking." Imagine you're playing soccer and a ball suddenly flies at your face. You don't calmly analyze the situation: "I'm currently playing soccer; let me calculate the ball's velocity and direction, then evaluate my options." You just dodge. That fast, instinctive judgment is System 1 thinking, and Jev is built precisely for that kind of scenario.

Its positioning is crystal clear: rather than becoming an all-powerful "superintelligence," it aims to do one thing — decisions — to the absolute extreme: fast, cheap, and accurate. The author repeatedly emphasizes that this is the first AI product in a while that genuinely excites him, because it's "not just reheating the same old stuff."

"System 1 thinking" comes from psychologist Daniel Kahneman's dual-process theory in Thinking, Fast and Slow. System 1 is fast, automatic, and unconscious — relying on intuition and pattern matching with almost no cognitive overhead. System 2 is slow, deliberate, and conscious — requiring active attention for logical reasoning. Traditional LLMs, when generating responses, operate more like System 2: they reason token by token, weigh semantics, and produce coherent long-form text, making them inherently slower and more expensive. Jev's design philosophy bypasses this entirely, handling only what System 1 can do: quickly outputting a classification result given a context, without generating any explanatory text. This trade-off is the fundamental source of its speed and cost advantages.

How It Works: Give It a State, Ask Yes/No Questions

Jev's interaction model is surprisingly simple. You give it a state — essentially telling it "here's what the world looks like right now" — and then ask it a set of questions for it to judge. The key is that these questions are executed in parallel, which is why it's so fast.

The author outlines several question types:

• Type choice: Pick one option from several. For example, given the state "I ripped my pants at a weightlifting competition," it chooses between "keep going," "go shower," or "pretend nothing happened and keep training" — and recommends with 95% confidence that you go clean up.
• Score: Provides relative confidence levels for each option, such as 85% confidence in a given choice.
• Newell value: A number between 0 and 1, named as a nod to the Bernoulli distribution.

The author demonstrates its practical use with a Super Smash Bros. example: the state is set to "you are Donkey Kong, you want to win, and you've received a message from another player," followed by two questions — Is this message appropriate? Does this message help Donkey Kong win? When the message is a profanity, it judges it as "inappropriate and unhelpful"; when the message is changed to "defeat all opponents," it judges it as "appropriate and quite helpful."

This example addresses a real pain point. The author once ran an event where 2,000 players collectively controlled four Smash Bros. characters. Every incoming message had to be reviewed by a "very slow agent" to check for inappropriate content — taking about a minute and a half per message. With Jev, you can instantly and in parallel judge "is this appropriate? if not, delete it" the moment a message arrives, eliminating those awkward pauses entirely.

How Cheap? 3 Million Q&As for Just $44

Jev's most striking feature is its price. The author shows himself repeatedly playing Balatro (the poker roguelike) with it, burning through 8 to 10 million tokens in just a few minutes — with almost no visible change in the bill.

The company claims it's "190×3 times faster and 444 times cheaper" than some unnamed model — though the author admits he couldn't figure out exactly what it's being compared against. But the real billing data speaks more clearly: the Smash Bros. query used only 345 input tokens, and Jev charges only for input tokens. The author did the math: that means you can ask roughly 3 million such questions for a total of just $44 — working out to roughly $42 per billion tokens, with each execution taking about 100 milliseconds.

This is also where the name comes from — Jev is derived from Jevons Paradox: the cheaper something gets, the more people use it, and demand actually increases. When the marginal cost of a decision approaches zero, you're willing to embed it in places where using AI would never have been considered before.

Jevons Paradox was proposed by 19th-century British economist William Stanley Jevons. While studying coal consumption, he found that improvements in steam engine efficiency didn't reduce total coal usage — instead, lower operating costs sparked far greater demand, causing total consumption to rise dramatically. This phenomenon has since been applied broadly to energy, computing resources, and more: when the efficiency of a resource improves dramatically, overall demand often rises rather than falls. Jev's namesake hints at its core business logic: when the cost of a single decision drops from "not worth it" to "practically free," developers will embed it into stages of their pipelines they would never have considered using AI for — creating entirely new use cases rather than simply replacing existing ones.

It Can Play Games — and Control Your Computer

To demonstrate its real-time capabilities, the author had Jev play several games. It can play Balatro in real time, formulate strategies like "build toward pairs scaling," pick Joker cards around those strategies, and win about 30% of the time (though the author jokes that its stubborn refusal to pick up Joker cards drove him crazy). It can also play Mario and Doom.

The Doom gameplay reveals its core nature: it simultaneously answers multiple yes/no questions — "Should I dodge?" (either stand still or duck), "Should I fire?" (either hold the trigger or release). You can watch it "hold fire and wait for enemies to get closer" — which is actually sound tactical judgment. All complex behavior is broken down into a series of parallel classification problems.

The application that really got the author hooked was Computer Use. He connected Jev to a remote QEMU session, pulling a screenshot on each request and having it take action based on what it sees on screen. He states plainly that paired with a "very dumb but very cheap" model, it could operate hundreds of times faster than traditional approaches.

He also points to two other directions worth exploring:

• Email triage: As emails arrive, judge "is this urgent?" and trigger different workflows accordingly for real-time sorting.
• Context pruning: Before feeding context to an agent, ask Jev "is this relevant to the task? if not, discard it" — compressing the agent's context window.
• Replacing brittle automated tests: The author jokes about "badly written Playwright tests" — since form-filling is fundamentally "just a classification problem," Jev performs well at this kind of task.

QEMU is an open-source hardware virtualization emulator that can run a complete virtual operating system on a host machine. In AI automation scenarios, connecting a model to a QEMU remote session means the model can capture screen state via screenshots, then execute actions through simulated keyboard and mouse input — enabling programmatic control of a full desktop environment. The traditional bottleneck in "Computer Use" setups has always been latency: every step requires sending a screenshot to the model for understanding, then waiting for the model to return an instruction, with delays stacking up to make the overall process extremely slow. Jev's low-latency characteristic (~100ms per call) is especially valuable here — it can instantly provide a classification judgment of "what to do next" as each frame arrives, making the control loop feel near-real-time rather than waiting seconds or even tens of seconds as with traditional approaches.

A Pragmatic Vision: Build Prod, Not God

The author specifically highlights Jev's manifesto: composable AI, build prod, not God. He draws on an analogy from the early days of the automobile: the first cars carried over many useless assumptions from the horse-and-buggy era (like fitting cars with blinders). Similarly, many people today force LLMs to handle decision-making — but decision-making isn't what LLMs are good at. Jev's approach is to extract "decisions" from large models and build them into a dedicated, composable module.

This restraint is actually its most compelling quality. It doesn't promise to end the universe — it only promises to do one small thing with extreme speed and extreme affordability. For developers, 100-millisecond real-time judgments at near-zero cost means many ideas that were previously rejected as "too slow and too expensive" suddenly become viable.

A word of caution: this article is based on a single video source with an obvious demo and subjective bent. The author doesn't specify which model Jev is benchmarked against, nor does he provide rigorous accuracy benchmarks — reliability in production environments will need to be verified independently. But as an exploration of what AI products can look like, a "cheap model that only makes decisions" offers a genuinely different way of thinking compared to chatbots.