Modern Creator

The Jev Playbook · Updated September 20, 2026

Jev cannot write a word. That is the whole point.

TypeSafe AI shipped a model that only ever does one thing: picks an answer off a list you wrote, and tells you how confident it is. No paragraphs, no reasoning, no parsing. About 200 milliseconds and a fraction of a cent. Here is what the creators found when they put it to work, across 18 breakdowns.

TypeSafe AIDecision modelChoice · Score · NullAgent routing18 breakdowns and counting
Read the 60-second version ↓Browse the full library
~200ms
per decision, whatever the schema’s complexity
$0.042 / M
input tokens. Output is free, there is no output
18¢
1,700 emails sorted, scored and spam-checked
39 / 40
head-to-head accuracy, tied with the frontier models
64K
context window. About 6% of a frontier model’s
18
breakdowns synthesized for this page

The 60-second version

  • →Jev is an AI model that cannot write a sentence. You give it an input and a list of allowed answers, and it gives back a probability for each one. That limitation is the entire product.
  • →Every request is one of three shapes: choice, score, or null (a yes/no expressed as a probability). One call can answer several questions about the same input at once.
  • →Because there are no output tokens, there is no output cost. Input runs about $0.042 per million tokens, and a decision lands in roughly 200 to 400 milliseconds instead of 10 to 30 seconds.
  • →The move everyone landed on is the same: put Jev in front of the expensive model. It triages the queue, routes the request, or answers the lookup, and the frontier model only sees what actually needs thinking.
  • →The limits are real and creators said so out loud: no reasoning, no explanation, a 64K context window, and a live trading test where a frontier model beat it outright. This is a traffic cop, not a strategist.

How it actually works

Three shapes. That is the entire API.

You hand Jev an input and a schema of allowed answers. It hands back a probability for each one, in parallel, with no reasoning in between. Every request you will ever make is one of these three.

Choice

Pick exactly one option from a list you define in advance.

Sort this email into Sales, Support, Personal, or Spam.
Score

Place the input on a numeric scale you define in advance.

Rate how frustrated this support ticket sounds, 1 to 5.
Null

Answer yes or no, returned as a calibrated probability.

Is this a scam? 91% confident yes.
One call, many questions. The same request can return a category, a 1 to 5 score, and an urgency probability about the same input. You skip training a separate classifier per decision type.
No autoregressive loop. A chat model writes one token at a time and can go wrong on the first one. Jev evaluates every typed question against the state at once.
Trained on calibration, not confidence. RLCD rewards probability estimates that match reality, so an 80% call is supposed to land about 80% of the time.

Worth knowing before you search: one breakdown in this set transcribes the lab as “TypeSpace.” The rest say TypeSafe AI. The company name nods to Daniel Kahneman’s System 1, the fast intuitive half of thinking, which is exactly the job it wants Jev to do next to a slower model. ↗ Rob Shocks ↗ Riley Brown

People are asking

The questions everyone’s Googling.

Straight answers, pulled from across all 18 breakdowns.

What is Jev?

Jev is an AI model from TypeSafe AI that never writes a word. You hand it an input and a schema of allowed answers, and it hands back a probability for each option. That is the whole product. It cannot chat, cannot explain itself, and cannot write code. Creators call it a decision model or a classifier rather than a language model.

How is Jev different from ChatGPT or Claude?

A chat model generates an answer one token at a time and streams you text you then have to parse. Jev evaluates every option in parallel and returns typed numbers and categories you can drop straight into code. No reasoning trace, no JSON wrapper, no parsing step. The practical difference creators kept measuring: roughly 200 to 400 milliseconds per decision instead of 10 to 30 seconds.

How fast and how cheap is Jev really?

TypeSafe claims 20x to 200x faster and 40x to 400x cheaper than a comparable LLM call, around 0.4 seconds and $0.0004 per decision. Independent creator tests land in that neighborhood: 185ms on a smart-home command, about 200ms per email across 1,700 emails, and 413ms on a 40-question outfit benchmark where Claude Haiku took 1,486ms and GPT-6 Astra took 3,269ms. Pricing is asymmetric: output is free because there is no output, and input runs about $0.042 per million tokens.

