Why Modern Creator?

Rob Shocks · YouTube

Jev: TypeSpace's Decision-Only AI Model Explained

TypeSpace's new model can't write you a sentence, but it can make a decision 200 times cheaper than the LLM you're already paying for.

Posted

September 17th

yesterday

Duration

10:36

Format

Review

educational

Views

208.1K

3.3K likes

Big Idea

The argument in one line.

TypeSpace's new Jev model skips text generation entirely and instead returns fast, cheap, calibrated decisions, making it a practical drop-in layer for the routing, classification, and guardrail calls that currently cost coding agents time and money.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You're building coding agents or production AI systems and need a cheap, fast layer for routing, classification, or guardrail decisions.
You're evaluating whether a full LLM call is overkill for a yes/no or multiple-choice decision buried inside your pipeline.
You want a concrete before/after cost and speed comparison from a real company (Vercel) switching classifier models.

SKIP IF…

You're looking for a general-purpose chat or writing model — Jev explicitly doesn't generate free-form text.
You want deep technical detail on how the RLCD training method actually works; the video only summarizes it at a high level.

TL;DR

The full version, fast.

TypeSpace, founded by a former OpenAI co-founder, built Jev: a model trained with reinforcement learning to output structured decisions instead of prose. Rather than generating tokens one at a time, Jev evaluates a state against typed questions (choice, score, or true/false) in parallel, answering in milliseconds at 20-200x lower cost than a standard LLM call. Vercel swapped it in for classification work and saw 6x faster results while beating their eval baseline. Demos include Jev playing Doom in real time for about seven dollars an hour, routing smart-home voice commands in 185 milliseconds, and triaging help-desk tickets by priority and urgency. The takeaway: audit your product for expensive LLM calls that are really just yes/no or multiple-choice decisions, and consider replacing them with a typed decision model instead of a full chat model.

Free for members

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 →

Chapters

Where the time goes.

00:00 – 00:55

01 · Cold open: a model that can't write

Rob introduces Jev by contrasting its inability to produce plain text with its real purpose: fast structured decisions. TypeSpace built it because models tuned for human reading preferences are worse at pure machine decision-making.

00:55 – 01:54

02 · Decisions, not text: RLCD explained

TypeSpace's two-year training approach, reinforced learning with calibrated decisions, aims to fix mode dropping, overconfidence, and unreliability. Jev runs 20-200x cheaper than an equivalent LLM call.

01:54 – 03:12

03 · Vercel's 6x speedup and picking a lane

Vercel swapped a cheap classifier for Jev and measured 6x faster results while beating their eval baseline. TypeSpace isn't chasing the smartest general model — it's optimizing cost per decision.

03:13 – 04:01

04 · Three primitives: choice, score, null

Every Jev request is one of three question types — choice, score, or a true/false probability — demonstrated against a support-ticket example.

04:02 – 04:57

05 · Deterministic code meets non-deterministic agents

Traditional software is deterministic if/then logic; agents are flexible but not guaranteed to repeat. Jev is pitched as the hybrid layer between the two.

04:58 – 05:59

06 · Jev plays Doom; meet System One

A real-time Doom-playing demo costs about seven dollars an hour in API calls. TypeSpace's own name nods to Daniel Kahneman's System 1, the fast intuitive mode of thinking.

05:59 – 07:09

07 · No token loop: parallel evaluation and getting access

Jev has no autoregressive generation loop, evaluating a full set of typed questions in parallel. Access runs through a waitlist into a playground, with API keys and a Claude Code integration.

07:09 – 08:44

08 · Live demos: six degrees of Wikipedia, smart home, 185ms

A six-degrees-of-Wikipedia link-hopping test finishes in 1.7 seconds. A smart-home voice command demo classifies and routes a spoken instruction to the correct device action in 185 milliseconds.

08:44 – 10:14

09 · Inside the playground: sky color, help-desk triage, tool routing

Rob walks through the TypeSpace console: a 'choice' example classifying sky color with a confidence score, a full help-desk triage example scoring urgency and priority, and a tool-call routing example.

10:15 – 10:35

10 · Takeaway and sign-off

Rob closes by asking viewers to identify which of their own decision flows could be swapped from an LLM call to a typed Jev request, then points to two related videos.

Atomic Insights

Lines worth screenshotting.

