Jev Is Not a Claude Killer. Here's What It's For

Author: Leon van Zyl · Watch on YouTube

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 Is Not a Claude Killer. Here’s What It’s For · Channel: Leon van Zyl · 16:10 · Watch on YouTube

Topics: AI agents, Software engineering with AI, AI models

Summary

The video argues that Jeff is not a replacement for frontier models like Claude: it is a fast, inexpensive model designed for narrow classification decisions, not reasoning or long-form answers. The presenter demonstrates using it with GitHub issues to assign issue categories and route work to the appropriate coding agent, including confidence scores and a comment showing the model’s input and response. He explains Jeff’s choice, score, and null task types, its deterministic response structure, and how to access it through TypeSafe or OpenRouter. The walkthrough finishes by connecting the issue-labeling workflow to a larger software factory that routes tasks to agent workflows.

Key points

Jeff is presented as a system-one model for quick decisions, not as a chatbot or a Claude replacement.
Its useful task types are choice, score, and null, which support classification, rating, and yes-or-no decisions.
The model returns a consistent, structured response with confidence scores that applications can use for routing or human review.
The presenter says Jeff is best suited to fast classification, while tasks requiring reasoning, accurate math, or science may need a frontier model.
The GitHub demo classifies issues as bugs, documentation changes, or enhancements and selects an appropriate coding agent.
The tutorial shows how to explore requests in the TypeSafe playground, create an API key, and add account credits.
The presenter says users can access Jeff through OpenRouter while TypeSafe has a waitlist.
Labels can route issues through a software factory, where agents handle bugs, features, or documentation using different workflows.

Chapters

Start	Chapter	Summary
00:00	What Jeff does in the GitHub demo	The presenter introduces Jeff as a fast classifier and demonstrates it assigning an issue category and coding agent in a GitHub project.
02:07	Jeff’s strengths and limitations	He distinguishes Jeff from frontier models and explains its choice, score, and null tasks, limited reasoning ability, and structured output.
05:48	Cost and access options	The presenter compares classification costs, introduces the video sponsor, and explains how to access Jeff through TypeSafe or OpenRouter.
08:29	Preparing the TypeSafe project	He explores the playground and response format, creates an API key, and prepares a GitHub repository and labels for the demo.
11:46	Building the issue-routing workflow	The presenter explains how labels route issues through a software factory, installs the TypeSafe agent skill, and asks a coding agent to implement the GitHub action.
14:00	Testing the workflow and next steps	He tests issue classification and agent routing, then shows how a separate repository uses labels to trigger a software factory.

Quotes

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

Jave is not a chatbot. — 03:08

This structure is deterministic. — 05:17

Jef is perfectly fine. — 05:48

Concepts and entities

Jev, TypeSafe AI, Claude, Codex, OpenRouter, GitHub Actions, software factory, Leon van Zyl

Full transcript (original language)

00:00 Jeff from TypeSafe AI is an incredible model, but it’s also being overhyped right now. I’ve seen too many videos calling this a Claude killer, and it’s not. It can’t even write a full sentence. But, there is one job it does better and faster than any LLM. And in this video, I’ll show you how to use it in a real project, not a demo. So, let me show you what we’ll build in this video, and you can apply everything you’ve learned here to apply Jeff to so many different use cases. This is one of my GitHub repos. This is simply a web

00:30 application with a 3D model of Claude. We’ve got this spooky mansion sitting back here, but we don’t have a facial expression showing that Claude is scared. So, let’s create this new issue, and within a second, we’ll see these labels change. We’ve got Agent Codex and Enhancement. So, what happened is when we created this issue, all of the contents, like the title and this description, was sent to Jeff. We then asked Jeff to do two things. First, we asked Jeff to assign a category. An issue can either be an enhancement,

01:02 documentation, or a bug. And Jeff correctly identified that this issue is actually an enhancement, which means it’s a new feature. This GitHub repo is hooked up to a software factory, and in the back end, I’ve got multiple agents in the fleet that consists out of Codex agents and Claude code agents. Depending on the type of work in this change, we should assign the correct agent. And for any 3D work, or any work that involves spatial reasoning, I’ll have to use Codex with GPT-6 Astra. That’s why Jeff identified Codex as the correct coding