Who makes Jev?

TypeSafe AI, a lab founded by one of the co-inventors of ChatGPT. Its name nods to Daniel Kahneman’s System 1, the fast intuitive half of human thinking, which is exactly the role the company wants Jev to play next to a slower reasoning model. One early breakdown transcribed the company as "TypeSpace"; the rest of the corpus says TypeSafe.

What are Jev’s three output types?

Choice, score, and null. Choice picks one option from a list you define. Score rates the input on a scale you define, say 1 to 5. Null is a yes/no answered as a probability, like 91% confident yes. Every Jev request is one of those three shapes, and one API call can answer several of them about the same input at once.

What can Jev actually do?

Anything that is really a fast judgment call on structured input. Creators demoed inbox triage (category, priority, spam likelihood, reply likelihood), lead scoring from a contact form, routing a coding agent to the right model tier, picking the best clips in a long video, driving a browser agent through a booking flow, real-time smart-home command routing, a self-driving simulation, and a crypto bot choosing buy, sell, or hold every few hundred milliseconds.

What should you not use Jev for?

Anything that needs reasoning, writing, or a high-stakes judgment call. In a live buy/hold/sell Bitcoin test, Jev underperformed a frontier reasoning model that could cross-reference the news. It also cannot explain why it decided something, and its 64,000-token context window is roughly 6% of a frontier chat model’s, so it cannot weigh much reference material per decision.

Is Jev calibrated, or just confident?

TypeSafe trained it with RLCD, reinforcement learning for calibrated decisions, which rewards probability estimates that match real-world frequency instead of rewarding answers that sound sure. The claim is that an 80% call actually happens about 80% of the time. That matters, because a confidence number you can trust is what lets you auto-accept high-confidence picks and escalate the rest.

How do I get access to Jev?

TypeSafe runs a waitlist for direct API access. You do not have to wait: the Vercel AI Gateway serves Jev today with an API key, and OpenRouter lists it too. Creators testing the model in launch week all routed around the waitlist that way.

How do you add Jev to Claude Code?

Through the UserPromptSubmit hook, which intercepts a message before the LLM ever sees it. Every prompt hits Jev first; if Jev can resolve it with a direct tool call, it answers instantly and no LLM tokens are spent, and anything it cannot handle falls through to Claude as normal. Setup is a TypeSafe API key plus TypeSafe’s agent setup prompt and skill file, pasted into a fresh session and wired by the agent itself.

Jev vs a chat model, dimensionalized

Faster and cheaper, at exactly one job.

Not vibes. Here is what happened in the tests creators actually ran.

40 identical decisions, four models

JEV413ms per answer, 39 of 40 correct, and zero frontier tokens spent.
THE FIELDClaude Haiku 1,486ms. GPT-6 Astra 3,269ms. Claude Sonnet 5 4,645ms. Same 39 of 40 score, and 74,923 tokens burned to get there.
↗ Julian Goldie

The same inbox, priced

JEV1,700 real emails categorized, prioritized, spam-scored and reply-scored for 18 cents total.
A CHAT MODELThat run moved 4.2M input tokens. A generative model reading and writing the same volume is the part that costs real money.
↗ Greg Isenberg

One fraud question

JEVFull probability breakdown in about 100 milliseconds, generated in parallel.
AN LLMAbout 8.5 seconds of token-by-token generation, and the answer degrades if the first tokens head the wrong way.
↗ David Ondrej

Vercel’s production swap

JEVReplaced a cheap classifier model in a live workload: 6x faster, and it saturated their eval.
THE OLD ONEThe classifier it replaced was already the cheap option, not a frontier model.
↗ Rob Shocks

Reach for JEV when…

  • The answer is one of a small, fixed set you can write down in advance
  • You are running the same judgment call across hundreds or thousands of rows
  • Latency is part of the experience: a button click, a keystroke, a driving decision
  • You want a confidence number you can threshold on, not a paragraph
  • The decision sits in front of something expensive and only some of it needs the expensive thing
  • You would otherwise be writing a brittle pile of if/else rules

