Jev Is the Cheapest AI Model I've Used, and It Can't Write a Sentence
Almost every model launch this year has been about the same two things. Better chat, better reasoning, longer answers.
Jev is not that.
TypeSafe put it out on 18 September 2026, and the model does not write text at all. You hand it a question and a fixed list of answers, and it picks one. That’s the whole thing.
I’ve been running it through OpenRouter on actual work for the last few days, so here’s what it does, where I used it, and where it falls apart.
TL;DR
- Jev is a decision model. It picks from options you define. It does not generate text.
- Input is $0.042 per million tokens. Output tokens are free.
- It answers in 70 to 500 milliseconds instead of 3 or 4 seconds.
- The context window is 32k on OpenRouter, and that’s the biggest limit.
- You can’t chat with it, and it won’t tell you why it picked something.
- It’s behind a waitlist, so OpenRouter is the easy way in right now.
What a “System One” Model Means
This comes from Kahneman. System 1 is the fast, automatic answer. System 2 is the slow one where you sit and think it through.
Every model that does chain of thought is System 2. It talks to itself, weighs things, then writes you a paragraph. That’s great when you actually need the paragraph.
But most decisions inside software don’t need a paragraph. Is this ticket about billing or about delivery? Did the customer agree to a callback or not? Is this lead worth calling again? You want one answer, you want it now, and you want it in a format you can put in a column.
That’s the gap Jev is going after.
What Jev Actually Gives You
You get three shapes of answer. A choice from a list you wrote. A score. Or a yes or no with a probability attached.
That’s it. No explanation, no reasoning, no follow up.
The nice part is that because you define the answers, it can’t make one up. There’s no hallucination here because there’s nothing to hallucinate into. It also can’t hand you broken JSON, which is half the reason people write retry logic around normal models. TypeSafe says the structured output error rate is 0%, and in my use it hasn’t handed me anything I had to clean up.
The way they got there is a training method they call RLCD, Reinforcement Learning for Calibrated Decisions, instead of the usual RLHF. The model is also not autoregressive. It doesn’t write one token, look at it, then write the next one. It produces the whole answer in one pass, which is why it comes back so fast.
TypeSafe was started by Diogo Almeida, who was one of the co-inventors of ChatGPT at OpenAI. So this is not a random weekend project.
Where I Used It
I work with AI calling data, so I have a lot of call transcripts sitting around and very little patience for reading them.
For one brand, I set up Jev to look at each call and answer a list of questions:
- How many bathrooms did the customer mention?
- Was a slot actually booked?
- Did the agent discuss the timeline?
- Was a WhatsApp message sent to the person?
- Did the agent confirm the number is on WhatsApp?
- Was the call in English or Hindi?
- Did the agent miss any of the questions he was supposed to ask?
- Is this lead qualified or not?
- What’s the sentiment of the call?
- How good was the bot on this call?
That’s 14 questions answered in one call to the model. The metrics on top, duration, turns, talk share, how much of the customer’s speech was in Hindi, those are counted from the transcript, not asked of Jev. Only the questions below are.
On top of that I was already pulling the boring stuff from the call logs, like latency and the longest call of the day.
None of these questions need an essay. Each one is a yes or no, a number, or a pick from a list. Which is exactly what Jev does.
Scroll further down the same run and you get the judgement calls:
The agent’s biggest failing on that call came back as deflected_question at 0.99. Quality landed on “Adequate”, sentiment on “Neutral”. Look at the footer: 748 ms, $0.000080 for the whole thing, and 12,551 calls per dollar. That’s a full transcript with 14 questions on it.
So I Built a Small Bench for It
I ended up making a thing I’ve been calling JevBench.
It’s simple. I add the questions I care about, and the options for each one. Then I point it at a batch of transcripts and it fills in the table. If I want a new column tomorrow, I add one row and run it again.
Doing this with a normal model was always possible, but it was slow and it cost real money once you had a few hundred calls. Here the output is free and each call takes half a second, so I stopped thinking about the cost at all.
The Same Bench, Different Jobs
Once the calls were working I started throwing other things at it, because setting up a new one takes about two minutes.
A support ticket, which is the obvious one:
“Help! My payouts have been failing for 3 days.” Urgent 0.95, billing 0.85, customer is frustrated. 710 ms, and at that size it’s 55,760 calls per dollar. That is the routing rule you were going to write with keyword matching, except it handles the ticket that never says the word “billing”.
A live chat, where the question is whether a human needs to step in:
A lead, from a plain JSON record instead of a transcript:
And a pull request, which I did mostly as a joke and then kept:
A hotfix that bypasses an auth check, no tests, new contributor, merging to main on a Friday evening. Risk 3.90 out of “do not merge”, area security at 1.00. It took 410 ms and cost $0.000021.
The Price Is the Real Headline
This is the part that made me pay attention. These are the OpenRouter numbers:
| Jev | GPT-5.6 Terra | |
|---|---|---|
| Input | $0.042 / M tokens | $2.00 / M tokens |
| Output | free | $12.00 / M tokens |
| Per decision | $0.0004 | $0.0304 |
| Answer time | 70 to 500 ms | about 10 seconds |
When you’re classifying one thing, none of this matters. When you’re classifying every call, every ticket, every row in a sheet, it’s the difference between a feature you ship and a feature you keep postponing.
The Benchmark Numbers
TypeSafe ran it on four workflows of their own: security incident response, agent trace observability, invoice processing, and customer service. This is their own benchmark, so take it as a starting point and not as proof.
| Model | Accuracy | Cost per case | Latency |
|---|---|---|---|
| Jev | 67.8% | $0.0004 | 0.4s |
| GPT-5.6 Terra | 67.9% | $0.0304 | 10.1s |
| GPT-5.6 Sol | 74.1% | $0.0836 | 23.3s |
| Claude Opus 5 | 73.1% | $0.1761 | 37.8s |
Read that first row against the second. Same accuracy as GPT-5.6 Terra, about 75 times cheaper, 25 times faster. TypeSafe’s own claim is 40x to 200x faster than frontier models depending on the task, and the gap I see day to day sits inside that.
The bigger models are still better. Sol and Opus 5 are five to six points ahead, and on some work that matters a lot. But you’re paying a few hundred times more and waiting half a minute for it.
What It Can’t Do
This is where I have to be honest, because a lot of what I’m seeing online about this model is nonsense.
The context window is 32k, at least on the OpenRouter listing I’m using. That’s the first wall you’ll hit. Long call transcripts, long documents, anything with a lot of history, you’re going to have to cut it down first.
You can’t talk to it. If I want to ask it something like “should I call Yusuf today” and get an answer back in words, that’s not what this is. You can ask it to pick from options you wrote. That’s the only interface.
It won’t explain itself. You get the answer and the probability. You don’t get the why. If you need to show someone the reasoning behind a decision, this isn’t your model.
The one thing that saves this is the confidence number. It won’t tell you why it picked something, but it will tell you when it isn’t sure, and that turns out to be enough. Here it is on a comment that’s rude but not actually abusive:
“Honestly whoever designed this checkout flow should be fired into the sun.” Harassment 0.34, threat 0.05, and severity sitting between “No violation” and “Borderline” at 0.20 confidence, with a low confidence flag on it. Which is correct. That comment is genuinely borderline. I’d rather have a model that says it’s unsure than one that writes me a confident paragraph about it.
The advertised latency is optimistic. TypeSafe says 70 to 500 ms. Round trip from my laptop, on real payloads, I see 400 to 800 ms. Still fast, but the 70 ms number is not what you’ll live with.
It cannot write. No summaries, no long text, no drafting. And this is the one I want to be loud about, because people are already putting out tutorials claiming Jev can build games or write apps. It can’t. It doesn’t generate text. Those videos are just wrong.
It’s still waitlisted. Access is gated, so unless you got in, OpenRouter is how you use it today. The build I’ve been hitting is typesafe/jev-1.13-20260917.
When I’d Reach for It
Anywhere I’m making the same small decision thousands of times.
Support tickets that need to go to the right person based on what’s in the message. Leads that need to be marked qualified or not. A column in a Google Sheet that needs a label. Sentiment on a pile of calls. Checking whether an agent followed the script. Any place I was about to write twelve if statements and regex, and I know the regex is going to miss half the cases.
What I wouldn’t do is try to make it the main model in a product. It’s not the thing that talks to your users. It’s the thing sitting behind that, quietly sorting.
Final Thoughts
Jev is good at one narrow job and it’s very good at it. Cheap, fast, and it always gives you something you can put in a database.
The 32k context window is the thing I keep running into, and the lack of any explanation means I can’t use it for anything I’d have to defend later. TypeSafe’s numbers are also TypeSafe’s numbers, so I’d like to see somebody outside the company run the benchmark before I fully trust that 67.8%.
But for what I actually do all day, which is turning piles of calls into rows I can read, it has already replaced a slower and much more expensive setup. And honestly, it was fun to play with. Not something I say about most launches.