01:35 agent. What’s also useful is we’ve got this comment showing exactly what we got back from Jeff. And for the category, Jeff was 100% sure this was a new feature, and for the agent routing, it was 100% sure this change should be passed to Codex. We can see some other useful information as well, like all the context that we sent over to Jeff, as well as Jave’s response. So, in this video, I am going to show you how you can set all of this up, and this will teach you how to use Jave across many different types of projects as well. You

02:07 do not have to use it within a GitHub repo only. You can apply it to games or whatever you want. And you probably saw in the intro that there’s currently a waiting list to join Type-Safe, but I will show you how you can get access to Jave right now without having to join this wait list. But first, what the heck is Jave? I’ve seen too many people compare this to the frontier models like Claude and Open AI, but it couldn’t be further from the truth. Jave is a system one model, whereas things like Claude and Open AI are system two models. But

02:38 you might be wondering, what is the actual difference? Well, system one models are actually super simple. They’re built to make really quick decisions and give you the responses cheaply and quickly as possible. This makes models like Jave perfect for classification work. Whereas system two models like the frontier models have reasoning and a lot more intelligence. This distinction is really important. Because Jave is so blazingly fast, it can’t do complex work. It can’t reason, and it’s really bad at things like

03:08 science and math. It’s also got a tiny context window of about 32,000 tokens. Jave is not a chatbot. You can’t interact with it the same way you can with Claude or Open AI. It’s really only good at three types of tasks. Choice, score, or null. For all of these, we can give Jave some kind of context about, you know, what the problem is or what we want it to do. But then we can either give it a list of choices to select from. For example, we could give it some context about a problem, and it needs to route it to something like billing,

03:40 technical, or sales. Or like with our GitHub repo, it should classify an issue as being a new feature, a bug, or a documentation change. We can also ask Jave to score something. So, we could give it a customer review and then ask it to give it a score of what’s this review? Calm, frustrated, or very angry. And then we’ve got null. This is almost like a boolean kind of decision. Like, is the statement true? And it will say either yes or no with a little bit of a confidence score. As you can see, none of these return full-blown sentences.

04:13 It’s really quick, rapid classification. And just to get a little bit technical for a second, this is what the actual request and response looks like from Jeff. In the request, we can specify the model like Jeff latest. We can give it some kind of context like this current state is something like help, my payouts have been failing for 3 days. You know, this is a typical comment from a user. And then we can ask it questions. So, for null, we could have something like is this urgent with a type of null with an instruction, does this convey

04:45 urgency? So, this section here will tell Jeff to kind of score this as a yes or no. Or we can get Jeff to select the department that this issue should be routed to. And of course, we’re using type choice here with instruction, which team should handle this? And all we’re doing is we’re giving it a couple of choices to select from. And of course, we can use a scoring type as well to set the frustration level. And the response from Jeff will look something like this. And this structure is deterministic. This means that you will always get this

05:17 consistent structure back when using Jeff. This means if you’re using code to reference this object or you’re mapping to it from something like N8N, you are always guaranteed that you will receive the same structure back. And one cool thing to note about the output structure is that you do get this confidence score back from Jeff as well. This is a score from 0 to 1, 1 meaning 100%. So, you could add some logic in your application to say, if the confidence score is less than 0.75, then let’s actually just pass it to

05:48 human review instead. Now, when you decide between using Jef or Claude to do classification work, it really does come down to costs. Look, if the decisions you need to make rely on, you know, the math being accurate or the science being accurate or needing reasoning effort, you might have no choice but to use something like Claude. But, if you just do quick classification work, Jef is perfectly fine. And I’ll just try to map out what a million classifications with Claude cost you for something like GitHub repos. So, if you had to do 1