Reach for something else when…

  • The output is writing: code, copy, an email, a plan
  • You need to see the reasoning, or defend the decision to a human
  • The call is high-stakes and worth the extra seconds (the Bitcoin test is the cautionary tale)
  • The decision needs a lot of reference material: 64K context is the ceiling
  • The question is genuinely open-ended and the option list cannot be written down

⚠️ The headline 0% hallucination and 0% tool-error figures come from TypeSafe’s own benchmark charts, not an independent test. The one independent head-to-head in this corpus had Jev tying Claude Haiku, Claude Sonnet 5 and GPT-6 Astra at 39 of 40, while spending zero of their tokens. Speed and price are the proven win. Accuracy is a tie, not a leap. ↗ David Ondrej ↗ Julian Goldie

What the demos proved

Launch week, in numbers.

Every one of these was run live on camera. Tap any to watch the source.

1,700 emails
sorted, scored and spam-checked for 18 cents
7.1 seconds
for a browser agent to book Zurich to London
17 clips
scored out of a long video in about three seconds
55 of 500
emails flagged as likely scams in one extra pass
1.7 seconds
to find a path through six degrees of Wikipedia
185ms
to classify and route a spoken smart-home command
~$7
to play Doom in real time for an hour
60 emails
triaged in 25 seconds into reply, research, wait, or flag

Use-case playbooks

Here’s exactly what they built, and how.

The real methods creators demoed, with the actual tools and the video to watch.

The AI traffic cop: put Jev at the front of the queue

↗ Greg Isenberg & Ryan Vogel
EmailContact formsSupport ticketsLead intake
A.Find the expensive incoming queue. Emails, leads, support tickets, quote requests. Anything where a human currently reads everything to find the few that matter.
B.Ask Jev three questions per item. What is it, how important is it, and what should happen next. One call, three answers, about 200ms.
C.Route by confidence, not by category. High confidence goes to a human now. Middle confidence gets automated or drafted by an LLM. Low confidence gets ignored.
D.Start with $5. A starter credit covered two days of heavy team testing, and $10 could plausibly last three months. The cost of finding out is close to zero.

Stop paying a frontier model to sort your mail

↗ Julian Goldie
Claude CodeGPT-6 AstraAgent pipelines
A.Understand where the money goes. Every new message makes an agent re-read the whole conversation. One real follow-up, "do you have the guide on this as well?", cost 186,000 tokens. A bare "how’s it going" cost 222,000.
B.Spot the quiz questions. Inside one sentence like "I’m giving a keynote tomorrow" there are seven separate closed-list decisions: jacket, shirt, trousers, shoes, extras, room setup. None of them need a frontier model.
C.Write the question and the allowed answers. If you can enumerate the options, it belongs to Jev. If you cannot, it stays with the big model.
D.Set a confidence threshold. Auto-accept anything above roughly 60%, flag the rest back to a human or escalate to the bigger model. The calibration is what makes the threshold meaningful.

Wire Jev into Claude Code so simple prompts never cost a token

↗ Kevin Badi
Claude CodeUserPromptSubmit hookTypeSafe API key
A.Use the UserPromptSubmit hook. It intercepts a message before the LLM sees it, which is the right place to split lookups from reasoning. A prompt instruction telling the model to "be efficient" is not.
B.Let the agent wire itself. Three inputs: a TypeSafe API key, their agent setup prompt, and their skill file. Paste all three into a fresh session and tell the agent to build the hook.
C.Color the cheap path. Jev’s answers come back in a different chat color, so you can see at a glance which replies cost nothing. Verify the savings, do not assume them.
D.Test it on a dataset that is not yours. He uploaded a random steak-eating survey mid-video and got a correct cross-tab back in half a second, which proves it generalizes before you trust it on real data.

Monitor everything, because now you can afford to

