JEV: How It Works and What You Can Build

Video authored by the channel shown, not by IANIA; all rights belong to the creator. Transcript and summary generated automatically; the original-language content is preserved.

Original language: English

Original video: JEV: How It Works and What You Can Build · Channel: Riley Brown · 19:49 · Watch on YouTube

Topics: AI agents, Enterprise AI applications, Task and workflow automation, Data, databases and embeddings, AI models

Summary

The video introduces Jev, a model from Type-Safe that makes decisions rather than generating text, and demonstrates it classifying and prioritizing 500 emails. Riley explains Jev’s three output types—choice, score, and null—and contrasts its structured responses with traditional LLM outputs. He shares the company’s speed and cost benchmarks, discusses potential uses such as monitoring communications and filtering scams, and notes Jev’s smaller context window. The video also presents examples involving driving, trading, and browser agents, then describes ways to access the model.

Key points

Jev is presented as a decision-focused model that reads language but does not generate sentences.
The email app demonstrates Jev categorizing and prioritizing 500 emails in seconds.
Jev’s three output types are choice, score, and null: selecting a predefined option, assigning a value on a scale, or returning a probability.
Users define the categories, scoring scale, or question that Jev evaluates.
Unlike an LLM that generates and formats text, Jev returns structured results directly.
Type-Safe’s cited benchmarks put Jev at about 0.4 seconds and $0.0004 per decision, compared with about 10 seconds and 3 cents for a traditional LLM.
Potential applications discussed include sorting messages, flagging scams, and routing information to the right person.
The video gives Jev a 64,000-input-token context window and compares it with larger windows in other models.
Examples shown or discussed include driving decisions, trading, and completing browser tasks.
The video says Jev can be accessed through Type-Safe’s waitlist or Vercel AI Gateway.

Chapters

Start	Chapter	Summary
00:00	Introducing Jev	Riley introduces Jev as a fast, low-cost decision model and previews an email-classification demo.
01:32	Launch context and model routing	He shares the model’s launch description and demonstrates using Jev to select an appropriate model for different requests.
04:08	What Jev returns	Riley explains classification and walks through Jev’s choice, score, and null output types using email examples.
10:57	Structured outputs, speed, and cost	He compares Jev’s direct structured responses with LLM-generated JSON and cites Type-Safe’s speed and cost benchmarks.
13:04	Monitoring and filtering information	Riley describes possible monitoring uses, demonstrates scam detection, and discusses Jev’s context window.
16:11	Other use cases and access	The video covers examples involving driving, trading, and browser agents, then explains how to try Jev through Type-Safe or Vercel AI Gateway.

Quotes

It can’t even write a sentence. — 00:00

It reads language like an LLM, but it never writes any. — 04:40

It’s either a choice, a score, or a null. — 05:12

It doesn’t waste any tokens on the text portion. — 11:59

It’s booking a flight incredibly fast. — 18:46

Concepts and entities

Jev, TypeSafe AI, Diogo Almeida, Claude, Vercel AI Gateway, Codex, classificação, choice, score e null

Full transcript (original language)

00:00 We have huge news in the world of AI. A company called Type-safe just released a new type of model that’s very different from the other models I talk about regularly like GPT-6 Astra and Fable 5.1. This new model is called Jev and it’s not a chatbot. It can’t even write a sentence. It simply makes smart decisions way faster and way cheaper than any of the other models. In this video, I’m going to show you three examples of tools I built with this new

00:30 model Jev and I’m also going to explain the 10 things you need to know about this model before you start using it. So, I just had Claude create this app for me that uses Jev. Watch how fast Jev is going through 500 of my emails. And so, it is running through all my emails. It’s gone through 80, 90, 100, 110, 120, 130. And you can see here that it’s actually categorizing every single email. It’s deciding when we need to respond. There’s a lot of emails I need

01:02 to respond to today. I’m not that great at checking my email. And you can see here it’s going through all of these and it is done. It has gone through 500 out of 500 emails and then it creates this pie chart of all of the different types of emails that I’ve received. And you might be thinking, “Okay, Riley. That seems pretty cool. But like, what the hell is it?” And don’t worry. We are going to be talking about the 10 things that you need to know about Jev in order to start using it. The first thing I want to talk