06:19 million classifications, Jef would only cost you like $21, where cheaper models like, you know, Sonnet 5 would cost you about $1,500. And I don’t even want to mention something like Fable 5.1 at $7,500. So, for quick classification work like with GitHub repos or if you are building workflows or redirecting issues between different departments, Jef is definitely the way to go. Now, enough said, how can we actually use Jef? But, first, a quick

06:50 word from today’s sponsor, Decodr. When you ask an AI agent to pull something off a website, there’s a decent chance it will come back with nothing. Real websites simply won’t hand data over to something that’s not a real browser, and AI agents like Claude isn’t one. Or like in this example, this data is actually geo-restricted. If the agent had to do a request from Germany, this website won’t return any useful information. Decodr has a web scraping API with an MCP server in front of it. This means you can drop it into anything that speaks

07:21 MCP. Decodr provides rotating IPs, JavaScript rendering, and retries. You give it a website, you can even specify the geo-location, your agent will use their MCP server, and your agent will get back clean markdown or structured JSON. The web scraping API free plan gives you 2,000 credits and is valid for a full year. And no credit card is required. I’ll leave a link in the description of the video. And if you use code Leon van Sale, you’ll get 10% off your first paid plan. Thanks to Coda for sponsoring this video. Now, let’s get

07:55 back into it. In order to get access to Jef, you can go to TypeSauce.ai and log in to your account. Now, at the time of recording, you do have to join a waitlist. They actually removed the waitlist for a short period of time, but it seems to be back again. So, in order to skip the waitlist, what you can do is actually go to Open Router and just sign up for an account over there. Open Router does give you access to the latest version of Jef. For this tutorial, I will be using TypeSauce itself. But if you do want to follow along with Open Router, whenever I mention TypeSauce or the TypeSauce API

08:29 to the coding agent, you can just mention Jef within the Open Router API. So, from the TypeSauce AI dashboard, there’s a couple of things we have to keep in mind. When we go to playground, we can actually see exactly how Jef works. And as I mentioned earlier, you basically have three different options: null, score, or choice. Let’s click on one of these examples. And look at that, there’s that structure that you saw earlier. And we can also combine multiple different questions. So, it doesn’t just have to be null, it can also be scoring, it can also be choice. These can all be combined into a single

09:03 request. Now, we could just swap out these values for, you know, actual values. But if we run this, we get a response back as well, and we get an idea of what these responses are going to look like. And when we switch over to the JSON view, this will give us that technical structure that we can expect back every time we send this request. This structure is guaranteed. In order to use Jef, we will need to create an API key. So, what we have to do is go to API keys. Then, let’s create a new key. I’ll just call this tutorial. And now

09:37 we’ve got our API key. So, just copy this key and store it in a safe place. Please use your own key. I am going to delete this one after this recording. Now, because this is a paid service, we do have to add some credits onto our account. When I signed up, I actually got $5 of free credits. So, I assume that applies to everyone, and I actually haven’t even used any of it. These requests are so cheap. But, so all we need now is a GitHub repo to attach Jeff to. Now, you’re more than welcome to use my code, or you can use one of your

10:09 existing repos, or just push a new dummy repo to GitHub. It doesn’t matter. So, all you have to do is go to code, then copy this command over here. Then, we can open up our coding agent. I’ll just use Claude code. I’ll set this to Opus 5.5 and on high reasoning effort. Please clone this repo to the root of the project. And I’ll just paste in that GitHub URL. All right, now that we’ve copied all the files over, let’s create a new GitHub repo. So, I’ll just say,

10:39 “Go ahead and create a new private GitHub repo for this project.” Cool. So, our project is down GitHub. And what we want to do now is, whenever we create a new issue, we want the ability to assign very specific labels. Now, this is really fun. This is up to you. You can make it as complex as you want. So, I think I’m just going to keep it really simple for this demo. We already have a bunch of default labels like bug, documentation, and enhancements. We can also ask our agent to add custom labels as well. For instance, let’s say,

