Testing Jev: Can This New AI That Claims 200ms Decision-Making Actually Play Balatro?

Well-known programmer streamer ThePrimeagen (Prime) tested a recently discussed new AI tool called Jev (pronounced "gev", named after the Jevons Paradox in economics) during a live stream. Unlike familiar large language models, Jev is positioned as an ultra-fast classification decision engine that reportedly makes judgments from a given set of options in approximately 200 milliseconds. Prime used it to attempt to have an AI autonomously play the roguelike card game Balatro, revealing both the potential and limitations of this type of tool.

What Is Jev: A High-Speed Decision Classification Engine

Jev's core characteristic isn't generating long text — it's selecting one action from several options in an extremely short time. Prime repeatedly emphasized this point during testing: when he fed Jev a game state and a set of possible actions, the result came back almost instantly.

"Did you see how fast that was? That's why everyone is excited about this — it lets you run super, super fast."

His minimal example clearly illustrates the design philosophy: throw Jev a situation ("I pooped my pants, I need help"), provide two options (technical or interact), and Jev returns what it thinks the right action is along with a confidence probability. The entire interaction model revolves around three components: state (input context), questions (available actions), and answer (output with probability).

It's worth emphasizing that each Jev call is stateless — it carries no conversation history. Prime corrected viewers during the stream: "Every prompt to Jev is a brand new prompt, it doesn't carry the history of what I'm doing." This means the usage pattern requires an external system to continuously feed in the complete current state.

Jev's name comes from the Jevons Paradox, an economic concept proposed by British economist William Stanley Jevons in 1865: when technological progress improves the efficiency of resource use, total consumption of that resource actually increases, because lower costs generate greater demand at scale. Naming this tool after that concept hints at its core logic — the faster and cheaper the inference, the more frequently developers will call it across more scenarios, triggering more decisions rather than simply "saving" compute. This contrasts with the traditional large language model approach of optimizing for single-call quality: Jev's design philosophy trades extremely low single-call latency for the viability of high-frequency invocation, suited for scenarios requiring many simple judgments in rapid succession.

Driving Balatro with Jev: Architecture and Pitfalls

Prime already had a custom Balatro plugin (sidecar + Lua) capable of exporting the entire game state on screen via a "God View": deck, current hand, blinds, phase (splash / menu / selecting hand), and more. His idea was to feed these states into Jev and have it output the next action.

The whole setup process was filled with genuine vibe coding twists:

• Actions being executed repeatedly: The code had both options (menu and quit) JSON.stringify'd and sending click signals, causing what should have been a binary choice to execute both actions simultaneously. Prime repeatedly complained about AI-generated code — "Who would write it like this?"
• Click method pitfalls: Clicking by coordinates would accidentally trigger whatever element was under the cursor, so the approach was eventually changed to triggering interactions by button name (name click), already integrated with Lua.
• "reason: unavailable" confusing the model: Many clearly selectable actions in the God View were incorrectly labeled as unavailable, which misled Jev. Prime's fix was straightforward — simply remove the reason field and keep only the enabled flag, because "it'll confuse baby Jev."

State Trimming Is Critical

Feeding the entire game JSON directly to Jev worked fine for menu screens, but model performance degraded once inside a hand. Prime realized he needed to drastically trim the state: removing deck details, shop information, and discard records, keeping only the hand cards, current score, remaining plays and discards, joker cards, tarot cards, and the score needed to clear the blind. He also wrote a dedicated state function to generate a simplified view, plus a hand-type reference sheet (definitions and examples of two pair, four of a kind, etc.) and a brief Balatro strategy primer.

After trimming, input tokens dropped from over twenty thousand, and the model's judgment on menus and blind selection became accurate — it successfully chose "play" over "quit" and made reasonable moves when selecting blinds.

The Real Challenge: Getting the AI to Play Good Cards

Being able to click menus is one thing; playing strong hands to beat blinds is another. This is the core bottleneck exposed by this test.

Jev frequently made poor choices during hands — for example, having a full house available but selecting a King instead, or continuously sorting by suit without ever playing a hand. Prime's assessment:

"Jev is at the end of the day a classification engine, a classifier that works really, really well."

