Jev: The New AI Model That's Breaking The Internet (Full Tutorial) transcript

Yesterday, a completely new kind of AI model was released that's 20 to 200 times faster and 40 to 400 times cheaper than other frontier AI models. It's called Jeff and it's actually a completely different kind of model that's trained in a different way from an LLM, which of course is the type of language model we use with Chad or Claude. So, in this video, I want to explain to you exactly what Jeff is, how to start using it, and I will be building three example projects to show you exactly what this model unlocks and how powerful it is.

So, let's dive in. All right, so this is probably the best graphic I found that explains what Jeff is. So, if you think about how currently LLMs work, if you have your app that is asking a question, which is, is this invoice fraud? And then uh the LLM in this case would be basically answering in text form, right? So it would say based on the line items and the vendor history which was passed here inside of the context, this invoice appears to be legitimate, right?

So this could be an answer by an LLM. And the thing here is it the LLM basically writes a sentence one token at a time. And you can see in this example how much time this took, 8.5 seconds. So it took a lot of time to evaluate this question. Okay. Now, how does this look like when Jeff answers the question? So, same question here. Is this invoice fraud? The difference here is that the answer is actually a classification.

So, you can see here there's this category which is fraud. This is the the first option basically. There's clean and then there's review which are different ways to classify this invoice, right? And then you can see that it gives you a probability here that this invoice is clean. And the probability here in this example is 88%. So it's very likely that this invoice was clean. And the main difference here, as you can see, is it does not write text.

The output is not text. It basically points at one of your options that you will have to predefine. But it does this in a much faster way. So the way to think about it is that LLMs generate answers while Jeff actually gives you probabilities which helps you make decisions. So okay you might be asking okay so what like what does this really enable then? Well, the thing is if you think about it, software is actually full of these little decisions which are also known as if statements.

And uh ultimately, if you think about the software, it's basically just a series of if this then that happens. And if you know this new thing happens, then you should like route it here. And you know, if this other new thing happens, then you should you know, escalate it to a human for example. Right? This is basically how software works. Okay. So, let's give you a couple of examples of what this can look like. And we'll be building more examples later in this video as well.

So, in this example, you see here, this is a game basically, right? The input is the environment of the game. And this character has a couple of options. It can move left, it can move right, it can move forward, it can shoot. So, these are the actions that it can do. And Jeff is able to control these actions based on these inputs in a super fast way. And so it's able to control this character in this game, which an LLM would just not be able to do because it's not fast enough.

So to summarize, Jeff can pick an action, classify, score and rank, route, and all of that. It can do it at 100x the speed, but it cannot write a sentence. It cannot explain itself. It cannot write code, and it cannot reason step by step. And so it's basically giving up writing in order to get the speed which is the whole trade. So the way you can think about it is that you can use Jeff in combination with a GBT and Jeff would decide what needs to happen and the LLM can then reason or generate when deeper intelligence is needed and that actually opens up a pretty interesting category of software.

So let me give you a sneak peek now with a couple of examples. All right, the first thing we'll need to do before we can start building is go get an API key. So, uh, go to typesafe.ai, their website here, and then if you scroll down, you'll see here, join weight list. So, right now, there's still a wait list, and they're letting some people in. Um, I'm lucky enough to to have gotten in early, and I'm assuming they will let more people in over the next few days, but for now, yeah, just join the wait list, and then once you have access, you uh will be able to log into the console here.

And it's quite cool. they have like this little playground where you can kind of go in and um try out a couple of things here just to understand better like what this model is and what it does and you know feel free to go play around with that. Uh we won't do that now. All we really need is an API key. So just go here to the API keys tab and then you can create a new key here and then just go ahead and save your key somewhere in a local file.

So in your local env file and then what I did here is I opened up cursor which is the application I use to code and I created a new folder here. I just called it Jeff and the first prompt was this. So I just said read the documentation completely and save a compressed version. So yeah, I want to get the documentation of Jeff fully compressed into my project just so that it's able to like know everything about the project and it can, you know, do things for me and and so that it doesn't need to like reference the documentation all the time and and go back into the browser to to look at stuff.

