wtf is jev?

What Jev actually is

A new model has been released, and the first thing to understand is that it does not chat. Jev comes from TypeSafe AI, a company led by Diogo Almeida, who helped invent reinforcement learning from human feedback (RLHF) and the research behind ChatGPT while at OpenAI. TypeSafe frames Jev as its first "System One Model," a name borrowed from Daniel Kahneman's book Thinking, Fast and Slow. System 1 is the fast, automatic, immediate part of thinking; System 2 is the slow, effortful, deliberate part. Traditional LLMs like Claude, ChatGPT, or Gemini are System 2: they can reason for a while, and they are slower. Jev is System 1: it answers instantly and does one narrow thing.

The performance claim is the reason to care. The speaker gives it as roughly 20 to 200 times faster and 40 to 400 times cheaper than a traditional LLM. TypeSafe's own launch numbers are more specific: 193.6 times faster than Claude Sonnet 5, 444.6 times cheaper than Claude Opus 5, with end-to-end responses between 70 and 500 milliseconds and pricing of $0.042 per million input tokens with output free. The speed comes from the architecture: instead of generating an answer one token at a time, a parallel sampler produces all of the requested answers in a single pass.

How Jev works: state, questions, probabilities

You give Jev two things. The first is your data, which TypeSafe calls the "state": a customer email, a chunk of code, a page of text, whatever you want a decision about. The second is your questions: the specific things you want to know, each with a fixed set of options. Jev returns a probability for each option. Your code then branches on those probabilities and performs an action. Jev never takes the action itself.

There are three question types. A Noul is a yes/no question answered as a probability. A Choice picks one option from a set (up to 255 of them). A Score rates something on an ordered scale of 2 to 10 levels. So you could ask a customer email "is this a refund request?" (Noul), "which team should handle it?" (Choice), and "how frustrated is the customer?" (Score) in the same call. Writing this looks exactly like talking to any AI SDK.

The client reads a TYPESAFE_API_KEY from the environment and defaults to the jev-latest model. Every answer is typed and predictable, so there is no prompt to tweak and no output to parse.

Why this is different from an LLM agent

Today, if you build an agent, you tend to write one giant prompt. You feed it the user's message and a pile of questions all at once, what is the intent, is it safe, does it need a human, what tool should I call, do we even support this, and then tell the model to write and send a reply. That prompt is fragile. Anyone who has run an agent in production knows the endless wording tweaks and the high error rate, even with structured output, which is why so much of that code sits inside a try/catch for when the model's answer gets cut off or hallucinates a field.

Jev inverts it. It sits first in line. One fast call classifies the incoming message, and then your own code branches on the answer. Ask for order status? Do the lookup, no LLM required. Ask a real product question? Now call an LLM. Angry or unclear? Route to a human. Trying to jailbreak you? Block it immediately.

What people have built with it

The rest of the video is demos. The common thread: something that used to need an LLM per item now runs on Jev, cheaper and far faster.

Browser automation is the first. Hooking Jev up to snapshots of a web page lets it decide what to fill in next, fast enough to book a flight end to end in about seven seconds.

Five more demos share the same shape and go by fast. The creator of Hiring Café used Jev to score whether a given resume is a good fit for a job posting, about 10x cheaper than the smaller LLMs he compared against. One developer pointed it at his personal inbox to classify each email's priority, whether it is spam, and whether it deserves a reply, live, as fast as the messages scroll past. Another built an X browser extension that hides posts it judges to be rage bait, crypto, or political, effectively re-tuning your feed in real time. People have also coded the rules of Tetris into Jev so it decides each move as an API call, and wired it into a self-driving simulator that reacts to stop signs, traffic, and pedestrians. Every one is the same move: replace a slow per-item LLM call with a fast per-item Jev classification, in cases where the decision has to come back fast enough to matter.

Inside Syntax and Sentry

The presenter then shows two production uses from his own work. The Syntax podcast generates an episode summary with a big LLM prompt full of hand-written spelling rules (for example, forcing the correct spelling of "Sentry," the sponsor, which transcription keeps mangling). That pile of rules is a perfect fit for Jev, and Jev can also verify the LLM's output: after the notes are written, run every extracted claim through Jev to check that it is true and nothing was hallucinated.

The second is a model router. Sentry's Slackbot, "Junior," answers questions, opens GitHub issues, writes code, and pulls from Linear and Notion, and it has to pick which model to respond with. Today that is a big prompt describing which requests go to which models. It becomes two Jev questions: how much reasoning is required, and which profile does this fit, where each profile maps to a specific model. Classify first, then route to the LLM.

