From Claude Code Mods to Super Mario: What People Are Building on Jev

We’ve arrived at yet another time when developers go gung-ho for a new framework built atop the transformer model. 

But this time, the idea comes from someone who helped build the technology that made modern LLMs possible. 

TypeSafe AI’s Jev, created by OpenAI veteran Diogo Almeida, takes a fundamentally different approach to AI: it doesn’t generate language.

Instead, Jev is designed to make fast, structured decisions that software can act on directly. Rather than returning long strings of text, it produces typed outputs with probabilities and confidence scores.

Almeida was a co-author of the research behind InstructGPT and RLHF, the instruction-following approach that helped turn GPT models into useful chatbots.

TypeSafe says Jev delivers comparable intelligence to frontier LLMs on structured decision-making tasks while running 40–200× faster and at substantially lower cost.

And developers have already found plenty of ways to put Jev to work, from speeding up AI agents to playing Super Mario.  

Using Jev for Fast, Structured Decisions

Cloudflare has integrated Jev into its AI platform as a model for making fast, structured decisions around AI applications. 

Jev is available through Cloudflare’s AI infrastructure alongside its model catalogue, giving developers access to a decision-oriented model rather than using a conventional LLM for every classification or routing task. 

This fits Cloudflare’s architecture for agents, where models can be used to route requests, select tools and make other decisions that sit directly on the critical path of an application. 

Cloudflare has previously described these routing decisions as a key requirement for agents, because latency can compound when an agent makes multiple model calls during a single task.

Replacing Claude Code’s Compaction Summaries

App developer Tamara Tran’s fast-jev-compaction is a Claude Code plugin and npm library that uses Jev to compact long coding-agent conversations without generating a traditional summary. 

Instead of asking an LLM to rewrite older context, it sends the conversation state to Jev, which scores individual tool calls and their results based on whether they are still needed. 

Unnecessary calls and results are removed, while useful ones are retained verbatim. Results that are less important can also be truncated while preserving the associated tool call. 

User and assistant messages are otherwise kept in their original form and order. The system is designed for coding sessions where losing exact file paths, commands, errors or constraints during summarisation can affect subsequent work. 

Using Jev to Evaluate AI Agents

LangChain researchers used Jev as an evaluator for AI agents, testing whether its decision-focused architecture could provide a faster and more consistent alternative to LLM-as-a-judge systems. 

They evaluated a weather agent across five fixed tasks, repeatedly scoring the same runs with Jev, GPT-5.6 Luna, GPT-5.6 Terra, and Claude Sonnet 4.6, using human reviewers as the reference. 

Jev matched the human pass/fail judgments in all 500 repeated decisions and showed substantially lower score variance than the other models. 

Its average variance was 92–913 times lower, while the researchers measured an average latency of 0.44 seconds and a cost of $0.00035 per evaluation. 

The experiment suggests Jev could make continuous and online agent evaluation more practical by allowing developers to score more production traces and run more frequent regression checks at lower cost. 

However, the authors note that the experiment was narrow and that consistency alone does not guarantee correctness.

Making Browser Agents Faster

Browser Use’s Jev Ultrafast is a browser agent that uses Jev to make fast, structured decisions about what to do on a webpage. 

Instead of relying on screenshots and a large language model to generate every browser action, it converts the current page into an indexed table of visible elements and has Jev select both an operation and its target in a single request. 

Supported actions include clicking, typing, selecting, scrolling, waiting and finishing a task. 

A smaller LLM is used only when the agent needs to generate text, such as a city name for a search field. 

The approach reduces browser round trips and avoids sending screenshots through the main decision loop. 

For example, in a Google Flights demonstration, the agent completed a Zurich-to-London search in 7.1 seconds. In six alternating test runs, the Jev-based version reduced median task time from 9.45 seconds to 7.09 seconds and browser protocol calls from 1,092 to 101. 

Reviewing Coding-Agent Commands For Safety

Vercel is using Jev as a safety reviewer for fx, its coding agent. In fx’s auto mode, every command proposed by the agent is checked before execution to determine whether it is safe to run. 

The existing reviewer uses GPT-5.6 Luna; Vercel says its internal benchmark found Jev to be roughly 5–18× faster at p95 while also producing more accurate safety classifications.

In this use case, the command approval is a bounded decision rather than a text-generation task. The system needs to classify a proposed action and return a decision quickly. 

Vercel has since made Jev available through AI Gateway, where it can also be used for guardrails, routing and other typed decisions.

Organising Thousands of Research Papers

Elvis Saravia, Co-Founder of DAIR.AI, used Jev to reorganise the tags for roughly 2,300 AI research papers in the DAIR.AI Academy’s paper collection. 

The papers had previously been classified using DeepSeek V4 Flash, but Saravia was not confident enough in those labels to use them without further validation. 