TypeSpace's Jev model produces structured decisions instead of text, running 20 to 200 times cheaper than a standard LLM call for the same classification task.
Vercel swapped a cheap classifier model for TypeSpace's Jev and saw it run 6x faster while saturating their evaluation benchmark.
Jev has no autoregressive token loop: it evaluates a batch of typed questions against a state in parallel instead of generating one token at a time.
Every request to Jev is one of three primitive types: a multiple-choice question, a score on a scale, or a true/false probability.
In a live demo, Jev classified a spoken smart-home command and returned an action in 185 milliseconds.
Jev played real-time Doom for an hour and the entire run cost about seven dollars in API calls.
TypeSpace, the company behind Jev, is named after Daniel Kahneman's 'System 1' — the fast, intuitive half of human decision-making.
Traditional software runs on deterministic if-then gates, AI agents are flexible but non-deterministic, and Jev is built to sit in between as a fast, cheap decision layer.
A YouTuber used Jev to read and prioritize hundreds of emails in a couple of seconds, a task that would take a full LLM far longer.
Jev found a path through six degrees of Wikipedia links, from a DNA page to an unrelated page, in 1.7 seconds.

Takeaway

A model that decides instead of talks

COST AND SPEED

Jev proves that a lot of the 'AI' work inside a product isn't really language generation, it's a cheap classification decision dressed up as a chat completion.

01Cold open: a model that can't write

The video opens by contrasting Jev's inability to write plain text with its real purpose: producing structured decisions almost instantly.
TypeSpace built Jev because models tuned for human reading preferences are worse at pure machine decision-making.

02Decisions, not text: RLCD explained

TypeSpace spent two years building reinforced learning with calibrated decisions, a training approach aimed at fixing mode dropping, overconfidence, and unreliable outputs in preference-tuned models.
Because Jev skips free-form generation, it runs 20 to 200 times cheaper than a comparable LLM call for the same classification or routing task.

03Vercel's 6x speedup and picking a lane

Vercel replaced a cheap classifier model with Jev for a production workload and measured a 6x speed improvement while beating their existing evaluation benchmark.
TypeSpace isn't positioning Jev as a general-purpose smartest model — it's a narrow, purpose-built tool optimized for cost per decision at scale.

04Three primitives: choice, score, null

Every Jev request maps to one of three primitives: choice to pick from options, score to rate on a scale, or a true/false probability.
A support-ticket example shows choice picking a category, score rating how frustrated a customer sounds, and the true/false primitive flagging urgency.

05Deterministic code meets non-deterministic agents

Traditional software runs on deterministic if/then logic, while AI agents are flexible but not guaranteed to behave the same way twice.
Jev is pitched as the middle layer, bringing agent flexibility into workflows that still need fast, repeatable, structured decisions.

06Jev plays Doom; meet System One

In a demo, Jev played Doom in real time using a structured description of the game state and returning structured action instructions, at roughly seven dollars for an hour of play.
TypeSpace's own name references Daniel Kahneman's System 1, the fast intuitive mode of thinking, positioning Jev as the fast gut-check layer next to slower LLMs.

07No token loop: parallel evaluation and getting access

Unlike standard LLMs, Jev has no autoregressive generation loop, evaluating a full set of typed questions against a state in parallel rather than one token at a time.
Access currently runs through a waitlist into a playground with API keys, and it can also be installed directly as a tool inside Claude Code.

08Live demos: six degrees of Wikipedia, smart home, 185ms

A six-degrees-of-Wikipedia navigation test found a path between two unrelated pages in 1.7 seconds by having the model pick the next link at each hop.
A smart-home voice command demo classified and routed a spoken instruction to the correct device action in 185 milliseconds, with no multi-step reasoning chain.

09Inside the playground: sky color, help-desk triage, tool routing

The playground's choice example classifies a plain question like what color is the sky and returns a probability-weighted answer with a confidence score.
The help-desk triage example takes a full support state including role, location, and time, and returns a prioritized decision plus a separate true/false read on urgency.

Glossary

Terms worth knowing.

RLCD (Reinforced Learning with Calibrated Decisions): The training method TypeSpace built over two years to produce a model whose output is a calibrated decision rather than free-form text.
Mode dropping: A failure pattern in models trained on human preferences where the model collapses toward one answer instead of representing the true range of possibilities.
Autoregressive loop: The way standard LLMs generate text one token at a time, each token conditioned on the ones before it; Jev skips this entirely.
Choice / Score / Null: Jev's three question primitives: pick from a list of options, rate on a numeric scale, or answer true/false with a probability.
System 1 / System 2: Daniel Kahneman's model of two modes of human thinking — fast and intuitive versus slow and deliberate — which TypeSpace's name and positioning reference directly.

Resources

Things they pointed at.

00:44toolTypeSpace

02:43productVercel

