Jev, the silent AI model taking over feeds worldwide: how does it actually work?

New models keep pouring out, each eager to prove to the world that it can write and chat. Yet the hottest name flooding feeds right now is Jev.

It does not talk.

Diogo Almeida is a researcher at OpenAI. He worked on ChatGPT and later helped introduce reinforcement learning from human feedback (RLHF).

That approach, in many ways, defined the path of large language models over the past few years. But even as the method pushed the industry into a boom, Almeida grew increasingly skeptical of it.

“We had a one-time innovation success, but we didn’t turn it into something truly useful.”

It took him a long time to see where the problem was: we kept optimizing for human language. Over four years, systems became extremely good at handling human language—but that did not help much with automation, because computers speak a different “language.”

Two years ago, Almeida left OpenAI and co-founded TypeSafe AI with Erik Gafni and Sasha Sheng. The company stayed under the radar until September 15, when it finally came out of stealth with two announcements: a $40 million seed round led by DCVC, and its first model, Jev.

Jev is still a Transformer-based model, but it is deliberately not a large language model and does not output a full sentence.

You give it a program state and a predefined question. It returns a typed answer: a choice, a score, or a probability between 0 and 1, plus a confidence score.

TypeSafe calls this output a “calibrated decision.” That is also why many people felt confused the first time they saw the name Jev in public.

The screenshot compares how Jev and a large language model respond to the same request.

The hottest model in AI is not on ChatGPT’s path

To understand what Jev is doing, set aside LLM habits for a moment.

A customer-support scenario makes it clearer. A user messages: the payment service has been down for days and business is already hurt. Several judgments are needed: should this go to tech or billing, how upset is the customer, and is it urgent?

Under TypeSafe’s interface design, questions in the same request share one input but are evaluated independently and in parallel. Classification and urgency can be handled together.

Concretely, outputs come in three basic forms. The first is Choice: pick one item from a list you define, with up to 255 options—useful for routing and classification. The second is Score: place the input on a scale you define to measure urgency, quality, or risk. The third is Noul: essentially a yes/no judgment, returning a number for the probability that something is true.

Every answer comes with a full probability distribution and confidence score. Results are strongly typed: no JSON prompting, no extra parsers, and no worry that the model will suddenly wrap the answer in a Markdown code block.

The most immediate benefits are time and cost savings, plus fewer format errors from free-form generation.

TypeSafe’s published numbers put Jev’s end-to-end latency between 70 and 500 milliseconds—20 to 200 times faster than comparable large language models.

At current public pricing, input costs $42 per billion tokens, or $0.042 per million tokens in the more common unit; output is free. New questions and option descriptions still consume input tokens, but you are no longer charged again by the length of generated answers.

Because users define the output space in advance, the model does not “hallucinate” outside it. (When people say Jev does not hallucinate, they mean it will not invent answers beyond the preset options—though it can still pick the wrong option inside that set.)

In a public Ably Pong demo, Jev made 47 control decisions in 12 seconds, while Gemini, Claude, and GPT made only two or three in the same window—even though the latter were still correct in most cases.

In that demo, the program fed Jev game numbers directly: ball position, direction of motion, paddle position, and the expected y-coordinate when the ball would reach the paddle line. From those numbers, Jev chose among “up,” “down,” and “stay.”

How to use Jev

To turn Jev into a playable product, you still need game logic and realtime communication. In the project above, the backend advances the game, calls the model, and pushes new state to the browser through Ably. In other words, game rules, visuals, and networking are not generated by Jev—it is only inserted into the repeated three-way decision step.

Speed expands the application surface. Jev can act as a judgment layer for computer use, guiding agents to execute instructions quickly. It can also compress context by deciding which content is critical, rapidly narrowing million-token histories.

Browser Use’s public project jev-ultrafast implements a browser agent. On each page, it first reads actionable elements into a numbered list: which items are buttons or inputs, what they are called, and what is currently filled in.

Jev receives that structured state, the user goal, and action history. The choice space is dynamically generated from elements that actually exist on the page.

