Over the last couple of weeks I’ve been playing with a new kind of model, and I have to say I haven’t been this excited about something in the AI space in a while. It’s called Jev, it’s built by TypeSafe AI, and they describe it as a “System One” model. I honestly think this is just the start…. I’m hoping to see a lot more models like this coming out soon, and for us developers that is super exciting, because it changes what we can build into our applications (and how much it costs us to do it!!).
So today I wanted to share what I found, with four small examples you can run yourself.
So what makes Jev different?
For those who know me, you know I love type safety. I’ve been a C# developer for most of my life (even though I must admit that’s changing lately!), so getting actual type safety from an AI API, instead of just a string of text, is just awesome !!! it’s really a direction that I hope to see more of.
Before we go any further, I want to be clear on one thing:
Jev is not a replacement for a full-blown LLM.
The way to think about it, an LLM is a massive jackhammer. It’s incredibly powerful, and we’ve got so used to having it around that we reach for it for everything, even the jobs where all we needed was a small hammer. Is this ticket about billing or a bug? Which context or tool should I load for the next agent? We’ve been answering all of those with an LLM call, not because it was the right tool, but because it was the only thing around that could read. And on top of that, what came back was a string, which for us developers can cause all sorts of problems: parsing it, validating it, and retrying when it comes back in the wrong shape. Jev is the small but effective hammer that fixes this, and not just because we finally get type safety. We get a bunch of other stuff too:
Types, not text: you send Jev some text and get back an actual typed response. No prompt begging for “valid JSON” or funky retry loop for when it adds a friendly paragraph before the JSON (we’ve all been there!). The TypeSafe documentation covers the full API and we’ll go through this in example 1 below.
Ask everything, pay only for input: Jev charges for what you send, not for what it answers: $42 per billion input tokens, and the output is free (Claude Sonnet 5, for comparison, is $2 per million input tokens and $10 per million output). And it answers all your questions in one pass, so 32 questions cost the same wait and about double the price of one.
Speed: about a quarter of a second per call in my runs, pretty much whatever I asked.
Confidence and consistency: every answer comes with a confidence, and in my tests that number actually meant something.
I see the real potential when you actually start mixing Jev with an LLM. Sometimes you do need the jackhammer to do the heavy lifting, and for everything around it, Jev makes the whole experience so much better: faster for your users, cheaper for you, and with confidence and consistency you can actually build on. We’ll check this out in example 4.
Alright, enough of the intro. Let’s get into the actual code.
All the code is on my GitHub, so if you’d like to follow along, open it up and read the article side by side. Each example runs with a single command.
Example 1: three ways to ask a question
To keep things fun, every example is set in the inbox of Crust Issues, a made up pizza shop that gets some interesting messages. Here’s the first one:
“I ordered a large margherita two hours ago. It arrived cold, somehow with pineapple on it, and the driver ate a slice in front of me. Honestly I’m a little impressed. I still want my money back though.”
Jev gives you three types of question, and you can mix them in the same call. These are the primitive types that Jev comes with today (hopefully more of these to come in the next releases of Jev)
Noul: a yes/no question. You get back a single number, the probability that the answer is yes, and that number is the confidence (0.5 means it has no idea, 0 or 1 means it’s sure).
Choice: pick exactly one option from a list you define. You get back the choice, a probability for every option, and a confidence.
Score: where something sits on an ordered scale you define. You get back a score (a decimal, so it can land between two levels), a probability for each level, and a confidence.
Here’s what that looks like in code:
result = ask(message, {
# Noul: a yes/no, answered as a probability
“driver_misbehaved”: Noul(instructions=”The delivery driver did something wrong”),
# Choice: pick one of the options you define
“wants”: Choice(instructions=”What does the customer want us to do”,
criteria={”refund”: “...”, “remake”: “...”,
“just_venting”: “...”, “praise”: “...”}),
# Score: where it sits on a scale you define
“anger”: Score(instructions=”How angry is the customer”,
criteria=[”Happy”, “Mildly annoyed”, “Properly annoyed”,
“Furious; writing a one-star review as we speak”]),
})And here’s what came back:
Noul driver_misbehaved: 0.97, so a very confident yes (no arguments there).
Choice wants: refund, with refund at 1.00 and every other option at 0.00.
Score anger: 1.77 on a scale from 0 (Happy) to 3 (Furious), with a confidence of 0.64.
That anger score is my favourite part. The customer is annoyed but also a bit impressed, and Jev picked up on that: 1.77 sits between “Mildly annoyed” (1) and “Properly annoyed” (2). All of this for 482 input tokens, $0.00002, in 343 milliseconds.
Example 2: ask everything, it costs (almost) nothing
This one surprised me the most. I took one customer review and asked Jev 1 question about it, then 2, 4, 8, 16 and finally 32, each time in a single call.
“Ordered the Vegan Volcano. It was brilliant but so spicy my cat left the room. Delivery took 55 minutes and the driver called me ‘chief’. Box was soggy. Would order again, but maybe with a fire extinguisher. 4 stars.”
32 times the questions, the same wait, and a bit over double the cost. Each extra question is roughly 13 tokens, because Jev reads the message once and answers everything in the same pass. And yes, I asked some silly ones, and it still got them right: “mentions safety equipment” 0.98 (the fire extinguisher), “uses a nickname” 0.87 (“chief”) and “mentions a pet” 1.00.
With an LLM we’ve learnt to ration our questions, because every one of them costs time and money. With Jev you can stop doing that. Ask everything you might possibly need about a message in one call, and decide later what to do with the answers.
Example 3: can you actually trust the confidence?
Classification is where I think a lot of teams will feel Jev first. Think of bug reports that need to land with the right team (payments, onboarding, mobile, infrastructure), or customer feedback that needs theming. With an LLM, that’s a full LLM call per ticket — slow and expensive!
But cheap only matters if you can trust it. So I gave Jev 17 messages from the Crust Issues inbox to route to four teams (kitchen, delivery, billing, other), half of them deliberately messy, like “The driver dropped my pizza and it’s now a calzone. Refund please.”
The confidence from a single ask decides the route: 0.99 or above is automatic, 0.80 or above gets a human to confirm, and anything lower goes to a human. Then I checked two things: was the answer right, and would it hold across 34 more asks, including every order of the four options?
A few things jumped out at me:
Confident answers never moved — above 0.80, every one of 374 re-asks gave the same answer as the first ask. The only two messages that ever flipped were both under 0.50.
It told me how it would flip, before it flipped — for “If the driver is late again tonight, do I get my money back?”, a single ask said delivery 0.61, billing 0.39. Across 34 asks it picked delivery 76% of the time and billing 24%. Honestly, this is the part that blew my mind. An LLM gives you an answer and that is it; Jev also tells you how likely it is to change its mind which for decision making it matters.
Steady isn’t the same as right — “I was charged for extra cheese and there’s no cheese on it” came back as kitchen in all 34 asks, but only at 0.59 confidence, and I’d have sent it to billing. Low confidence doesn’t mean “this will flip”, it means “reasonable people could disagree” — which is exactly when you want a human looking at it.
Tell it your rules — three of the four misses were about money but also mentioned the driver or the food. My house rule is “money goes to billing first”, and Jev followed the topic instead, because I never told it that rule. If a rule matters to you, write it into the option descriptions.
The whole thing, 578 calls, cost less than a cent!
Example 4: the real magic, Jev and an LLM together
This is the part I was most excited to try. If you’ve built anything with RAG or tools, you’ll know the pattern: before the “real” LLM call, you make a chain of smaller ones. What is this question about? Which sources should I search? Which tool should the agent use? Every one of those is another LLM call, more latency, more cost, and another JSON blob to parse (when lucky :) )
With Jev it becomes > Jev decides what, the LLM decides how to say it.
So I gave the Crust Issues assistant four documents (the menu, an allergen sheet, the delivery policy and the refund policy) and two tools (track_order and issue_refund). One Jev call reads each message first and answers three questions: what does the customer need, do they mention an allergy, and how upset are they? A few lines of plain Python turn those answers into a plan, and then Claude gets only what it needs to write the reply.
The Garden Party one is my favourite. The menu only says pesto; the allergen sheet says the pesto is made with walnuts. Without Jev’s allergy flag pulling in that sheet, the LLM could happily tell a parent there are “no nuts listed”.
The last one matters just as much. Jev wasn’t sure what the customer wanted, so Claude got no tools and asked a question instead of guessing. An LLM router would usually just pick something, with no number telling you it was guessing.
On cost, Jev took about a quarter of a second and $0.000018 per message, while the Claude reply took about two seconds and $0.002, so the router costs roughly 1/100th of the call it routes. To be fair, with four documents and two tools you could just send Claude everything; think of this as a stand-in for the 400 documents and 40 tools of a real product.
The big players are paying attention too
One more thing before I wrap up, because the timing is just too good. This week, at DevDay, OpenAI announced its Decisions API: you define a question and a fixed set of answers, and it gives you back one answer with a confidence score, built on a version of their GPT-6 Luna model. Sound familiar?
There are some key differences between the two, and it’s still in limited preview, so I’m not going to go into a comparison in this article (maybe that’s the next one!). But I think it says a lot that one of the biggest model makers is going in the same direction. Small, fast, typed decisions are quickly becoming their own category, and I don’t think this is going away.
Try it yourself
I’ve put all four examples on my GitHub so you can run them yourself. You’ll need a TypeSafe API key, plus an Anthropic key for example 4, and then it’s one command.
Next time you’re about to write yet another “classify this and reply in JSON” prompt, stop and ask yourself whether you need the jackhammer, or whether Jev is a better option for you.
I’m super excited to see what TypeSafe AI ships next, and where this new way of working with AI goes. For a while now, we’ve had a jackhammer and not much else. Now we’re finally getting a proper toolbox, and I can’t wait to see what we all build with it!!
First published on Medium on 30 September 2026.