▶ YouTube Summaries

• YT :: https://www.youtube.com/watch?v=F3YXg7AaKWE
• Original title :: Jev is incredible

Typesafe AI released Jev, a "system one" frontier model that does classification instead of text generation: unstructured state in, typed probabilistic decisions out. It is 40-200x faster and orders of magnitude cheaper than LLMs on classification workloads, never violates the output schema, and reports calibrated confidence with every answer. Theo's whole argument is that it is a library-level primitive - a smart if-statement you call from code - not a replacement for reasoning models, and most of the excitement on Twitter is people misapplying it.

What Jev is

The name comes from Jevons paradox: making a capability cheaper increases its total consumption. Jev unlocks no new capability - it makes classification cheap and fast enough to be viable in places where calling an LLM never was. The system-one framing is from Kahneman's Thinking Fast and Slow: fast intuitive judgement (Jev) versus slow deliberate reasoning (still the reasoning models).

It was built by a founder who worked on the instruction-following and RLHF research behind ChatGPT, and who concluded that RLHF helps model behaviour but not classification. Typesafe AI spent two years in stealth building a separate stack - new architectures, parallel samplers, and a training method they call reinforcement learning for calibrated decisions. Jev is in invite-only early access, reachable through OpenRouter and the Vercel AI gateway.

Key properties:

• Output shape is deterministic. Give it a JSON schema and you always get that schema back; content is not deterministic but is reliable. Measured structured-output error rate is 0%, versus 45.5% for Haiku and worse-than-Terra-and-Luna-combined for Astra.
• Every output carries a confidence estimate. Ordinary models are overconfident and inconsistent, and a task a model does right 95% of the time without telling you which 5% it missed cannot be automated.
• Roughly $0.04 per million input tokens against ~$10 for a model like Fable, with output tokens free ("too cheap to meter").
• 70-500 ms per call against 3-300 seconds for LLM classification.
• 32k context, no vision. It takes structured program state, not message histories.
• Batches many inputs in parallel.

Prior art is BAML, a small interface language between typed code and LLMs that patches malformed JSON in its runtime. Jev makes the patching unnecessary - the model literally cannot emit the wrong shape.

What it is good at

Anything you would classify, rank, score, or route: tagging a video library by topic, triaging email, moderation and safety labelling, guardrails and jailbreak detection, map-reducing a pile of data into insights, choosing the next link in a web navigation loop.

Sub-500ms worst case makes it usable inside real-time UI - a live search, a colour-palette generator that updates as you type, or JSON-render components that get their whole payload at once instead of waiting on a token stream. Demos include Doom driven from game-state JSON at under $7/hour running ten decisions a second, wiki-racing, and booking a flight in 7.1 seconds.

Ryan's email demo is the representative case: 1,500 exported emails classified at ~200 ms each (P95 240 ms), 38 per second - a cheap first pass that strips the obvious junk before anything expensive runs. Theo classified 32,311 messages across 1,118 coding threads for $0.37 and found nearly half his work was bug fixing and ~20% PR review. Because outputs are scored 0-1 rather than hard labels, he could slide the confidence threshold afterwards: 22% of threads counted as scope expansion at 80% confidence, 6.8% at 90%.

What it is bad at, and the demos to ignore

Jev is roughly as intelligent as a switch statement. The checkers game Theo built responds instantly and plays terribly - he beat it while barely paying attention. Doom looks twitchy because each frame wipes its brain and re-decides with no memory of the last move. It can't reason across a codebase, and asking it to pick which threads were good video material produced garbage.

Two bad ideas circulating:

• LLM-as-judge replacement. Brain Trust suggested swapping the judging model for Jev to save the effort of prompting a general model into a judge. Writing that prompt takes thirty seconds, and a one-sided classifier cannot evaluate the reasoning it is meant to grade.
• Context compaction. Compaction synthesises a summary, it is not a filter that deletes lines. Jev sees neither tool results nor reasoning traces (labs no longer return them), and 32k of context is not enough to decide anyway. Models are RL-trained on their own compaction and already do it well. Deleting middle history invalidates the prefix cache and forces expensive rewrites, and a shallow classifier eventually loops with nothing left it is willing to drop. People have benched it; it performs badly. Its only real virtue is that it is fast enough to go viral.

The heuristic

Once you have perceived all the information, how many seconds does it take you to answer? Under ten seconds - naming the colour of a shirt - and Jev is the right tool. Over ten seconds and it is not. Treat it as a library you install or a function you call, integrated into the tools you build; not something you run in Codex or Claude Code as an inference farm. Image support, when it lands, would make computer use and frame-level PII scanning compelling.