Jev by TypeSafe Explained: Pricing, Benchmarks, and Claude Code

By Beau Johnson··10 min read

Quick answer

Jev is TypeSafe's System One model: you send it a state plus typed questions and it returns a choice, a score, or a probability instead of text. I'd keep Claude Code and Opus for planning and building, and put Jev on the small yes or no calls inside the app.

Jev is a new model from TypeSafe that never writes a sentence. You give it some state and a few typed questions, and it hands back a choice, a score, or a probability. In this video I break down how it works, TypeSafe's numbers, where I'd use it next to Claude Code, and the catches. It's for anyone building apps or AI agents who is tired of asking a big model for JSON and hoping it parses. I did not test Jev myself, so every speed, cost, and accuracy number here is TypeSafe's or a builder's, and I say whose.

What I cover in this video

  • 0:46 Who built Jev and what TypeSafe means by a System One model
  • 3:02 What Jev sends back: the four question types and the example from their docs
  • 5:18 Why it's fast and cheap, with TypeSafe's speed and price claims
  • 7:35 Where it fits in your app: route, rank, moderate, extract, verify
  • 9:08 The Claude Code pattern and the official plugin
  • 10:39 Where I wouldn't put it, and how I'd start with one if statement
  • 11:24 The catches, including what TypeSafe's own benchmark says
  • 12:55 The classifier criticism and the three layer stack I think we're heading toward

What Jev is and what it sends back

TypeSafe came out of stealth on September 15, 2026. The founder and CEO is Diogo Almeida, a former OpenAI researcher who co-invented RLHF, the training method behind ChatGPT. Jev launched with a $40 million seed round led by DCVC.

TypeSafe calls Jev a System One model, after Daniel Kahneman's book Thinking, Fast and Slow. System One is your fast brain. You look at a face and know it's angry. System Two is your slow brain, the one that has to work out 17 times 24. Every chatbot is a System Two tool. It reasons and writes one word at a time, which is great for a plan or a big chunk of code. But a lot of questions inside an app are System One questions. Is this ticket urgent? Which team should get it? Is this command safe to run? Theo, as quoted by DigitalOcean, gave a good rule of thumb: "If a human can decide in under 10 seconds, this model's probably good for it."

One call to Jev has two parts: the state (text, JSON, or an image) and a set of questions you define. Every question has a type, and there are four:

  • Choice picks one option from a list you give it, up to 255 options.
  • Score puts something on a scale you write, like calm, frustrated, or very angry.
  • Noul is a number from 0 to 1 for how likely a statement is to be true.
  • Box finds where something is in an image. It came with Jev 1.14 in October.

The example in TypeSafe's quick start docs is a support ticket saying an API started returning 500 errors and orders can't be processed. Three questions go in: which team should handle it, how frustrated is the customer, and is it urgent. Three values come back: department technical with a probability of 1.0, frustration 0.67, urgent 0.99. There's no paragraph and nothing to parse. Those are their example results, not a run of mine.

TypeSafe trains Jev with a method they call RLCD, reinforcement learning for calibrated decisions. Calibrated means that across a big pile of answers, the ones it gives 0.8 should come true about eight times out of ten. Their docs say this does not guarantee any single answer is right. Their homepage says zero hallucinations, and what that really means is Jev can't answer outside the options you gave it. It can still pick the wrong option and be confident about it.

Speed and price, by TypeSafe's numbers

A chatbot writes token by token, and every token waits on the one before it. TypeSafe says Jev makes all its answers at once, in parallel, and that adding questions barely changes the response time. Their claim is 70 to 500 milliseconds end to end, with most calls around a tenth of a second. The launch post says 40 to 200 times faster on the narrow kind of question it's built for.

Their claims don't match each other, though. Diogo's post on X said 20 to 200 times faster and 40 to 400 times cheaper. The homepage says 193.6 times faster and 444.6 times cheaper. TypeSafe itself says those are on the higher end of real world gains, and that their evals are generally run from their laptops on the West Coast.

The list price is $0.042 per million input tokens, and output is free. Right next to that they wrote, "We can't prove it isn't subsidized."

