🎯 What Jev Is 0:00
Moritz opens with the headline claim: a model released "yesterday" that is 20–200× faster and 40–400× cheaper than frontier LLMs — and it's a completely different kind of model, trained differently from the LLMs behind ChatGPT and Claude. The name is Jev 🔗, from TypeSafe.
Rather than recite the spec sheet, the video's value is in showing what the architecture enables — three prototypes that each demonstrate a different slice of "software that can make decisions in real time."
🆚 Jev vs an LLM: The Invoice Test 0:34
The clearest explanation is a side-by-side on the same question — "is this invoice fraud?" An LLM answers in a sentence, generating "based on the line items and the vendor history, this invoice appears to be legitimate…" one token at a time, taking 8.5 seconds to reach that verdict.
Jev answers the same question as a classification: it points at one of three predefined options (fraud / clean / review) and returns a probability — here, 88% likely clean — in a fraction of the time. The framing that matters: "LLMs generate answers, while Jev gives you probabilities, which helps you make decisions." The output isn't text; it's a pointer at one of your predefined options plus calibrated confidence.
🧮 The Trade: No Writing, 100× Speed 2:49
The deeper insight is that software is "full of these little decisions — also known as if statements." Route it here, escalate it to a human, flag it for review: that's how most software actually works, and it's exactly the class of problem Jev is built for.
| Jev can… | Jev cannot… |
|---|---|
| Pick an action | Write a sentence |
| Classify | Explain itself |
| Score and rank | Write code |
| Route | Reason step by step |
The trade is explicit: Jev gives up writing to get ~100× speed. The example that makes it concrete is a game character — Jev can control its actions (move left, move right, shoot) in real time from the environment state, "which an LLM would just not be able to do because it's not fast enough." The pattern that falls out is the throughline of the whole video: use Jev and an LLM together — Jev decides what needs to happen, and the LLM reasons or generates when deeper intelligence is required.
🔑 Getting Started 4:06
Setup is still gated: Jev is on a waitlist at typesafe.ai, with access being rolled out gradually. Once in, there's a console with a playground for poking at the model before you write any code, and the only thing the tutorial actually needs is an API key from the API-keys tab, saved to a local .env file.
The interesting workflow detail: Moritz opens Cursor and tells it to "read the documentation completely and save a compressed version" — so the coding agent has the full Jev API surface locally and doesn't have to keep bouncing back to the browser for docs. It's a small habit, but it's the "let the agent absorb the reference material first" move that makes the rest of the session fast.
🎙️ Example 1: Voice-Controlled Browser 5:59
The first prototype is a web app where you speak and the browser obeys — "go to wikipedia.org", "click on the first link", "scroll down a bit", "go back." The demo works in real time, and the architecture is the template for everything Jev is good at. It's a three-part pipeline:
The point is what the model is not doing: an LLM would have to reason through the page step by step, too slow for a live conversation. Jev "just gets all that data and makes very fast decisions on the probability that this button should be clicked — then it clicks." In practice it's near-instant: "when I said 'go back', it went back before I even finished my sentence."
🧠 Example 2: Memory Retrieval 11:33
The second prototype fixes a real pain: Moritz's "Claudia OS" — a personal folder of daily memory markdown files that seeds all his AI chats. The naive LLM approach guesses which file to read from its title, reads the whole file, and "hopes it's right"; writing memory is worse, because the agent never knows which file to append to and usually dumps everything in the daily file.
The Jev version is a "judgment engine, not a writer." You give Jev state — a list of files, a list of sections, a new bullet — plus a batch of small typed questions (yes/no, pick-one, score), and it answers all of them in one request in a few hundred milliseconds with probabilities. Then "the code does the counting, chunking, and diffing — Jev only makes the small semantic calls." The results speak for themselves:
| Query | Tokens (with Jev) | Savings |
|---|---|---|
| "Current offer positioning" | 2,756 vs ~13,000 | ~80% fewer |
| "What broke between CRM and email provider?" | 293 vs ~13,000 | ~98% fewer |
| "Moritz's favorite pizza topping" (not in memory) | 0 | 100% — Jev knew it didn't exist |
That last row is the memorable one: the question was never discussed, so Jev returns "no" and zero tokens are spent searching — an LLM would have read files to conclude the answer wasn't there. It's a prototype, but the memory-savings pattern is the real demonstration of the decision-model economics.
📺 Example 3: YouTube Topic Scoring 17:27
The third prototype turns Jev into a content-strategy tool. It fetches 600 videos across 15 channels in the niche and crunches the data, surfacing feature importance — the factors that actually predict a video's success (duration: longer videos do better; live streams; whether it's a course/training).
Two tools sit on top. "Score my title" takes a proposed title, thumbnail concept, and planned length, and returns a breakout probability — a 2-hour course scores high; a 20-minute "what is Jev" video scores 0.35 and gets flagged an underperformer. Then "ID8" reverses the direction: you give it a topic, an LLM writes 15 candidate titles and thumbnail concepts, Jev featurizes each one, ranks them, and runs a final sanity pass over the top five — asking which a viewer would click and which is the most honest. The winning pick ("Jev tutorial for beginners: build your first AI agent") is rewarded for specificity.
The division of labor is explicit here: the LLM does the generation (writing 15 candidate titles), and Jev does the evaluation (featurizing, ranking, sanity-checking) — fast enough to run over a large candidate set.
⚖️ Verdict & Where Jev Still Needs an LLM 22:12
Moritz's honest read is that Jev is "definitely just a start" — interesting, but not a drop-in replacement for anything. The pattern across all three prototypes is the same, and it's the key mental model: Jev decides, an LLM reasons and generates, and plain code acts on the probabilities. Every prototype still leans on an LLM for the parts that need text or deep reasoning, and on ordinary code for the deterministic parts.
💡 Key Takeaways
- Jev gives probabilities, not sentences. It points at a predefined option with calibrated confidence — and returns it in a few hundred milliseconds.
- The trade is writing for speed. No explanation, no code, no step-by-step reasoning — but ~100× faster, which unlocks real-time loops an LLM can't do.
- Software is mostly if-statements. Routing, triage, escalation, classification — that's Jev's entire wheelhouse.
- The winning pattern is Jev + LLM + code. Jev decides, the LLM reasons/generates, and plain code acts on the returned thresholds.
- Batch your questions. Both the browser and memory demos work by asking Jev a bundle of typed yes/no/pick-one/score questions in one request — one semantic call, not a conversation.
- Knowing the answer isn't there is free. Jev returned 100% token savings on an unanswerable memory query — an LLM would have read files to reach the same "no."
- Claim-check the numbers. "20–200× faster, 40–400× cheaper" is marketing; the official figures are 40–200× faster and $0.042/MTok input.
🔗 Resources & Links
- 🌐 typesafe.ai — try Jev / join the waitlist
- 📰 Introducing System One Models & Jev — the TypeSafe launch post (founder, benchmarks, pricing)
Source video: youtube.com/watch?v=Nq_lu5QT-fI