01:32 about, however, is the launch video. So, a few days ago, Diogo Almeida, he said, “After co-inventing ChatGPT, I kept asking myself, why have superhuman chat models not led to AGI? I’ve spent the last 2 years in stealth building a new way to train models, RLCD, and a new type of frontier AI model that we are releasing today, Jev. It is 20 to 200 times faster, 40 to 400 times cheaper,

02:03 optimized for decisions. And we’ll get into what that means in just a second. Right before I filmed this video, I created an AI agent that has a model router that uses Jev. So, based on my input, it will use Jev to immediately decide which model it should use. And I created this in a single prompt using Claude. I’ll show you the prompt in just a second, but let me show you how this works. Hey, I’m Riley. Now, this is a very simple request. It should use a very cheap model for this. There’s no

02:34 need to use a really powerful model. Watch what happens. I’m going to hit send. And Jev immediately selected Nano, which is the smallest model. Let’s go up the stack a little bit. So, I’m going to refresh. I’m going to say, “Hey, I’m Riley. I want to build an app that uses API wrapper. Tell me the best way to do it.” Now, I don’t think this will be like frontier. I think this might be one level up. It might use a model

03:05 slightly smarter than Nano. And look at that. It actually selected using Claude Sonnet 5, which is this balanced, right? There’s tiny or nano, fast, balanced, and frontier. And I created this agent that can search the web, it can generate files, it can actually write code. I created this in a single prompt, and it’s pretty cool. And so, here it says, “Please” I’m going to say, “Please, can you generate all of the code for this. Make sure it’s

03:37 perfect.” Now, I don’t think it’s going to do the frontier. I actually haven’t gotten it to select frontier. But as you could see here, it is 95% sure that it should be this balanced model. And what Jev is made for is to make really fast, high-quality decisions for incredibly cheap. Okay, the first thing that I realized about Jev when I was talking to my friends about it, they said it’s really good for a classification. So, what does classification even mean? Classification

04:08 is a way of sorting an input into a few boxes that you’ve named ahead of time. Right? If we were to have this set up on our email, it basically sorts them into categories. It’s like a customer question, a sponsorship, or it’s spam. This model is really good at accurately and quick quickly sorting it into a predefined category. So, what is Type-Safe AI? And so, Type-Safe AI is the name of the company, Jev is the model. The guy who worked on ChatGPT left to start a company called

04:40 Type-Safe, and then they just released their model called Jev. So, is Jev an LLM? And so, they say, “No, it is not an LLM. It reads language like an LLM, but it never writes any.” Right? That’s That’s why there’s no output token cost because there is no output tokens. It just spits out a verdict and how sure it is. The LLM predicts the next word one word at a time or one token at a time. Jev will just respond with, “Yes, it is

05:12 91% confident in yes.” Or it is 90% confident it falls into this category. Okay, so this is actually the most important thing that you need to understand about Jev when you’re using it for the first time. And that is, how does it actually respond and what are the different types of responses? Let’s go over all three types of responses. So, this model will respond in three ways. It’s either a choice, a score, or a null. A choice is like multiple

05:44 choice, right? It fits into one of your predefined choices. That’s how it does categories. Now, there’s also a score. So, you can create a scale, and you get to decide what the scale is, and I’ll show you how that’s created. And then there’s also a null. How likely is this true? To illustrate the different types of outputs that Jev can have, I made some changes to my email app, which gives us full customizability over the inputs and the outputs. So, here we can

06:14 see that we can add a choice, we can add a score, or a null. Let’s start with the simplest one, which is a null, right? Where the answer is just a probability of yes. So, remember, we’re analyzing 500 of my emails. If we click null, we could say something like mentions a brand deal opportunity. And so then, since all of this information will be sent into Jev when it runs, and that’s how it predicts how confident it is in yes or the

06:44 probability of a yes, we want to make sure that we give good answers here. Does the email mention an opportunity for sponsorship in Riley’s content? So, it’s only going to be looking for emails that mention a brand deal opportunity. So, let’s go ahead and run this. And notice here, this is the null style output. Right? And so, most of them are very low, right? They just don’t mention anything, but some of them are green,

07:15 meaning there’s above a 50% chance that it mentions a brand deal opportunity. And so, we can scroll down. Here, it’s Riley Wick Symphony. Hey Riley, how are you? I’ve been following your AI content. And so, this one commands a brand deal opportunity. This one is 90% sure, and it went through all 500 of them. So, that is a null. Now, let’s go ahead and add another one, right? So, we can add another one, which is a choice. So, here we are going to add category of