A few builder reports: in a case study on TypeSafe's blog, Jack and Jill swapped out Gemini 3.1 Flash Lite at one step of their pipeline and their cost per thousand candidates went from about 75 cents to about 9. TechCrunch reported that Vercel got answers 5 to 18 times faster on a command safety checker. On October 9, TypeSafe says it raised $870 million at a $7.5 billion valuation, led by a16z.

Where it fits in your app and next to Claude Code

The best line on this comes from someone in developer relations at TypeSafe: "Jev makes judgments. Code makes decisions." Your code owns the workflow, and Jev answers the fuzzy if statements. Their docs keep coming back to five jobs: route, rank, moderate, extract, and verify.

Their bug triage pattern shows why the probabilities matter. If Jev's confidence is under 0.5, the ticket goes to a person. If it's confident, the severity score decides between backlog, this sprint, or paging whoever is on call. When something goes wrong, you change a number in your code instead of rewriting a prompt.

In my reselling business we sell pre-owned Lululemon live on Whatnot and TikTok Shop, and chat moves fast during a show. Is this a sizing question, a shipping question, or a problem with an order? That's one Choice with three options, and the low confidence ones go to a person on my team. I haven't built this yet.

For Claude Code, TypeSafe's own docs say Jev is not a drop-in replacement for the model behind Claude Code, Cursor, or any coding agent. What exists is an official Claude Code plugin, which I have installed. It teaches Claude Code how to write code that calls Jev. Claude Code does the building, and the app it builds makes the fast calls.

My take, and it's mine, not theirs: Opus is the slow brain that plans and writes the code. Jev is the reflexes. Inside an agent there are thousands of tiny forks, like which tool to call or which skill to load. TypeSafe has a test that points this way. They put two Jev calls in front of a Claude Haiku 4.5 agent picking at most one skill out of 194. Over 452 requests, wrong skill loads dropped from 15.7% to 7.9%, and loading a skill when nothing fit dropped from 14% to 5.2%. It's their test and their setup.

One place I wouldn't put it comes from DigitalOcean: don't use Jev to rewrite or compact your agent's context in the middle of a session, because you throw away the warm prompt cache.

If you want to try it, find the one if statement in your app that keeps breaking, the one where a model returns JSON and messes it up every so often. Ask Claude Code, with the TypeSafe skill, to swap it for a Choice with a confidence threshold and log every miss.

The catches

TypeSafe's own benchmark tested four workflows written by their own team, and they say some bias could exist. Accuracy there means agreeing with labels from GPT-6 Astra and Claude Fable. Jev scored 67.8% and GPT-5.6 Terra scored 67.9%, at about four hundredths of a cent a case for Jev versus about 3 cents for Terra. GPT-5.6 Sol scored 74.1% and Claude Opus 5 scored 73.1%, so the bigger models still beat it by five or six points. DataCamp noted that no large scale independent reproduction has surfaced yet.

TypeSafe also has a page on model jaggedness, which I respect. Jev is not a calculator. It struggles with counting and comparing dates. It gets worse when you stuff the state with things that don't matter. Text inside the state can steer it, because it doesn't treat that text as hostile by default. And it leans toward whichever option you list first, so order your options on purpose.

It's also a black box. TypeSafe hasn't said what the architecture is, so you get a number without a reason. My favorite comment under one of the big Jev videos asked if everyone just collectively remembered that rerankers and classifiers exist. Fair. I think the honest answer is yes, it's a classifier, except you don't have to train it. You write the options in plain English.

Key takeaways

  • Jev takes a state plus typed questions (Choice, Score, Noul, Box) and returns values your code can use directly, with no text to parse.
  • It can't answer outside your options, but it can pick the wrong one with confidence. Use thresholds and send low confidence calls to a person or a bigger model.
  • Every speed, cost, and accuracy number so far comes from TypeSafe or builders. On TypeSafe's own evals Jev ties GPT-5.6 Terra and trails GPT-5.6 Sol and Claude Opus 5.
  • Jev doesn't replace the model behind Claude Code. The plugin teaches Claude Code to build apps that call Jev.
  • The stack I see coming is three layers: a big model to think and plan, a fast System One model for the reflexes, and plain code holding the rules and thresholds.

FAQ

What is Jev from TypeSafe?

Jev is what TypeSafe calls a System One model. You send it a state (text, JSON, or images) plus typed questions, and it returns a choice, a score, a 0 to 1 probability, or a box in an image instead of written text.