Using Jev as an action judgment layer to guide fast computer control: https://x.com/gregpr07/status/2100411066966749359

Take flight search as an example. The goal might be: “Find one-way flights from Zurich to London on a given date, passenger count, and cabin class; stop when matching results appear.”

Each round, the program asks several questions at once: should the next step be click, type, select a dropdown, or wait? If click, which number? If type, which field? They share the same page state but are answered separately.

The program then keeps only the target that matches the chosen action: if it selected click, it uses the click target and temporarily ignores the rest.

When a city name must be typed, the program separately calls a small text-generation model to fill the field based on the goal and current input. After the browser executes the action, it reads the new page state.

Using Jev to judge which context matters enables near-instant context compression: https://x.com/tamarajtran/status/2100694549362553153

Vercel software engineer Pranit Sharma said his company used OpenAI’s ChatGPT Luna 5.6 as a classifier to check command safety. After replacing Luna with Jev, processing became 5 to 18 times faster and accuracy improved substantially.

Another developer, Bryo AI CTO Nikhil Mudholkar, also tested Jev against Gemini for classifying business email. In his tests, Gemini was slightly more accurate, but 10 to 20 times more expensive.

You can build something similar yourself: prepare a table where each row includes subject, body, receive time, and needed context.

Then split the business into clear questions. For an email that says “I was charged twice for an order and want this handled today,” Choice can decide whether it should go to support, sales, partnership, or another queue; Noul can ask whether the sender clearly requests action; Score can rate priority.

“Ultimately, this approach shifts a bit of the hallucination problem onto the user,” explained Earendil CTO Armin Ronacher. “The user has to decide: if the probability is only 50%, maybe ignore it. If it reaches 95%, I can act on it.”

Ronacher also sees model routing as another potential use. Predicting whether a task needs a specific model is valuable, but doing that with a large language model is expensive. Jev is cheap and fast enough for realtime routing.

Automatically assigning the right model by task complexity: https://x.com/mdlahfir/status/2100314182201802811

The wisest decision

The name Jev comes from 19th-century economist William Stanley Jevons. Jevons’ paradox says that when the cost of a good falls, consumption of that good rises. In this framing, cheaper intelligence should lead to far wider use of intelligence.

In other words, once inference becomes cheap, it will be used in many places that previously were not worth calling a model. Almeida clearly likes the analogy. He imagines a future not dominated by a few giant apps, but filled with many tiny intelligent judgments running everywhere—“more like the early internet than the large applications people are trying to build today.”

TypeSafe has not disclosed Jev’s exact architecture. Outside observers generally guess it is adapted from an open-source large language model.

The company calls them System One Models, borrowing Kahneman’s idea of intuitive thinking: judgment without a long reasoning chain, specially tuned for concrete tasks.

Official guidance is to break complex judgments into several clear questions and combine them in code, rather than asking one model to do everything at once.

Almeida revealed that he foresaw early on that he would end up working with synthetic data—and that may have been the wisest decision of his life, wiser than taking a company public, and wiser even than relying on real human feedback.

For now, TypeSafe is the only company publicly taking this route, but Ronacher expects followers to appear as the pattern proves useful. TypeSafe itself plans more model versions for different scenarios.

Asked whether the company counts as a frontier lab, Almeida said: “The main products of frontier labs are either fear or hype. I hope our main product is wisdom. We are not the kind of lab obsessed with creating infinite wealth, building religious narratives, or trying to summon a god inside a data center.”

After launch, demand briefly exceeded expectations and the API struggled to respond. Some people used it to filter niche feeds: read related posts from the past three days, ask eight questions, finish in about two seconds for $0.007 per run, and remove bait content and hidden ads.

Other teams plugged it into full marketing analytics pipelines—scanning Meta’s ad library, comparing how long different ad formats survive, and evaluating creative scripts before shooting—speeding up formerly manual judgments by 30x and keeping cost under $3.

AI said much less. Software got more done.