A company called TypeSafe AI released a model called Jev this week and it's the first thing in a while that's properly got my attention. Not because it's smarter than the big models. Because it isn't trying to be smart at all, and that turns out to be the interesting bit.
Jev doesn't write. You send it some state and a set of typed questions and it hands back structured answers with probabilities attached. Pick from this list. Score that against this rubric. Is this statement true? No prose, no parsing, no praying it puts its JSON braces in the right places.
The founder is Diogo Almeida, who helped build ChatGPT and then invented RLHF, the training technique most responsible for the age we're living through. His summary of where it all went a bit wrong is that we got very good at human language, but computers speak a different one. I think that's about right.
The name is the joke and the thesis. Jev is short for Jevons, the Victorian economist who noticed that when something gets cheap enough you don't use less of it, you use it everywhere. Coal, then electricity, now judgment. The bet is that decisions become a utility.
Most of what agents should be doing all day isn't writing. It's judging. Is this email urgent? Does this output meet the bar? Which model should handle this? Should this action be allowed to run? We've been paying a words-for-people machine to do those jobs, which is a bit like hiring a novelist to sit at a switchboard. It works, mostly, but you're paying by the word for answers that should cost a fraction of a penny and arrive before you've finished blinking.
Because you define the outputs in advance, Jev can't wander off. There's no text to hallucinate into. What you get instead is a probability, and the probability is the honest bit. Ask a language model how confident it is and it will tell you it's 87% confident, confidently, because confidence is just more words to it. Jev hands you a number you can branch on.
https://odok.ai runs a bunch of agents doing real work: building sites, researching companies, drafting outreach, reconciling invoices. That means a hundred small decisions a day that nobody should be burning a frontier model on, and a few big ones where you absolutely should. So Jev sits in the middle as a cheap, fast judgment layer. Three places, specifically.
Routing. When a task comes in, Jev scores it first: how complex is this, does it need reasoning or just doing? High confidence it's simple and a small fast model takes it. Anything ambiguous goes up the chain. It's a doorman, and it costs about nothing to stand there.
Quality gates. Every agent output passes a Jev check before it's called done. Does this actually answer the brief, with what probability? Above the threshold it ships. Below it, the work goes back for another pass or gets flagged for a human. Using agents to watch agents used to be the expensive part, expensive enough that everyone quietly didn't do it. Now the watching is nearly free, so it actually happens.
The effect on the bill has been silly. Vercel reported getting results five to eighteen times faster when they swapped a classifier over, and another developer found it ten to twenty times cheaper than Gemini for the same job. Our numbers are in that ballpark, but honestly the money is the least interesting part. The interesting part is that decisions now have error bars, and a system with error bars is one you can trust structurally rather than on vibes.
Armin Ronacher's take is that it delegates the hallucination problem a little to the user. If a decision comes back at 50% that's a coin toss, and now it's your problem. But I'd argue it was always your problem. The language model just let you pretend otherwise, because it never told you the odds.
The frontier labs keep saying the future is bigger models reasoning for longer. Almeida's counter is that it's probably lots of small, boring, reliable judgments embedded everywhere, more like the early internet than the mega apps. When asked if TypeSafe is a frontier lab he said his main product is intelligence, not fear or hype.
I built Odokai on roughly that belief, so perhaps I was always going to like Jev. But I think there's something here for anyone building with AI. The interesting question is no longer how smart your model is. It's whether your system knows what it doesn't know. Jev is the first model I've used that answers that with a number instead of a paragraph.
That's the whole trick. And it's a good one.