How much does Jev cost?

TypeSafe's list price is $0.042 per million input tokens, and output is free. TypeSafe's own note next to the price says, "We can't prove it isn't subsidized."

Can Jev replace the model behind Claude Code?

No. TypeSafe's docs say Jev is not a drop-in replacement for the model behind Claude Code, Cursor, or any coding agent. Their official Claude Code plugin teaches Claude Code to write code that calls Jev inside the app you're building.

How accurate is Jev compared to bigger models?

On TypeSafe's own workflow evals, Jev scored 67.8%, about tied with GPT-5.6 Terra at 67.9%, while GPT-5.6 Sol scored 74.1% and Claude Opus 5 scored 73.1%. The four workflows were written by TypeSafe's team, and no large independent reproduction has surfaced yet.

Chapters

  1. 0:00An AI that won't write a sentence
  2. 0:34Fast brain, slow brain
  3. 2:25Night Crew Studio
  4. 2:48What Jev actually sends back
  5. 5:19Why it's so fast and cheap (their numbers)
  6. 7:27Where it fits in your app
  7. 9:03The Claude Code pattern
  8. 11:07The catches
  9. 13:20Big brain, fast reflexes

Transcript

Read the full transcript

0:00an ex open AAI researcher who helped invent the training behind chat GPT just built an AI that won't write you a single sentence in Typescape's own demo. GPT 5.6 Terra takes about 8 1/2 seconds and their model Jev about a tenth of a second and the output is free. But the speed isn't why builders are excited. what comes back is. So, in this video, we're breaking down how it works, their numbers, where it fits with Cloud Code, and the catches. I build with Claude Code daily, so I had to know. Let's jump right into it. So, on September 15th, a company called Typesafe came out of Stealth. The founder and CEO is Dio Almeida. He was a researcher at OpenAI, and he co-invented RLHF, which is the

0:46training method behind ChatGpt. After two years in stealth, he launched a new kind of model called Jev with a $40 million seed round led by DCVC. His launch post is sitting at over 40 million impressions as of this week, and TechCrunch reported their API briefly buckled because so many people showed up. So why would the guy who helped build the chatbot go build something that doesn't chat? The answer is in the name. Typesafe calls Jev a system one model and that comes from Daniel Conorman's book thinking fast and slow. System one is your fast brain. You look at a face and you know it's angry instantly. System two is your slow brain. 17 * 24. You can do it but you have to sit there and work it out. So

1:31every chatbot you use is a system 2 tool. It reasons, it writes, it explains itself one word at a time. And that's amazing when you need a plan or a big chunk of code. But think about how many questions inside an app are actually system one questions. Is this ticket urgent? Which team should get it? Is this command safe to run? So you don't need a paragraph for any of those. You need one answer right now. So Theo Brown put it simply as quoted by Digital Ocean. If a human can decide in under 10 seconds, this model's probably good for it. And the name Jev is a nod to William Stanley Jevans, the economist behind the Jevans paradox. When something gets cheaper, people end up using way more of it. So that's the bet. Make judgment calls so fast and cheap that you'd make

2:17thousands of them without thinking twice. So what does a model that doesn't write actually hand back to you? That's next. Blueprint, Clay Studio, Chalk Talk, Neon Noir, Retro Arcade. Every one of these came out of the same app. Night Cruise Studio has 14 looks built in. And if none of them fit your brand, you describe your own in plain words and it builds it. So you pick a look, you give it a topic, and it makes the whole short on your Mac on your own Claude plan. Nightcrew studio. Join at nightcrew.studio. So think about how you normally use an AI model inside of your code. It writes back text one token at a time. And if your code needs something it can use, you ask it to return JSON. And then you parse it, you validate it, and you hope

3:02it didn't add a friendly sentence at the top that breaks everything. I've been there many, many times. So, Jev does it the other way. You send it two things. First, the state, the stuff you want it to look at, some text, some JSON, or an image. Second, a set of questions you define, and every question has a type. There are four of them. A choice picks one option from a list you give it, up to 255 options. A score puts something on a scale you write, like calm, frustrated, or very angry. A nule is a number from 0 to one for how likely a statement is to be true. And a box finds where something is in an image, which came with Jev 1.14 in October. You can see it in Typesafe's quick start docs. The ticket says their API started