The problem is that single-pass classification struggles with complex decisions requiring multi-step planning. His proposed solution is to build a decision tree / behavior tree, layering the decision-making:

1. High-level decision: do you want to play a hand, discard, or do something else?
2. If playing a hand, enter a sub-state: current hand, selected cards, hand type and its value, having it repeatedly select until satisfied;
3. After completing, return to the higher level to continue deciding.

By narrowing the option space for each decision, Jev's high-speed classification capability can shine rather than facing the full complexity of an entire hand at once. He summarized this approach as building a state machine / behavior tree where the AI makes only simple choices at each node.

An Unavoidable Limitation

Testing also revealed a game-mechanics-level obstacle: Jev cannot pre-calculate the score of a hand before playing it. Because Balatro's scoring is resolved by actually playing the cards (chips × mult stacked with joker effects and enhancements), there's no dry run interface available. This means the AI lacks a direct value feedback signal and can only rely on prior understanding of hand types to estimate.

---

Behavior Trees are a widely used decision architecture in game AI, first popularized in commercial AAA games (such as Halo 2) and later adopted by robotics and autonomous driving. The core idea is to decompose complex behaviors into a tree structure composed of "selector nodes," "sequence nodes," and "leaf nodes (concrete actions)," where each node returns only one of three states: success, failure, or running. Compared to finite state machines (FSMs), behavior trees are easier to scale and debug because new behaviors can be inserted as subtrees without rewriting the overall logic. The approach Prime describes here — first classifying high-level intent, then repeatedly executing card-selection actions in a sub-state — is a natural expression of the behavior tree "sequence + subtree" pattern. Embedding a high-speed classification engine like Jev into the leaf nodes of a behavior tree keeps the decision space for each AI call extremely small, playing to its strengths.

---

Observations on a New AI Paradigm

Beyond the technical details, Prime's attitude toward tools like Jev is worth noting. He candidly admitted he's grown weary of the recent wave of conventional large model releases — "slightly better, whatever." By contrast, the real-time decision-making direction that Jev represents rekindled his interest:

"Jev is the coolest LLM-adjacent thing we've come up with recently… it can make a decision for you in about 200 milliseconds, which is crazy."

Some viewers in chat raised whether this represents "the return of expert systems," while others pointed out this is essentially "drawing a decision tree and having the AI pick." These observations hit the mark: Jev's value isn't in replacing general-purpose reasoning, but in embedding AI into scenarios requiring low-latency, structured choices (game AI, real-time decision routing, etc.). Prime also mentioned that others have already used similar tools to have AI play Mario and Doom in real time.

It should be noted that this content comes from an exploratory livestream. The specific capability boundaries of Jev, its pricing (Prime mentioned there's an initial credit that gets used up quickly), and other details remain incomplete. The test stopped at a stage where "the AI can enter the game and make basic decisions, but is far from winning a round."

---

The expert systems mentioned in viewer chat were the dominant AI paradigm of the 1970s–80s, simulating domain expert judgment through manually coded "if-then" rule libraries. Notable examples include the medical diagnosis system MYCIN and the chemical structure analysis system DENDRAL. Expert systems' core weaknesses were the knowledge acquisition bottleneck (rules had to be written by hand) and brittleness (inputs outside the rules were difficult to handle). The fundamental difference between Jev and expert systems is that Jev's classification capability comes from knowledge implicitly encoded in model weights rather than explicit rules; but their usage patterns are indeed similar — both rapidly match the optimal action within a structured option space rather than freely generating output. This discussion reflects a broader trend: as the marginal value of generative AI diminishes at the margins, the industry is beginning to reexamine the unique value of the "narrow but fast" specialized inference approach.

---

Summary

This livestream was an honest technical exploration, not a polished product demo. It showcased an AI direction different from "bigger, better conversational models" — using ultra-fast classification decisions to drive real-time interactions. The real engineering challenge lies in how to decompose complex tasks into a series of simple choices the model excels at, and how to provide it with appropriate, trimmed, non-misleading state input. For developers looking to try this type of tool in game AI or real-time agent scenarios, the pitfalls Prime encountered — state trimming, action deduplication, misleading fields, and behavior tree layering — represent hard-won, practical experience.