The chatbot with no LLM

The presenter's own demo is a chatbot that never calls an LLM at all. It uses only tool calls, built from TypeSafe's smart-home starter. You type plain language, and Jev works out what you are asking, which registered tool answers it, and what arguments to pass, all in one request. Because Jev returns everything in a single response (which tool, which arguments, the extracted values), there is no multi-step prompting, and it comes back in a couple hundred milliseconds.

The trick is that the existing MCP tools are used unmodified. Jev just chooses which one to call and fills in the arguments, and the whole decision comes back in one response.

Jev is available through a waitlist (the presenter got in within a day), and it is also reachable right now through the Vercel AI Gateway, which may cost slightly more but works on an existing plan with no waiting.

Tools and resources

Claims to verify

• The speaker's "20-200x faster, 40-400x cheaper" is a rounded range. TypeSafe's launch cites the sharper 193.6x faster than Claude Sonnet 5 and 444.6x cheaper than Claude Opus 5, at 70-500ms end to end and $0.042 per million input tokens with free output. Both are the vendor's own figures, not an independent benchmark.
• "Jev never hallucinates" is a framing, not a proof. Because it returns a probability over options you fixed, it cannot invent a field, but a confident wrong classification is still possible; the demos show confidence scores precisely because calibration, not certainty, is the point.
• The demo cost/latency numbers ($0.0039 for a flight, $0.08 for 1,018 papers, $0.0497 for the debate, 200-325ms in the chatbot) are each author-reported screenshots at recording time, not reproduced here.
• Hamed Nilforoshan's accuracy benchmark (Jev at Spearman 0.79 for $0.02) is one human-labeled test posted by a third party; treat it as a data point, not a settled comparison.
• Access is a waitlist plus the Vercel AI Gateway as of the video (2026-09-17). Waitlist speed and gateway pricing will change.
• Auto-caption corrections applied silently and logged in g1-adjudications.json: the model is Jev (not "Jeb"), the company TypeSafe AI, the founder Diogo Almeida (not "Dio Almata"), the author Daniel Kahneman, the yes/no type Noul (confirmed on-screen), and "Vercel"/"RLHF"/"Playwright"/"Mount Rainier" corrected from garbled captions.

Glossary

• Jev: TypeSafe AI's fast, cheap classifier model that returns a probability per option instead of generating text.
• classifier: a model that sorts an input into predefined categories (or scores it), rather than producing free-form output.
• LLM (large language model): a model like Claude, ChatGPT, or Gemini that generates text token by token and can reason at length; slower and costlier than a classifier.
• System One / System Two: from Kahneman's Thinking, Fast and Slow; System 1 is fast/automatic thinking (Jev), System 2 is slow/deliberate thinking (an LLM).
• state: the input data you hand Jev to make a decision about (an email, code, a page of text).
• Noul: Jev's yes/no question type, answered as a probability between 0 and 1.
• Choice: Jev's "pick one option" question type, supporting up to 255 options, returning the pick plus a confidence.
• Score: Jev's "rate on an ordered scale" question type, 2 to 10 levels, which can land between levels.
• confidence: how concentrated Jev's probability mass is on its top answer; high confidence means the options were well separated.
• parallel sampler: the architecture that lets Jev produce all requested answers in one pass instead of one token at a time, which is why it is fast.
• RLCD (Reinforcement Learning for Calibrated Decisions): TypeSafe's training method aimed at probabilities that are well-calibrated, not just high-scoring.
• structured output: an LLM feature that asks for JSON matching a schema; reliable enough to use but prone to cut-off or hallucinated fields, which Jev's fixed options avoid.
• deterministic code: ordinary program logic that behaves the same every time; the pattern is Jev makes the judgment and deterministic code takes the action.
• decision engine: a system that classifies an input and branches on the result, which is the role Jev is built to play.
• model router: code that picks which model handles a request; Sentry's "Junior" uses Jev to route before calling an LLM.
• MCP (Model Context Protocol): an interface that lets an agent call an external tool or service; Jev reuses existing MCP tools by choosing which to call and filling arguments.
• Home Assistant: an open-source home-automation platform; the no-LLM chatbot controls lights through its MCP tools.
• Vercel AI Gateway: a Vercel service that proxies model calls; an alternate, no-waitlist way to reach Jev.
• RLHF (reinforcement learning from human feedback): the training technique behind ChatGPT that Diogo Almeida helped invent.