3:48returning 500 errors 20 minutes ago, and they can't process any orders. Three questions go in. Which team should handle this? How frustrated is the customer? Is this urgent? So, their example output comes back as three values. Department technical with a probability of 1.0. Frustration 0.67 on their 0 to2 scale. Urgent 0.99. No paragraph, nothing to parse. In Typescript, the answers type is literally billing, technical, or sales. And those are their example results from their docs, not a run of ours. So, here's how it actually works. Jev looks at the state in one go and then it answers every question in parallel, each one on its own, so no answer leaks into

4:33another. Typesafe says adding questions barely changes the response time. So what about those probabilities? Typesafe trains Jev with a method they call RLCD, reinforcement learning for calibrated decisions. Calibrated means that across a big pile of answers, the ones it gives 0.8 should come true about eight times out of 10. So their own docs say it does not guarantee any single answer is right. Okay, so this is the sneaky part. Their homepage says zero hallucinations. What that really means is Jev can't answer outside the options you gave it. If you list billing, technical, and sales, you will never get back pizza, but it can still pick the wrong one and it can be confident about it. Keep that in your back pocket because it matters

5:18later. So why is it so fast? A chatbot writes its answer token by token and every token waits on the one before it. So Jev doesn't write anything. Typesafe says it makes all its answers at once in parallel instead of one token at a time. Now their numbers and these are all theirs. Typesafe says 70 to 500 milliseconds end to end with most calls around a tenth of a second compared to 3 to 329 seconds for Frontier models. and their launch post claims 40 to 200 times faster on the narrow kind of question it's built for. But their claims don't even match each other. Do's own post on X said 20 to 200 times faster and 40 to 400 times cheaper. Their homepage says

6:05193.6 times faster and 444.6 times cheaper. And Typesafe itself says those are on the higher end of realworld gains. They also admit their evals are generally run from their laptops on the West Coast. Respect to them for writing that down, but take it for what you will. So then there's the price, and this part is just their price list. 4.2 cents per million input tokens. That's $42 per billion. And the output is free because there's barely any output to begin with. And right next to that, they wrote, "We can't prove it isn't subsidized." You do not see a company say that every day. So, what are customers seeing? Jack and Jill, in a case study on Typesafe's own blog, swapped out Gemini 3.1 flashlight at one

6:50step of their pipeline, and their cost per thousand candidates went from about 75 cents to about 9. Moritz Kreme built a voice controlled browser and says Jev comes back in about 300 milliseconds at 200ths of a cent per decision. And TechCrunch reported that Verscell got answers 5 to 18 times faster on a command safety checker. And the money followed. On October 9th, about three and a half weeks after launch, Typesafe says it raised $870 million at a $7.5 billion valuation led by Andre Horowitz. That's a lot of money for a model that won't talk to you. So where does it actually go in your app? Ali Labs, who works in developer relations at Typesafe, has the best line on this. Jev

7:35makes judgments. Code makes decisions. So your code owns the workflow. Jev just answers the fuzzy if statements and their docs keep coming back to the same handful of jobs. Route. Which Q model or tool should get this? Rank. Which file or passage matters most? Moderate. Is this okay to show? Extract. Which of the values your code already found is the right one? And verify. Does this answer actually match its source? So their bug triage pattern shows why the probabilities matter. If Jev's confidence is under 0.5, the ticket goes to a person. If it's confident, the severity score decides. Backlog, this sprint, or page, whoever's on call. When something goes wrong, you change a number in your code instead of rewriting

8:21a prompt and praying. So, here's how I'd use it in my reselling business. We sell pre-owned Lululemon live on Whatnot and Tik Tok Shop, and the chat moves fast during a show. Is this a sizing question, a shipping question, or a problem with an order? That's one choice with three options. And the low confidence ones go to a person on my team. I haven't built this yet, but it's exactly the kind of question Jev is shaped for. So, builders are already doing stuff like this. Boyd made Jev plays Pokémon where Jev is the player and the chat moderator. Dev ran it on a live chat to pull out negative comments. And with moderation, tuning that threshold is the real work because a false positive means you just deleted a real fan. So now the part I care about most, Claude code. First, what it is