↗ Riley Brown
InboxDMsCommentsVercel AI Gateway
A.Run one classifier, many questions. The same pass that scores importance can score scam likelihood and brand-deal likelihood. 500 emails, three separate questions, seconds per pass.
B.Let it change what you read. Jev flagged 55 of 500 emails as likely scams. "Read your whole inbox" becomes "read the six flagged ones."
C.Word the question, not the prompt. The quality of a score or a probability depends on how precisely you define the scale and the yes/no anchors. That is the actual craft here.
D.Skip the waitlist. The Vercel AI Gateway serves Jev today with an API key. Existing infrastructure beats waiting on a new company’s queue.

Ship a product on it in one sitting

↗ David Ondrej
OpenRouterCoolifyA VPSAn agentic coding assistant
A.Pick a decision-heavy idea. Find software that is either pure if/else rules or uses an LLM in a limited way, then replace that piece with Jev. He built a Typeform competitor that ranks applicants live as they answer.
B.One VPS, not five subscriptions. A single box running Coolify hosted the frontend, the backend, and any agent workloads for the whole demo business.
C.Delegate the build. Describe the app in plain language, approve or reject the UI decisions, and let the coding agent write, test, and prep the deploy.
D.Expect manual checkpoints anyway. A rejected admin password had to be regenerated and the env vars updated before the redeploy worked. Agent-built is not hands-off.

Steal these

12 things to have Jev do for you today.

Real instructions from real demos. Copy, paste, tweak.

“Score every email in my inbox on four axes at once: category, priority, spam likelihood, and how likely I am to reply.”
via Greg IsenbergWatch →
“Score my inbound contact-form leads 0 to 1 so the 98% ones get a reply today and the vague ones wait.”
via Greg IsenbergWatch →
“Add one more question to the same classifier pass: does this email look like a scam?”
via Riley BrownWatch →
“Route each incoming request to the nano, balanced, or frontier model based on how hard the task looks, not on what the user asked for.”
via Riley BrownWatch →
“Transcribe this long video and score every moment for how clippable it is, then hand me the top 17.”
via Greg IsenbergWatch →
“Wire Jev into my Claude Code UserPromptSubmit hook so data-lookup prompts never reach the LLM.”
via Kevin BadiWatch →
“Go through my agent’s workflow and list every decision that is really a closed-list quiz question.”
via Julian GoldieWatch →
“Auto-accept any Jev pick above 60% confidence and flag everything below it back to me.”
via Julian GoldieWatch →
“Build me a Typeform-style application form that re-ranks the candidate into a qualification tier live as they answer.”
via David OndrejWatch →
“Build an adversarial QA bot that clicks through my site before every release trying to break it.”
via David OndrejWatch →
“Classify this spoken smart-home command and return the device action, no reasoning chain.”
via Rob ShocksWatch →
“Take this support ticket and give me three things at once: the category, how frustrated they sound 1 to 5, and whether it is urgent.”
via Rob ShocksWatch →

Getting access

The waitlist is optional.

Three doors, and every creator in this corpus used one of the side ones.

TypeSafe direct. The official route is a waitlist into a playground with API keys. Fine if you are not in a hurry.
Vercel AI Gateway. Serves Jev today with an API key, no waiting. This is what most of the launch-week demos ran on.
OpenRouter. Already lists Jev as an available model, which is how one creator routed around the waitlist mid-build.

Budget for testing: one team’s $5 starter credit covered two days of heavy use, and $10 could plausibly last three months. ↗ Greg Isenberg ↗ typesafe.ai ↗ Vercel AI Gateway

The map

Where the creators agreed, and where they split.

The honest part you only get by watching all of them. Tap any name to watch.

Routers

“Put it in front of the model you are already paying for.”

Julian GoldieKevin BadiRiley Brown

Traffic cops

“Put it in front of your inbound queue.”

Greg IsenbergRiley Brown

Builders

“The model is not the bottleneck any more. Ship something.”

David OndrejGreg Isenberg

Architecture explainers

“Understand why the constraint is the feature.”

Rob ShocksRiley BrownDavid Ondrej