03:13toolOpenCode / browser-use

05:25bookThinking, Fast and Slow (Daniel Kahneman)

09:28toolClaude Code

10:20linkPstack (Rob Shocks' prior video)

10:30linkAnthropic SDLC breakdown (Rob Shocks' prior video)

Quotables

Lines you could clip.

00:00

“So this huge new model can't write a single sentence. It can't explain itself, but it is a very interesting model.”

contradiction hook, sets up the whole video→ TikTok hook↗ Tweet quote

02:07

“They swapped it out with TypeSpace and it was 6x faster and it basically saturated the eval.”

concrete production stat from a named company→ IG reel cold open↗ Tweet quote

05:36

“Every LLM we've been using is trying to be system two... however Jev doesn't generate tokens, there's no autoregressive loop.”

the core technical distinction stated plainly→ newsletter pull-quote↗ Tweet quote

08:25

“185 milliseconds. What we're doing there is sending in the command, it's doing some very quick classification.”

hard speed number from a live demo→ TikTok hook↗ Tweet quote

The Script

Word for word.

Read-along

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.

analogy

So this huge new model can't write a single sentence. It can't explain itself, but it is a very interesting model. And big production companies like Vercel are saying they're seeing extraordinary results from it.

So it's called Jev. My name is Jev. So it literally came out yesterday from a company with some serious credentials.

This is Diego Almeida and he was one of the co -founders of ChatGPT. So Typeface and Jev are something completely different. So this is a different kind of model.

We're used to most frontier models producing text. It's designed for humans and instruction following. So the problem is these models are trained for human preferences and that doesn't make them ideal for machine usage.

We get mode dropping, overconfidence and lack of reliability. So the team at TypeSpace has spent the last two years reinventing the process and have come up with reinforced learning with calibrated decisions.

Now, what the heck is that? so the big difference here is jev is trained to produce decisions for your code to act on so every model that we're used to is basically creating text for humans to read and consequently agents can read that text as well but jev does something very different and very useful in just milliseconds and between 20 and 200 times cheaper than existing models you might use for the same same task you can get it to categorize things and even decide whether something is true or false there are a lot of real good use cases for something like this that is super fast and very cheap if you're building coding agents or you're building agents in production this is going to make you a lot more accurate and efficient instead of using a sub agent as a guardrail or a security review you could have Jev do that at lightning speed let's say you want to classify a task to see what model should be used Jev could be used as a great model router one great example is ticket triage so what's the big deal here we could have done this before with

a large language model. The big difference here is the difference between the speed and the cost. If you want chat, this is not the model for you.

If you want lightning fast, cheap with high levels of confidence, then this is what you want. So you can imagine that thousands of companies out there, including companies like Vercel, that do any kind of classification or verification, it's going to be incredibly expensive to do that at scale, particularly because all these models are non -deterministic and they tend to veer off or hallucinate or get things wrong.

The guys at Vercel were using a cheap model like Gemini 2 .5 flashlight to do some of their classifying. They swapped it out with TypeSpace and it was 6x faster and it basically saturated. the eval, meaning it just performed way above.

This can actually be a really big deal, particularly when you just don't need all that text coming back. Already people are doing some really cool things with it, like wiring it up to StarCraft and having it win missions. Now, what TypeSafe and Jev are doing here is really picking a lane.

They're not saying they're the all model. They're a very specific focus model and they do that thing very well. So it's not going to be the smartest model in terms of what you need, but look at what it does in terms of cost per workflow.

This means it can be used at huge scale and it can unlock completely new types of companies and workflows. great example here the guys over at open code tested it with browser use and it is blazingly fast this is why i'm excited for what really cool workflows this could start to unlock there's a lot to play with here so when you're submitting a question to jeff you've got three different question types choice score or null so you give it the options which would either be billing technical or sales it reads the ticket and decides that it's going to be technical and it's going to give you this confidence value here as well you can also give it to give you a score so maybe with that issue or ticket that comes from a customer you want to score it on a scale of how frustrated the user might be is it calm civil or angry so you get that score there as well and then renewal gives you a kind of yes no probability on your ask is this true is this urgent with a probability number

so one cool application i saw from youtuber vogel was basically classifying all of his emails so literally in just a couple of seconds he got it to read through hundreds of emails uh categorize them and drop priorities on them if you were to do that via a regular llm it would take you so much longer so here's a good breakdown from the docs that i posted on twitter so traditional software is deterministic it's all about yes no gate if then else Agents, on the other hand, are very non -deterministic.

It makes them super flexible and super useful, but it also means that they're not always correct. They don't always follow the plan and they're not guaranteed to do the same thing 100 % of the time. Where Jeff comes in really powerful is in the hybrid world of AI -powered software.

That's where we're using some levels of determinism, but then we bake in a model like Jeff to help us with those decisions that we previously couldn't manage via... completely deterministic methods so this is jev playing doom and you can actually see the real time rate and running this whole thing for one hour the amount of calls was crazy only cost around seven dollars so system one is getting a structured description of what's happening in real time and the model is feeding back instructions also in a structured format so there's some cool easter eggs baked into some of the naming conventions here so system one is actually the name of the company And that comes from the two systems of thinking from Daniel Kahneman, thinking fast and slow.

So system one is the fast intuitive gut check and then system two is the slow deliberate reasoning. every llm we've been using is trying to be system two think it through write it out and do it one token at a time however jev doesn't generate tokens there's no auto aggressive loop you just send it a state some text to json object and a set of type questions it evaluates them all in parallel so that's the other cool thing this is all done in parallel which makes it super fast you're not sending requests in a blocked fashion one at a time so you should be able to get access to this pretty quick i was on that waitlist for just a couple of hours and i got in so in there you'll get a playground your usage api keys etc this is an api you can set up you can also install it directly into cloud code but the playground is well worth investigating so you can look at some of the demos here so this is a fun test it's like six degrees of separation how many hops can you get from a wikipedia page like dna to something like mani puri pony how fast can a model do that by negotiating its way through the page and finding the next link let's check it out uh and we're gonna press go and types have got there in 1 .7 seconds so it went through

If we're working with a smart home device and we give it some natural language, like turn on the living room lights, that would have to go to an LLM, get processed, read through the available list of devices, pick a state, send that back, and then hope it's accurate enough so that the system can actually run it. Let's take a look at how that might work with the typing that we can do with TypeSafe.

So we can do turn off all of the lights. And over here in our mock smart home, we can see that all the lights turned off. We can say turn on the living room lights and those turned on.

We can say shut off all the music in the house and the smart speaker turned off. Get the coffee boiling. now you can see how fast that is it's super fast in its return look 185 milliseconds what we're doing there is sending in the command it's doing some very quick classification it doesn't have to go through reams of text and tokens it's reinforced learning is designed to shoot us back an answer really fast and really cheap so i hope you're starting to get the picture this is about decisions and not about text We're sending in a state, which might be a mixture of an email, user, some transaction details, and then the context of what we want the model to do.

It's going to process that, and then we get back set typed JSON that we're able to process with some kind of function on the other side. Fraud level, confidence, and risk scores. I think this has big implications for the speed and predictability of our coding agents, and particularly MCP usage and CLI usage.

Imagine being able to rapidly jump through through an MCP2 list or a skill call really efficiently. So let's check out some sample requests in the TypeSpace console playground.

So we've got three different example requests. Let's look at choice. So we have our question here, what color is the sky?

So our request is titled sky color, then we pick a primitive. So in this case, we're asking a multiple choice question. The instructions are what color is the sky?

And our criteria are the list of possible selections or answers that we want the model to choose from based on its probability. So we'll just run that request. And in just a few milliseconds, we get our response.

It's an 81 % likelihood to be baby blue and a confidence level of 78%. So another great example is a help desk triage. so here we have the state so the request is it's been over a week nobody's responded to my report about the wi -fi and then you can pass in things like user role location channel location and time and then the main question here is what priority are we setting this so we're giving this a choice so the model has to decide which priority we're going to assign this we're giving it a instruction of what priority and then criteria of low medium high critical some examples and then also some nested options so then running this we get a percentage likelihood on a medium priority so a triage so it's decided as a choice where this should go is it the help desk the finance ops etc our new question is does this mention a deadline of any type and there is a five percent chance that that is true And this is a really cool area when it comes to agents.

Which tool call should we use? Is it ticket status, Wi -Fi troubleshooting, and what confidence level? So in this case, it's saying it should be ticket status.

So you can imagine tool calling is a huge part of how we use agents. If we've got a model like this and probably more models like this to come that are super cheap and super fast, it's going to be a big deal. So if you're building AI powered software, you need to ask yourself, what are the big decision flows within your system that are costing you lots of time and real money to make those decisions?

Can those simply be changed into a yes or no structured input and output that is way faster and way cheaper? Imagine the difference that is going to make to your app. And also, what are the really cool things you can start to build with this now, like some of the examples that I showed you in the video?

I stayed up really late to make this video so if this was useful please subscribe. This is going to move really fast and I'll be covering it as it does. If you're new to the channel and you're a software developer and builder I cover all things got to do with building AI.

Check out my last video on Pstack which is a really cool skills library and also my breakdown on the new SDLC from Antropic.

The Hook

The bait, then the rug-pull.

A brand-new model just shipped that can't write you a sentence, and that's the point: TypeSpace's Jev is built to make fast, cheap decisions instead of generating text, and production teams like Vercel are already swapping it in.

Frameworks

Named ideas worth stealing.

00:44concept

RLCD (Reinforced Learning with Calibrated Decisions)

TypeSpace's training method for producing a model that outputs calibrated decisions rather than free-form text, addressing mode dropping, overconfidence, and unreliability seen in preference-tuned LLMs.

Steal forany pipeline currently burning full LLM calls on what's really a classification or routing decision

03:13list

The Three Question Primitives

Choice
Score
Null

Every Jev request is typed as one of three primitives: pick from options, rate on a scale, or answer true/false with a probability.

Steal forstructuring agent decision points as typed questions instead of freeform prompts

05:25concept

System 1 / System 2 Thinking

Daniel Kahneman's split between fast, intuitive thinking and slow, deliberate reasoning, which TypeSpace uses to position Jev as the fast gut-check layer next to slower LLMs.

Steal forexplaining why a small fast model and a large slow model can coexist in the same agent pipeline

CTA Breakdown

How they asked for the click.

VERBAL ASK

10:15subscribe

“I stayed up really late to make this video so if this was useful please subscribe.”

Direct, personal ask tied to effort invested, followed immediately by pointing to two related back-catalog videos for viewers who want more.

Storyboard

Visual structure at a glance.

cold open

hookcold open00:00

Vercel case study

valueVercel case study02:43

Jev plays Doom

valueJev plays Doom05:25

185ms smart home demo

value185ms smart home demo08:01

sign-off / CTA

ctasign-off / CTA10:15

Frame Gallery

Visual moments.

cold open

Frame at 00:07 from Jev: TypeSpace's Decision-Only AI Model Explained

Frame at 00:19 from Jev: TypeSpace's Decision-Only AI Model Explained

Frame at 00:29 from Jev: TypeSpace's Decision-Only AI Model Explained

Frame at 00:37 from Jev: TypeSpace's Decision-Only AI Model Explained

Frame at 00:41 from Jev: TypeSpace's Decision-Only AI Model Explained

One-click upgrade to your Google

Get more breakdowns in your search results

Add Modern Creator as a preferred source and Google shows you more of our breakdowns in Search, Top Stories, and AI Overviews. It only changes what you see, and you can undo it in your Google settings anytime.

Add to Preferred SourcesOpens your Google source preferences with us pre-loaded. Tick the box and you're done.

Watch next

More from this channel + related breakdowns.

12:57

Rob Shocks · Review

Pstack Is Agent Overkill. Use It Anyway!

A walkthrough of Lauren Tan's pstack: 21 engineering principles, 22 playbooks, and 24 skills that turn a coding agent from a slop machine into a verification-obsessed engineer.

September 8th

16:21

Rob Shocks · Essay

Claude's New intent.md: Inside Anthropic's AI-Native SDLC Playbook

Rob Shocks breaks down Anthropic's new AI-native SDLC playbook, the intent.md to plan.md artifact chain meant to keep agents and humans in sync from planning through autonomous maintenance.

September 1st

44:12

Theo - t3․gg · Review

OpenAI's GPT-6 Astra, tested by Theo before almost anyone else could touch it

Early access to OpenAI's next flagship model turns into a benchmark massacre, a string of jaw-dropping 3D demos, and one very ugly story about a model that lied about finishing a PR.

September 4th

27:14

The Next New Thing · Listicle

Top 10 Repos Explained: Archify, Omarchy, OpenMAIC, and More

Two hosts screen-share their way through this week's ten most useful GitHub repos, then react live on air to seven reader-submitted projects.

September 4th

Video of the Day30:53

Nate Herk | AI Automation · Review

Opus 5 vs. Fable 5: I Ran Both Through Real Workflows

Eighteen real Claude Code sessions later, the model that's half the price per token isn't automatically the cheaper one to actually run.

July 24th

36:06

Pat Simmons · Review

Kimi K3 Is Here! (Better Than Opus 4.8?)

Ten identical builds, five models, blind-ranked before the reveal — a real-world stress test of Moonshot AI's new open-source model against GPT-5.6 Sol, Opus 4.8, GLM 5.2, and its own predecessor.

July 17th