So yeah, I said uh read the documentation, compress it, save it locally because we will be working with this model inside of this project and I want you to know everything about it so that we can work with it efficiently with the API. And then you would also want to tell it where your API key is saved just so it knows and so it knows where the key is and can access it. Okay. And once you have that, you're ready to build something that can then utilize Jeff in the app that you're building.

Okay. For the first example, I want to build a voice controlled web browser. So, let's write the prompt here. I want you to build an app um using the Jeff API. It should be a web app uh where I can record or I can speak into it. automatically transcribes what I say and controls the web browser for me. So I can say for example, open this website, click on this link, etc. And the browser just does all of that in real time.

Okay. Okay, this is done. So let's check it out. The dashboard control page is here. Um, we can let's put it to the side. And then it also opened up this browser window here which we will put here. And I guess now we can start trying this out. So I can click here start mic and then it should be recording my voice. Okay. Go to wikipedia.org. Okay. It's working. Okay. Click on the first link. Okay. Click on the a fairerryy syncs link.

Nice. Scroll down the page a little bit. Scroll down a bit more. Click on the Matsuyama Kokura fairy link. Okay, awesome. Opens the page in Japanese now. Okay, go back in the browser. Nice. It went back. Amazing. Okay, I'm going to stop the mic here, but you can see kind of from this control panel um a little bit what's happening. So, basically my my voice is being transcribed here in real time. And then it's kind of like recording these commands.

So, okay, click on the very syncs link. And then, you know, I'm guessing the LLM is doing some of the work here as well, but then um Jeff is likely like, you know, taking all of the possibilities on that page and kind of giving, um, the LLM a ranking of which link I meant or which action I meant. And because it's able to do it so fast, um, it's able to do this basically in real time. So, let's actually go here and, um, I'm guessing the AI will be able to explain it better than me.

Can you explain in very simple terms um how this actually works? Okay, so here we go. So think of it in in three parts that passes a note down the line many times a second. So your voice becomes text while you're still talking. The dashboard page in Chrome listens to your microphone in terms of speech and text. Okay, that makes sense. And then the next step is Jeff answers a quiz about that text. Okay. Um each time a new fragment arrives, the node server looks at the controlled browser window.

So it looks at what's in the browser, makes a short list of what's on the page, okay? Like up to 100 things like there's a link which says new, there's a button which says search search and it sends that list plus your words to Jeff. Okay, with a fixed set of multiplechoice and yes and no questions like what does the user want like do I want to navigate? Do I want to search, click, type and so on. Which element on the page do they mean?

Which website are they talking about? Is the sentence finished yet? Um, is the user even talking to the browser to someone in the room? Okay, interesting. Um, and would this action buy, delete, or send something? Okay, cool. And after that, then plain code decides and acts. So, the server has a handful of if statements with thresholds. If is this a command uh is below 0.5, ignore it. Um, so these are the the probability that are basically returned.

If it's under 0.5, ignore it. And if is the sentence finished is below 0.6, six, wait for more words and so on. Okay, so it has like a bunch of rules and based on the probabilities that it it's it's getting back, it's making those decisions and like acting on it basically. And all of that is happening in real time. And so the thing here is that if an LLM were to make this uh decision, it would take a lot longer to actually arrive at that decision, right?

Because it needs to reason through the steps. It would need to like look at everything that's there and then kind of reason through it. Whereas Jeff is just it gets all of that data and then it can make very fast decisions on what probability is it that this button should be clicked and then it just goes and and clicks that button. Okay, so this was pretty cool to be honest and actually when I was trying this out earlier it was even faster and I think it just came down to my internet.

My internet right now is a bit slower than before. Like earlier it was really just instant. Like I said something and it just went instant. And in the end when I said um you can actually check this out on the recording I did on my Twitter. Um when I said go back, it went back before I even finished my sentence, which was actually which was pretty crazy. So you know, you can see how fast it actually is. All right, let's do another example.