07:48 email. And so, what is the category of the email received by Riley? And we could say brand deal. We have brand deal, subscription update, cold pitch, newsletter, and agent native. Here for this, I put very specific emails. And we’re going to call this agent native. And so, now we have five options. I’m going to hit save. Now, check this out. When I hit save, it added category. So,

08:19 now we have category of email here. So, let’s go ahead and run Jev again. And as you can see here, that is the second option. This is a null, which is like probability of a yes. And here is a category of email. And here is the confidence of its response. And we can see the category. And it did it immediately, right? Look at that. 500 emails in a matter of seconds, all analyzed. And now we have the category of email, which is

08:51 really cool. Okay, so now we have one more type of output that we can create. We’ve done a null, we’ve done choice for categories. Now, we can do score. So, we just added a score. And here you can create a scale. And so, I’m just going to go I think importance is actually pretty good. How important is it Riley personally sees email about given about Riley? And these are all variables. So, it’s just like, how important is it that Riley

09:22 personally sees email? And the data from the email will be placed in there. And then given about Riley. And so, about Riley is just this right here. And so, we’re creating a scale. Ignore, low, medium, high, critical, and we can add one more. We can call this like hyper. We’ll just call this insane. Needs response within 30 minutes or bad things happen.

09:54 So that again, this is a score and it’s scoring its importance and you get to decide as the person who’s using Jev the different scale. Ignore, low, medium, high, critical, insane. Okay. So now we’re going to save this and whenever we save it, the data gets reset and again, we have the null which is mentions a brand new opportunity. That is either yes, it’s a measuring the probability of yes, the category choosing between different options, or a score which will place it in the scale. So now we can run

10:25 it and let’s see the importance of each email. Look at how fast this goes. And it even has it on the scale right here, which is pretty cool. And just like that, I think that was 12, 13 seconds, we have all the emails analyzed. 500 were classified and here we have none of them were insane. None of them. Six were critical and we can actually click on critical and we can see the exact performance.

10:57 And so we can actually click directly on the category and there you go. It categorized all of those emails. So those are the different types of outputs that Jev can do. So there we go. The outputs are choice, score, and null. Now I want to talk about something a little bit different, which is couldn’t LLMs already do a structured output? And the answer to that question is yes, but it was really inefficient, right? Think about asking a chatbot to give you an

11:27 output and then it would actually need to format its output as JSON. And because Jev can’t write it all, structure isn’t part of the request. It’s the only thing it can return. This model is returned to respond in a structured fashion. Right? So, the LLM would need to generate text, format that text, and then parse the text into all of that information that shows up here, right? If we look at all of this, like an LLM has to do a lot of work to format it like this. Whereas this model that we

11:59 have right here, Jev automatically formats it in the exact format. And that’s why there’s only three different options. It will do it perfectly every single time. It will do it more efficiently because it doesn’t waste any tokens on the text portion. And the next question that a lot of people have about this model is like, how fast and how cheap is this model? And we can take a look at it here. So, based on their own benchmarks, it’s around 0.4 seconds and $0.0004

12:32 per decision. Very small cost. Whereas a traditional LLM would cost somewhere around 3 cents and take 10 seconds. I know 3 cents doesn’t sound like crazy, but if you’re doing tens of millions of requests per day, it starts to add up incredibly fast. And look at how much cheaper it is. So, it’s cheaper in cost per decision and the time per per decision is way different, right? 0.4 seconds versus 10 seconds.

13:04 Okay, so how am I excited to use it? And very simply, I’m going to monitor everything. The same way that I just set up my emails, right? I was able to monitor every email and categorize it and create a level of urgency, and you can basically monitor everything really quickly. You could do this about everything, not just your emails, but you could do your DMs across social for platforms, comments, sponsorship pitches, every single thing gets tagged and potentially routed to the correct person within the company. This will

13:34 allow me to organize all of the information that comes into my company. And so, that is one thing that I’m really excited about. And then, I was thinking at a societal level, right? Think about how much slop there is at the societal level. If we were to get models like Jev that are especially multimodal and can analyze videos, we could basically filter out all of the slop. Additionally, if this is used in email, it’ll filter out all of the cold emails, the scams. You could very easily

14:06 say, “Is this email a phishing scam?” And we can actually do this right now. We can actually create a new null. We create a new null, right? Is this a scam of any kind? Does this email look like a scam or something untrustworthy? We could actually save this. And then, I’m going to say, “Is this

