The argument in one line.
Jev is a classifier-only model that skips text generation entirely, so it lands within a few points of frontier-model accuracy on simple factual questions at a fraction of the cost and time, but falls behind on anything requiring real judgment.
Read if. Skip if.
- You run high-volume routine decisions (triage, tagging, routing) that currently get sent to a full LLM just to pick one of a few options.
- You already use Claude Code, Codex, or another agent harness and want a cheap pre-filter before a request hits a frontier model.
- You're building or operating an AI agency and want a concrete cost and speed benchmark before recommending a classifier model to a client.
- You need the AI to write or generate any actual text, code, or content; Jev cannot produce a single word.
- Your decisions require genuine judgment calls rather than a fact sitting plainly in the text; the video's own tests show frontier models still win there.
The full version, fast.
Jev, from TypeSafe AI, is a decision-only model: it never writes text, it just reads a piece of information plus a question and returns one pick from options you supply, along with a confidence percentage. Because it marks every answer at once instead of writing word by word, it runs in under a second and costs about 4.2 cents per million tokens in with free output. Testing it head-to-head against Claude Fable 5.1 and GPT-5.6 Astra across an inbox triage, contract review, AI-slop detection, and lead-scoring task, Jev matched the frontier models on plain factual questions for a few hundred times less money, but its own confidence score drops below 90% exactly where judgment is required, and that's where the bigger models still win.
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.

01 · JEV is going viral
Cold open on the viral launch posts: a Claude Code session token-count drop, a 7-second flight search, and 50 parallel Subway Surfers games, all run through a brand-new model.

02 · What JEV actually is
Introduces TypeSafe AI, the two-year-stealth company behind Jev, and the three-input structure: information, a question, and a fixed list of allowed answers.

03 · The three kinds of questions
Jev only answers three question shapes: yes/no (returned as a probability), pick-one from up to 255 options with a confidence score, and a custom 1-10 score that can land between two levels.

04 · Why it's so fast
Normal LLMs write answers one word at a time; Jev marks every answer on a multiple-choice sheet simultaneously, so a dozen questions on the same text all return together in 0.07 to 0.5 seconds.

05 · It's just a classifier
Addresses the objection directly: Jev is fundamentally a classifier, but unlike a traditional one it needs no labeled training data. Options are typed in plain English and it works on the first try.

06 · Getting JEV into your harness
Wiring Jev into Hermes, Claude Code, or Codex takes about a minute: sign up at typesafe.ai or route through OpenRouter, paste in an API key, and tell the agent to install it.

07 · The numbers: speed & price
TypeSafe's own homepage claims 193.6x faster and 444.6x cheaper. Input runs $0.042 per million tokens with free output; 10,000 decisions at 750 words each costs about 42 cents total.

08 · Is it actually any good?
TypeSafe's own published test table across four business workflows: Jev is cheapest and fastest on every row and most accurate on none, with the accuracy gap widening as the questions require more judgment.

09 · How to get access
Two paths in: join the typesafe.ai waitlist (people report getting in within a day) or skip the wait entirely through OpenRouter, which is what powers the live head-to-head comparison tool used for the rest of the video.

10 · Test 1: the inbox
40 emails styled like a real inbox, three questions each (needs reply, category, urgency) run through Jev, Claude Fable 5.1, and GPT-5.6 Astra. Jev finishes under two seconds for under a cent; the frontier models take 15-30 seconds and stay close on need-reply and category but fall further behind on urgency, the most judgment-heavy question.

11 · Test 2: contracts
Classifying auto-renewal clauses, notice periods, and risk scores across a batch of contracts: Jev matches the frontier models exactly on the plain-fact questions (does it renew, how many days notice) at roughly five times the speed and a few hundred times less cost.

12 · Test 3: spotting AI slop
30 homepage paragraphs, half generic buzzword copy and half real writing. All three models catch the AI slop itself perfectly (30/30), but only the frontier models can reliably explain what the specific problem with the copy is.

13 · Test 4: inbound leads
30 stripped contact-form messages scored for whether they're worth a sales call, which service they want, and urgency. Jev lands one call short of the frontier models (29/30) while finishing in a fraction of the time.

14 · The pattern across all four
Same result every time: on a simple fact sitting in the text, Jev matches the frontier models for a few hundred times less money. When the question needs real judgment, the big models stay ahead, and Jev's own confidence percentage tells you which rows those are.