Instead of building and tuning a more expensive few-shot LLM classifier, he ran the collection through Jev. 

Jev agreed with about 75% of the existing classifications and identified roughly 579 high-confidence topic changes. 

Savaria manually reviewed 30 of the disagreements and accepted all of them, after which the changes were applied to the production collection. 

The full run reportedly cost $0.14 and took about 83 seconds. The project demonstrates a hybrid approach in which a conventional generative model handles broader processing while Jev performs fast, structured classification at scale. 

The resulting tags are used to improve how researchers discover and navigate the paper collection.

Finding the Right Command For an Agent

Niaz Morshed’s Jev Capability Resolver (JCR) uses Jev as a routing layer for AI-agent capabilities. 

Instead of making an agent read multiple skill files and API references to find the command it needs, JCR stores documented operations in a hierarchical tree of providers, resources and individual commands. 

Jev progressively searches this tree, selecting the most relevant branch at each level and returning only the documentation attached to the final operation. 

Compound requests can be split into individual tasks and searched in parallel. The approach is designed to keep large capability catalogues out of the agent’s context while still letting the agent access deterministic commands from different providers. 

In Morshed’s benchmark of 20 scenarios across Claude and Codex, JCR reduced average agent context by 85% with Opus 5 and 23% with GPT-5.6-Sol, while lowering total costs by 67% and 16%, respectively. 

Selecting Which Claude Code Skill to Load

Developer Daniel San built a Claude Code mod that uses Jev to decide which skill is relevant to each user request. 

Normally, Claude Code can expose a list of available skills to the model, adding context even when most of those skills are irrelevant to the task. The mod hides that listing and sends the available skill names and descriptions to Jev instead. 

Jev first determines whether the request actually requires a skill, then ranks the available skills and performs a second check on the most relevant candidates. 

Only the selected skill’s SKILL.md is injected into Claude’s context; the others remain available but are not loaded. 

The mod can use either TypeSafe’s API or Vercel AI Gateway. 

The implementation is designed to reduce context bloat as users accumulate larger skill libraries, while leaving the main Claude model focused on executing the task rather than deciding which instructions to load.

Controlling Super Mario Bros

TypeSafe Mario, built by Faadil Shaik, is an experimental game-playing agent that uses Jev to control the original Super Mario Bros. 

Instead of giving Jev screenshots, the project reads emulator telemetry and RAM and converts them into structured JSON describing Mario’s position, velocity, jump trajectory, nearby enemies, terrain, reaction timing and recent actions. 

Jev then chooses from a small set of legal controller actions, such as moving right, running, jumping or doing nothing, with the emulator advancing several frames before the next decision. 

Each request also produces a Noul judgement on whether a forward jump is useful and a Score measuring immediate danger. 

The system keeps precise timing calculations in code while leaving the higher-level decisions to Jev. 

This creates a real-time control loop of emulator state, to structured data to Jev decision and controller input. 

The project demonstrates how decision models can control interactive environments without requiring a vision pipeline or generating natural-language instructions.

22 AIs Playing One Football Match

JevBall is a 3D football match where all 22 players are independently controlled by Jev. 

The simulation first calculates each player’s realistic options locally, such as passing, shooting, dribbling, pressing or marking. 

It then attaches information including distance, lane clearance, receiver space, estimated success, xG (expected goals) and offside margin. 

Jev then chooses among up to 14 typed options for each player and returns a probability for every option. 

Players make decisions at different frequencies depending on the game state: the ball carrier every 0.30 seconds, players within 15 metres of the ball every 0.55 seconds and others every 1.2 seconds. 

Decisions due at the same time are batched into a single API request. Physics, first touches, goalkeeper saves, and other reflex actions remain in code, while Jev handles the higher-level choices. 

A live tactics board shows the alternatives and their probabilities, and a human can take control of one player while the other 21 remain under Jev’s control. 

In one short test, the creator measured 366 ms average latency and about $0.01 per match-minute.

Jev Flies a Drone Through a City

Jev Autopilot is a 3D drone simulator built with Three.js where Jev autonomously flies from launch pad A to landing pad B through a randomly generated city. 

Instead of screenshots, Jev receives a compact situation report generated from simulator data, including altitude, speed, bearing, nearby obstacles and the tallest building along its route. 

In a single request, Jev makes six decisions: throttle, yaw, pitch and roll, plus whether to commit to landing and cut the motors. 

The simulator converts Jev’s probability outputs into stick movements, while code handles flight calculations and basic safety limits. 

Each refresh generates a new city, allowing the system to repeatedly navigate different environments. 

The developer says Jev responds in about 200 milliseconds, making it a demonstration of using a decision model as a real-time controller rather than a text-generating agent.