So I'm going to paste this prompt here and then explain what I want to do. So I want to build an improved Claudia memory system. And I'll explain what that is. Um, but basically I say look into my memory system in the Claudia folder. So Claudia is like my personal OS. It's basically like a a folder where I have all of my things stored and where I start all of my AI chats from. Um, and it has a bunch of memory about me and about the things that I've done.

So I want it to come up with ways to improve my memory system using Jeff build the improvements and build a dashboard to be able to demo exactly what improved and see the improvements. Okay. So um just to give a bit more context, my the way my Claudia OS works is, you know, it's essentially a folder which has a couple of subfolders. And one of those subfolders is this memory folder which has a bunch of daily memory files where whenever I chat with my AI from inside of this folder, it kind of saves what I've been chatting about.

And so this kind of builds this like knowledge base. And all of these other folders here are are things that I've built over time. So it contains a lot of memory. Now the problem with that is if I go here and start a new chat and ask something about it. So let's say I ask it like hey um what did we decide last month about the CRM or something like that, right? It would need to like go and search all of these files to try and figure out what the right answer to this question is.

And so I want to build something with Jeff here to see how we can improve the system because if we have Jeff here uh that's working in the background, we can probably retrieve the memory in a much faster way and we can also do a better job in actually saving the memory. Okay, here's what it built. Let's have a look at that. Okay, so again it's this dashboard here and there are these tabs. The first one says recall. So this is probably where we can ask question and it recalls memory and it says here there's you know we can type in our question here.

There are some examples that we can select which are questions that we can just use. So I can just click one and say and the question here is what's the current offer positioning. So now it's doing the recall. It's kind of waiting and asking Jeff. Okay. So now it did the recall and it returned what you can see here. So um it says 2756 tokens versus 13,000. So this request took almost 80% fewer tokens because we're using Jeff.

And it says here the cost of this recall was 0.297. Okay. And um it answers the question. So it was able to answer the question. Okay. I asked for a quick explanation here. So the way it was before Claudia's memory is a folder of markdown files. And the problem is that it's very inefficient the way the LLM is doing it. So it's basically when I ask a question, it's like trying to guess which file the answer is in based on the title of the file.

So it's, you know, doing a search for like keywords and file names basically. And then it's reading the entire file to see if the answer is actually inside of that file. And then yeah, it's basically hoping that it's right, which is, you know, pretty bad. And if it's writing memory, it's actually even worse. So when the agent learns something new, it should append something but it will never really know which file it should actually append it to.

And usually it will just I guess append it to the daily memory file. Yeah. So these are the problems. Okay. So how does it now work with the new system that uh now includes Jeff. So Jeff doesn't write text. You give it some state which is a list of files, a list of sections, a new bullet, and a batch of small typed questions. Yes or no. pick one score. Okay, so these are like kind of the criteria and it answers all of them in one request in a few hundred milliseconds with probabilities.

Okay, so it's a judgment engine, not a writer. And the code does the counting, chunking, and diffing. And Jeff only makes the small semantic calls. So the way I understand it is with this new system that is using Jeff, it's just able to much more easily find the right place where the memory is and it's kind of like doing this search like in parallel and get getting like all of these data points and then it's able to pinpoint the right file where the memory is located much more efficiently and much faster.

And so if we go back to the dashboard here, we can try out a couple of other questions. So what broke between the CRM and the transactional email provider? So this is a very specific question which you know relates to something that I've done within my OS and it would need to like search for the answer for quite a long time because you know it would need to like search through all of the files basically or like all of the daily memory files maybe.

So in this case it came back and it said 293 tokens versus 13,000. So, 98% fewer tokens than it would normally need. And the cost also minimal here. And the question was answered. Okay, pretty cool. Um, what about this question? So, what is Morris's favorite pizza topping? The thing is, I'm sure that I've never actually talked about this. So, this the answer to this question should not be inside of my OS, inside of the memory files.

And you can see here, uh, it is missing. So, you know, um, does the memory answer this? No. And for that reason, actually zero tokens were used. Um, which is 100% fewer tokens because, you know, it didn't even have to go and search the files for this memory. So, it it just knew that it doesn't exist, which is pretty incredible. So, this is obviously just an initial prototype, and I'm sure there, you know, you can still improve a lot about it, but it's definitely a very interesting start and I think already an improvement to my existing system.