9:08not. Types safe's own docs say Jev is not a drop-in replacement for the model behind claude code, cursor, or any coding agent. So there's no setting that turns Claude code into a Jevp powered agent. What does exist is an official plugin. Typesafe ships a claude code plugin. Two commands to install and I have it installed right now. It teaches Claude Code how to write code that calls Jev. That way, Claude Code does the building and the app it builds makes the fast calls. So, here's my take and it's mine, not theirs. Opus is the slowb brain. It plans, it writes the code, it handles the hard reasoning. Jev is the reflexes inside an agent. There are thousands of tiny forks. Which tool do I call? Which skill do I load? Is this

9:53file even relevant? Did that step actually pass? So right now a lot of builders pay a Frontier model to answer every one of those yes or no questions. That's like hiring a surgeon to take your temperature. So Typesafe actually has a test that points this way. They put two Jev calls in front of a clawed haiku 4.5 agent to pick at most one skill out of 194. Over 452 requests, wrong skill loads dropped from 15.7% to 7.9. and loading a skill when nothing fit dropped from 14% to 5.2. So, it's their test and their setup, but it roughly haved the wrong loads. Now, flip it around because there's one place I wouldn't put it. Digital Ocean made a good point. Don't use Jev to rewrite or

10:39compact your agents context in the middle of a session because you throw away the warm prompt cache. Keep it at the forks, not inside the conversation. So, if you want to try this, here's how I'd start. Find the one if statement in your app that keeps breaking. The one where you ask a model to return JSON and it messes up every so often. So ask claud code with the type- safe skill to swap it for a choice with a confidence threshold and log every miss. One if statement. Don't overthink it. So now the catches, and there are real ones. Every performance number in this video so far came from Typesafe or from builders. Their own benchmark tested four workflows. things like security incidents, invoices, and customer service. Those workflows were written by

11:24their own team, and they say some bias could exist. And accuracy here means agreeing with answers from GPT6 Astra and Claude Fable. So on that test, Jev scored 67.8% and GPT 5.6 Terra scored 67.9. Basically a tie at about 400ths of a cent a case for Jev versus about 3 cents for Terra. But GPT 5.6 Soul scored 74.1 and Opus 5 scored 73.1. So the bigger models still beat it by five or six points. And Data Camp noted that no large-scale independent reproduction has surfaced yet. If a bigger model lands on the reference answer six more times out of every hundred, some jobs still need

12:09the bigger model. Remember that back pocket thing? Here it is. Jev can pick the wrong answer and still be confident about it. So, Typesafe has a page they call model jaggedness, which I respect. Jev is not a calculator. It struggles with counting and comparing dates. It gets worse when you stuff the state with things that don't matter. Text inside the state can steer it because it doesn't treat that text as hostile by default, and it leans toward whichever option you list first. So, order your options on purpose. So, it's also a black box. Typesafe hasn't said what the architecture is. Ben Tossel put it well as quoted by Digital Ocean. You get a number, not a reason. Test it before you trust it. And Theo called it roughly as intelligent as a switch statement. My

12:55favorite comment under one of the big Jev videos was this. Did everyone just collectively remember that rerankers and classifiers exist? I mean, fair. But I think the honest answer is yes. It's a classifier. Except you don't have to train it. You write the options in plain English and on narrow questions by their numbers, it lands right next to GPT 5.6 Terra. That's still useful. Can you agree? So, like I said at the start, the speed isn't the real story. I think the stack we're heading toward is three layers. A big model on top to think and plan. A fast system one model in the middle for the reflexes and plain code underneath holding the rules and the thresholds. When that ticket from earlier comes in, Jev says technical

13:40confidence is high and it gets routed. If confidence is low, it goes to a person or up to opus. So, will the big labs just build this into their own models? Maybe. But if your agent is paying a Frontier model to answer yes or no a thousand times a day, this is worth a weekend. So, I'm curious. What's the first yes or no call in your app you'd hand to something like Jev? And how sure would it need to be before you trusted it? Write it in the comments. And if this made Jev finally click for you, tap the like. That's how it gets passed along to more people building with agents. Have a blessed day.

Ready to start building with AI?

Join the Shipping Skool community free. Paid members get live bootcamp calls every week and weekly-updated courses.

Join Shipping Skool

Keep reading