11:11 “Please add these labels to the GitHub repo.” And let’s say, “Claude running Fable.” Let’s say, “Codex running Astra.” And maybe “Claude running Haiku.” for very simple work. Now, when I refresh this repo and I go to labels, we can see the new labels over here. All right, what we want Jase to do when we create a new issue is classify this issue as being either a bug, documentation, or an enhancement, and it should also decide which agent to assign

11:46 this work to. In fact, if I’m confusing you a little bit on what we’re actually doing, I found this really cool diagram on Vercel’s page. This explains pretty much the workflow that we’re building now. This is the software factory that Vercel is actually using. And this is very similar to what we’re building. So, a human will create an issue, then there’s this identify type step where they call an LLM to identify the issue as being either a bug, a feature, or documentation. We could, in this step, also do additional things like assign

12:18 which type of agent we want to use in our agent swarm. And the reason we’re assigning these labels is when the software factory picks up that issue to actually process it, it’s going to route the issue down the correct flow. So, it’s going to look at the labels and say, “Okay, if I’m a bug, then I want an agent to actually reproduce the error, fix it, test it, and then create a pull request.” Or if it’s a new feature, analyze the feature, see if it’s aligned with the vision of the app, implement the feature, review it, and merge it. For documentation changes, it’s really simple. We can use a really cheap model

12:52 like Haiku to make the documentation change and then merge it. It’s a low-risk issue. Now, what I also like to do is to install the Type Safe agent skill. And this is the official skill from Type Safe AI, and this will teach your agent how to use Jase and their APIs. I’ll link to this GitHub repo in the free community as well. So, all you have to do is copy this URL, then let’s go back to your agent, and please install this skill in the project folder. And cool, this skill will now tell our agent how to actually use Jase.

13:25 So, guess what? All we have to do now is say the following. Whenever we add a new issue to this GitHub repo, Jave needs to be called via a GitHub action to do the following. One, label the issue as being an enhancement, bug, or documentation change. Two, assign an agent label like Claude Fable, Codex, Astra, or Claude Haiku. For the agents, advanced coding tasks should be assigned to Fable. Anything requiring spatial reasoning should use Astra like 3D animations, image generation, and Haiku will be used for any documentation changes. Add a

14:00 comment showing Jave’s input and response and the confidence score for each category. And then we can just pass it the type safe API key. And that’s it. I’m just going to send this message. All right, so I’m just asking Claude to push all of these changes to GitHub. Let’s give this a spin. Let’s go and create a new issue. I’ll just say add a new emotion and scared. Let’s create this. And cool, we got the response back from Jave. It assigned this as an enhancement and for the agent we’ll use Codex Astra. We also see this new comment by the way.

14:32 It was labeled as an enhancement with a confidence score of one, which means 100%. For the agent it selected Astra with a confidence score of 0.62. So, maybe the description was a little bit ambiguous. So, we could really decide how we want to deal with this. But either way, Astra or Fable would have been perfectly fine at doing this change. And here we can see the input that was passed to Jave and we can also see Jave’s response. And if you have a look at the tokens, this burnt like less than 800 tokens, which is nothing. Now,

15:05 if you want to take this a step further, you can hook this repo up to an actual software factory. Let me show you what it looks like on another repo. So, this is a repo for an RTS game and I created this issue just saying, you know, improve the visual all This change was assigned to Claude and it’s classified as an enhancement and I’ve set this label called ready. The ready label just turned into factory running and this means that one of the agents in my agent swarm is now actively working on this change. And once this

15:35 agent completes, it will create a pull request which I could review and merge back into this project. So, if you want to learn how to build a software factory, I’ll link to it in the description of this video. If you want to learn how to use coding agents effectively and build really cool stuff like software factories, then you might want to consider joining my school community, Agenty Labs. This will give you access to my Agenty coding masterclass, which contains hours of video showing you how to effectively use coding agents and build real projects. We also have live coffee sessions where you can ask me anything and we have weekly deep dive sessions as well. As a

16:10 matter of fact, this coming Thursday, we are doing a deep dive on JFAI. So, you might not want to miss that session. I’ll leave a link to Agenty Labs in the description of this video. Thank you so much for watching and I’ll see you in the next one. Bye-bye.