All right. So for my last example, I wanted to build something that helps me predict whether a YouTube topic is going to do well or not. And this is the dashboard here that it built. So I basically told it that it should uh like fetch a bunch of YouTube data. And it fetched like, you know, you can see here 600 videos in my niche across 15 different channels. And it crunched all of that data. And you can see like some of the analytics of you know the the data here.

I don't want to go too much into detail. But if I click into this tab here, it actually also gave me like a couple of interesting things here around some like like fe it calls it feature importance. So this one here for example the duration minutes how much so basically it's answering the question of how much does the duration of a YouTube video determine the success of it. And you can see the duration. So the the longer the duration, the more successful the video is, which makes a lot of sense, right?

So this is kind of what we're seeing on YouTube. Also, live stream event seems to determine whether a video does well or not, which also makes sense. They're pushing lives right now. Whether it's a course or a training determines that. So it's quite highly ranked. And okay, so so all of this is is pretty interesting data. Now, here is the part that actually gets useful. So, this is a score my title. And the way it works is I can just type in my the title that I'm thinking about.

So, let's say I'm thinking about the title for my for the chat GBT course video. The only chat GBT work and codeex course you need in 2026. And then we'll do like 2 hours. And then we can describe the concept here. a creator pointing at a whiteboard with the curriculum on it. We can put in the planned length of the video here. So we can put it as if it's going to be 2 hours. Let's put 120 minutes. And yeah, then we can say score with Jeff.

Okay. So it will come back with a score and you can see here the score it's it's predicting a breakout based on this. So because it's a course training, it's you know has very high likelihood that this is this is going to do well. So all of these indicators here would basically ind would basically push it towards doing well and these indicators here would like push it towards doing not so well. So let's try a different one.

Let's just try like a super simple one like what is Jeff and then we'll the thumbnail will say Jeff is insane and length of the video will be 20 minutes. Okay. So here it said it's going to be 0.35. So it's going to be an underperformer. If it's below 0.5, it's going to be an underperformer. What we can do here as well is here we can actually type in the topic for the next video. So ID8, so this is the ID8 feature and it generates featuriz ranks and sanity checks.

So okay, an LLM writes candidate titles and thumbnail concepts. Jeff featurizes each one. The model ranks them and the final Jeff choice over top five asks which viewer would click and which is the most honest. Okay. And so let's just type in the topic of the next video which is Jeff tutorial and examples. And then we can select like how many candidates we want. So let's leave it at 15. We click generate and rank. And then now we can see here the LLM is now writing the title ideas and thumbnail ideas.

And then Jeff will do like a featurizing and ranking and a sanity pass. So let's wait and see what it comes up with. Okay. So it came up with a couple of things here. So, first of all, here it says Jeff's pick to click Jeff tutorial for beginners. Build your first AI agent. Okay, so it's it's basically the one that's ranked as number one here. Jeff tutorial build an AI research agent step by step and the drivers course or training offer signal clarif clarity and then thumbnail high contrast.

Okay. And I'm guessing also because it's, you know, I saw somewhere that it it's good when it's like specific. So, this is like spec very specific tutorial. So maybe that's the reason that it chose this. And then it has like these these other suggestions. So it made 15 suggestions, right? The LLM made 15 suggestions and then Jeff ranked them by which one would probably do the best. And then it says on in 15th position, I tried Jeff for seven days what it can actually do.

Okay, interesting. I I don't know if I agree so much with these. I guess it's very hard to tell. But yeah, this was I guess Jeff's ranking. I do think this score my title feature is super useful. So, I might be using that. But yeah, overall pretty cool. All right, that's it for this video. I hope it was helpful. I find this new technology really interesting. It was definitely just a start for me. I will be experimenting more with it and inside of my school community.

I will be doing a couple of live sessions as well over the next week and to work together with other business owners to see how this can be implemented in their business and how it can be useful. So, if you want to join those, definitely come check out my school community. I'll put a link down below. And otherwise, hope to see you in the next video.