✓ What nearly all of them agreed on

  • It genuinely cannot write. Every breakdown opens on the same reveal, and every one of them treats the limitation as the point rather than a flaw.
  • Choice, score, null. All six describe the same three primitives, in the same order, with the same examples.
  • It belongs in front of something expensive. A frontier model, a human, or a queue. Nobody pitched it as a replacement for any of those.
  • The cost is close to noise. 18 cents for 1,700 emails, $5 covering days of team testing, $7 for an hour of Doom. The recurring advice is to just go test it.
  • The speed changes what is buildable. Sub-second decisions make AI usable inside a click, a keystroke, or a driving frame, which a 10-second reply never was.
  • Skip the waitlist. Vercel AI Gateway and OpenRouter both serve it now, and every creator who tested it in launch week went that way.

✗ Where they split

  • How fast, exactly? The numbers range from 100ms to 413ms depending on who ran it and on what. Treat “about 200ms” as the honest middle and benchmark your own schema.
  • Whose benchmark? The 0% hallucination and 0% tool-error figures come from TypeSafe’s own charts. Julian Goldie’s independent 40-question run is the only head-to-head in the corpus where a creator controlled the test, and there Jev tied the frontier models rather than beating them.
  • Is a classifier really new? Rob Shocks and Riley Brown both address the obvious objection that LLMs already do structured output. Their answer is that generating text, formatting it as JSON, then parsing it back pays for three steps where Jev pays for one.
  • How far up the stack does it go? David Ondrej builds a whole product on it. Greg Isenberg’s own Bitcoin test says stop at routing, and he says so on camera.
  • Even the company name. One breakdown transcribes the lab as “TypeSpace,” the rest as “TypeSafe AI.” Worth knowing before you go searching.

The 6 moves that pay

1

Audit your agent for quiz questions

Before you wire anything, list every decision your pipeline already makes where the answer comes from a list you could write down. That list is your Jev surface area, and it is usually bigger than you think.

2

Put the cheap model in front, not behind

The single most-repeated move in the corpus. Jev triages, routes, or answers the lookup. The frontier model only wakes up for what actually needs thinking.

3

Threshold on confidence

A calibrated probability is only useful if you act on it. Pick a number, auto-accept above it, escalate below it. That one rule turns a classifier into an actual system.

4

Word the question, not the prompt

The quality of a score depends on how precisely you define the scale and the yes/no anchors. There is no prompt engineering to hide behind here, which is a feature.

5

Make the savings visible

Color the cheap path, log the token count, count the calls. Otherwise you are assuming the savings instead of verifying them, and the whole reason to do this is the bill.

6

Know where to stop

No reasoning, no explanation, 64K of context. The Bitcoin test is the line: routing decisions yes, high-stakes judgment calls no. Nobody in the corpus argues otherwise.

What’s changed

This page is alive. Here’s the update log.

Every new Jev video we break down gets added to this page automatically. Every couple of weeks we go through the new ones and rewrite the guide itself around what they found. Here’s what changed and when.

September 20, 2026

First edition. Jev launched days ago and the first creator breakdowns are in, so this page went live built from the launch-week corpus.

  • The questions people are Googling, answered straight, with the number and the creator attached to each one
  • The three primitives explained: choice, score, and null
  • Four head-to-heads creators actually ran, including the only independent one in the set
  • Five use-case playbooks, from inbox triage to wiring it into Claude Code
  • 12 things to have Jev do for you today, copied from real demos
  • The honest limits section: no reasoning, 64K context, and the live trading test it lost
↗ Rob Shocks — Jev: TypeSpace’s Decision-Only AI Model Explained↗ Greg Isenberg — Jev: The Classifier AI That Scored 1,700 Emails for 18 Cents↗ Riley Brown — JEV: How It Works and What You Can Build↗ David Ondrej — Build Anything With Jev, TypeSafe AI’s Probability-Only Model↗ Kevin Badi — How to Add Jev AI to Claude Code (Step by Step)↗ Julian Goldie — Jev AI: How to Stop Wasting Claude and GPT-6 Astra Tokens on Tiny Decisions

The library

All 18 breakdowns, and counting.

20:18
Riley Brown · Demo

JEV: How It Works and What You Can Build

TypeSafe's new model can't write a sentence. It just makes fast, cheap decisions, and a growing list of builders are already wiring it into email triage, trading bots, and self-driving demos.

September 18th