14:36 scam email?” Save. Now, we have this new one. Is this a scam email? And we can run it, and it will check on how many of them are a scam. And look at this. We’re at 35, 39, 43, 44, 47, 51. 55. Out of 500 emails analyzed, 55 of them were scams. And it was recognized just

15:09 like that. Some of them are more confident in others, right? This is a 54% chance that this is a scam. 71% chance that this is a scam. But that’s a 10% of my email inbox, which is crazy. And so I think this may be how notifications work in the future, right? There should just be this filter that you have personalized for you, which filters out scam or cold emails, which I think is really cool. And what is the context window? So the context window is

15:40 smaller. Remember, all of this stuff is actually sent to the AI as it’s in its context. And remember, there’s only input tokens for this model. So the context window is 64,000 input tokens. So if you compare this to Astro, which is 1.5 million, this is actually only 6% of Astra or the best models in the world like Fable 5.1, which are around a million context window. This context window is only 6% of that. So it’s much

16:11 smaller. I wonder if they’re going to create a bigger one so you can add in more context about your business as it’s doing the classification, but that is the context window. Okay, and finally, how are other people using this model? Let’s take a look. So here’s Justin Schroeder on Twitter. This is very interesting. I’m going to turn this up to 1.25 speed, and let’s watch this video. >> Okay, this new Jed model is really something else. It’s different than the other ones because it’s not an LLM, it’s basically a classifier. It’s a fancy classifier, but it’s a general purpose

16:42 classifier. And so it’s able to make decisions that are pretty good, but you have to give it the options that it’s going to take. So here I was able to recreate Tesla autopilot in basically no time at all. I’m not driving this, it’s making its own choices about where to go. You basically give it the tree of options, and >> Remember, we talked about how you have to actually give it the tree of options. So it created a just like the categories or a choice, it has predefined choices, which is probably continue going straight, turn left, turn right,

17:12 straighten out. I don’t know how many choices he had, but he was able to at any given point or in certain intervals, the Jev model that’s running in his application is deciding which option to take based on all of the data around it. >> Then it’s able to decide. So, like it’s reading that there’s a red light there right now and that it needs to stop for it. It knows about the pedestrians. >> Okay, so this guy, Jared, is actually using it in real time. It’s analyzing the stocks and it’s determining whether it is a buy or sell and it has the

17:44 confidence and it’s actually making trades. And you can actually see the demo here at jevtrader.vercel.app. And this is really cool. And this will be used or models like this will be used to do trading or other gambling nonsense. It’s just a perfect model for it. Very fast decisions based on a set of inputs. And because trading is either buy, sell, or hold, right? It’s very simple set of outputs. You want something smart and fast and cheap. Cuz

18:15 you want it to run over and over and over again. You basically want this to run every second. And so, that’s what makes it a really good for finance use cases like trading. And so, the last use case I want to talk about is browser use and browser agents. So, look at this. Because this model is so fast and every frame on your browser is basically a set input, this model Jev is able to move so much faster than if it’s powered by an LLM. Check this out. So, it’s literally filling in the

18:46 browser. It’s booking a flight incredibly fast. And this is Jev. And so, it only took around 7 seconds to get through this screen here when booking a flight. And in order to use it, there’s actually a couple ways that you can use it. You can go to Type Safe and try and get off the waitlist. I was lucky enough to get access pretty early. So, you can get on the waitlist at typesafe.ai. But also the model itself is on the Vercel AI Gateway. You basically want to

19:17 go to Vercel, and then down here you have your AI Gateway, and you want to get your API key for this AI Gateway, because this model, Jev, is actually on the AI Gateway. So, if you get the AI Gateway key, you can literally go to Claude or Codex. I normally use Codex. I’m just out of credits on Codex, and you can just say, “Hey, I want you to create an app that uses Jev, and this app, here is my Vercel AI Gateway key, use Jev, look up the docs.

19:49 I want you to use Jev and create an app with Jev. It’s created by Type Safe.” And this will allow you to create an app. Your AI can go off and learn about Jev, and it will create whatever app you can think of. So, anyway, go out there, test this model. Let me know in the comments how you use it. What apps are you creating with Jev? What are you most excited about? Or is this super overhyped? Right? Am I overhyping this? Please let me know in the comments, and I’ll see you here for the next video.