15 · Where to start
Pick one recurring decision (is this lead worth a call, does this review need a reply, which folder does this invoice belong in), write out the options, hand it to Jev, and watch its confidence percentages for a week before letting it act unsupervised.

16 · Six ways people are using it
Six running use cases: grading competitor ads by awareness stage, a spreadsheet that tags itself by meaning, routing requests to the cheapest model by difficulty, stopping an agent from loading the wrong skill (cut Hermes' wrong-skill rate by more than half), running 50 parallel browsers to find what breaks a release, and finding a specific file by description.

17 · What to be careful with
TypeSafe's own docs list the failure modes: it can't invent a fourth option so 'not stated' has to be one of your choices, it's bad at math and reads dates as text, it takes your question literally rather than what you meant, and it degrades on long messy documents. A blitz chess match makes the same point visually: Jev won on the clock but lost the game in 18 moves because it decides fast without planning ahead.

18 · The chess match
The clock-versus-checkmate result closes the loop on what Jev actually is: a fast decision-maker, not a planner.
Lines worth screenshotting.
- Jev cannot write a single word; it only reads information and a question, then picks one answer from the options you give it.
- Because Jev marks every answer at once instead of writing token by token, it answers in 0.07 to 0.5 seconds instead of 3 to 329 seconds for models that write out their response.
- Jev costs $0.042 per million input tokens and charges nothing for its output, since it never generates any text.
- Testing 13 questions in one call came out over 11 times cheaper and almost 10 times faster than asking them one at a time.
- Jev is technically a classifier, but unlike a traditional classifier it needs zero labeled training examples; you just write your options in plain English.
- Across four real business tests, Jev was the cheapest and fastest option on every single row and the most accurate on none of them.
- On a customer-service classification task, Jev scored 76% accuracy against the best frontier model's 78.3%, a 2-point gap for roughly 300 times less cost.
- Jev's own confidence percentage doubles as a trust signal: at 90% or higher it agrees with the frontier models almost every time; below that, a human or bigger model needs to be in the loop.
- On plain factual questions, like whether a contract auto-renews, Jev matched frontier-model accuracy at roughly five times the speed and a few hundred times less cost.
- Jev always picks one of the options it's given, even when the real answer isn't on the list, which is why 'not stated' has to be one of the choices you offer.
- Jev is documented to be bad at math and bad at dates, since it reads a date as text rather than reasoning about which of two deadlines comes first.
- Running Jev as a pre-filter in front of Hermes' 182 skills cut wrong-skill loads by more than half.
- Vercel's CEO reported that swapping their coding agent's per-command safety reviewer to Jev made it up to 18 times faster and more accurate than the model they'd been using.
- In a blitz chess match against a frontier model, Jev won on the clock but lost the game, checkmated in 18 moves, because it makes fast decisions without planning ahead.
- The advertised '444 times cheaper' figure is the ceiling from TypeSafe's own homepage tests, not the average; real savings shrink the moment a task needs even one written sentence.
- A single Jev call can be multiplied across 50 parallel browser sessions testing which UI element breaks a new release, for pennies total.
When a model that can't write still wins
Jev proves that most of what you send to a frontier model is actually a multiple-choice question in disguise, and pulling those out first can cut cost and latency by orders of magnitude.
- A decision-only model needs exactly three inputs: the source text, a question about it, and the fixed list of answers it's allowed to pick from.
- Every question a pure classifier can answer reduces to one of three shapes: yes/no as a probability, pick-one from up to 255 options with a confidence score, or a custom score across up to 10 levels.
- Writing an answer word by word is what makes a normal LLM call slow; a model that only marks a box can answer a dozen questions on the same text simultaneously.
- Batching multiple questions into one call ran 11 times cheaper and almost 10 times faster than asking them one at a time in the same test.
- A classifier that requires zero labeled training data changes the economics: type your categories in plain English and it works on the first try, no dataset needed.
- A narrow decision-only model is cheap enough to wire into an existing agent harness as a pre-filter rather than a replacement for the main model.
- At roughly four cents per million input tokens with free output, 10,000 decisions of 750 words each costs about 42 cents total, cheap enough to classify everything instead of only what seems worth a person's attention.
- Published multiplier claims like '444x cheaper' come from the vendor's own best-case benchmark; treat homepage multipliers as a ceiling, not an expected result.
- The real verdict was 'cheapest and fastest on every row, most accurate on none' — a tool can be the right choice without winning on every axis.
- The accuracy gap between a fast classifier and a frontier model widens specifically as a question requires more judgment, which is a useful signal for deciding what to route where.
- On fact-based questions the classifier stayed within a few points of frontier-model accuracy in under two seconds for under a cent, but the gap widened on the one genuinely judgment-heavy question in the same test.
- When the answer to a question is a plain fact sitting directly in the text, like whether a contract auto-renews, a fast classifier matched frontier-model accuracy at a fraction of the cost and time.
- Detecting that copy is generic AI filler is a simple yes/no every model nailed; explaining specifically what's wrong with it needs more reasoning, which is where the cheaper model fell behind.
- The same split showed up in every test: matched accuracy on plain facts, a widening gap on anything needing judgment, and the model's own confidence score reliably flags which rows are which.
- Start with one decision you already make repeatedly, write out the exact options, hand it to a classifier model, and watch its confidence percentages for a week before letting it act unsupervised.
- A pre-filter that scores a request's difficulty before routing it to a model stops you from paying frontier prices for work a cheap model could do.
- Adding a lightweight classifier as a skill-picker in front of a large skill library cut wrong-skill loads by more than half in one real deployment.
- A model that always picks one of your given options will still pick something even when the true answer isn't on the list, so 'not stated' or 'none of the above' has to be one of the choices you offer.
- Known weak spots are worth logging before trusting any classifier: poor at arithmetic and treats dates as text rather than reasoning about chronology.
- Speed and planning are different capabilities: winning on the clock isn't the same as winning the game, so it's worth knowing which one your tool is actually optimized for.
Terms worth knowing.
- Jev
- A decision-only AI model from TypeSafe AI that reads information plus a question and returns one pick from a fixed list of options with a confidence percentage, without generating any text.
- System One Model
- TypeSafe AI's category name for Jev, referencing fast, intuitive 'System 1' thinking rather than the slower, deliberate reasoning of a full language model.
- Classifier
- A type of model that sorts input into predefined categories rather than generating free-form text; Jev works this way but skips the usual step of training on labeled examples.
- Confidence score
- The probability Jev reports alongside its pick, showing how sure it is about that answer; used as a threshold for deciding whether to let it act automatically or route to a person.
- Model routing
- Using a small, cheap model to judge how hard an incoming request is before deciding which, more expensive, model should actually handle it.
Things they pointed at.
Lines you could clip.
“A brand new kind of AI model called Jev has been going completely viral all over the internet this week.”
“It cannot write a single word. It only makes decisions.”
“Jev never writes anything. It's just like handing somebody a multiple choice sheet instead of asking for an essay.”
“Cheapest and fastest on every single row, and the most accurate on none of them.”
“It just makes very fast decisions. It doesn't plan ahead.”
Word for word.
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
The bait, then the rug-pull.
A brand-new model called Jev has gone viral for doing something no other AI does: it never writes a single word, it only picks. Nick Puru tests the hype against three real business workflows and Claude Fable 5.1 and GPT-5.6 Astra to see where a model that can't write anything actually earns its keep.
Named ideas worth stealing.
The Three Question Types
- Yes/No — returned as a probability (e.g. 94% yes)
- Pick One — up to 255 options, returns a confidence score for the top pick
- Score — a custom scale you define, up to 10 levels, can land between two
Every Jev call has to be shaped as one of these three question types; there's no free-form output.
The 90% Confidence Rule
When Jev's own confidence score comes back 90% or higher, it agrees with frontier-model answers almost every time. Below that threshold, the question likely needs real judgment.
Route by Difficulty
Jev reads an incoming request first and classifies it as easy, medium, or hard before deciding which model actually handles it, so cheap requests never hit frontier pricing.
How they asked for the click.
“There's going to be a completely free guide that we are giving away, link will be down below in the description... and if you're feeling crazy you can book in a call with our team if you qualify to go AI native.”
Soft verbal CTA at the very end pointing to a free AI Growth Plan landing page (shown on screen) plus an optional qualification call; held until after all the teaching content is delivered.






























































