A lot of LLM calls inside software don't write anything. They read some text and pick one of a few options. Is this a refund request or a bug report? Does this action need approval? Is this message spam? You can send those through Claude, GPT or Gemini and it works. It's also a lot of model for the job.
Jev is built for exactly that job. It's a classification model from a startup called TypeSafe, launched in September 2026. You give it text and a question, and it gives back one of the answers you defined, with a probability and no prose. At list price, a million classifications on Jev cost about $24. The same million costs about $68 on the cheapest small LLMs when they answer with only a label, about $1,350 on mid-tier models doing the same, and over $50,000 on flagship models that write a long answer first.
That gap is real, but its size depends on what you compare against, and nearly all the evidence for Jev so far comes from TypeSafe. Here is what's known, what isn't, and how to test it on your own data.
What is Jev?
Jev is what TypeSafe calls a decision model, the first of its "System One" models. It doesn't generate text. It returns a typed answer: yes or no with a probability, a pick from a list with a probability for each option, or a score from 0 to 10 worked out from those probabilities, as The Batch describes it.
You send a block of text and one or more questions. The questions run in parallel, you pay for the text once plus the question tokens, and output is free. The OpenRouter listing shows $0.042 per million input tokens and $0 for output.
Two things matter if you plan to depend on it. TypeSafe says it trained Jev so its probabilities mean something: an answer it gives 20 percent should be right about 20 percent of the time. And TypeSafe says Jev isn't an LLM and doesn't generate token by token, although it's built on a transformer. Most of the architecture isn't public, and the sources I read disagree on the context limit, so check with TypeSafe before you design around a number.
How is Jev different from an LLM?
An LLM writes an answer. Jev picks one. In practice that means three differences.
- The output is something your code can branch on. An LLM gives you text you then have to parse. Jev gives you a choice and a probability.
- The probabilities are meant to be usable. LLMs can sound certain and be wrong. Arize points to a 2025 study of 14 LLM judges that clustered at 90 to 100 percent confidence while their accuracy was well below that.
- There's no explanation. Jev won't tell you why. If you need a reason, you still need an LLM or a person.
How we're using it
We've started replacing LLM calls with Jev at decision points in the systems we build, the places where a system has to classify some text or choose between a few options before it does anything else. Those calls don't need a model that can write, and I'd rather not pay for one or wait on one.
I don't have a clean before-and-after number from client work that I can publish, so the cost figures below are list-price math, not our invoices. Use them to size the opportunity, not as a promise.
The pattern I reach for is a classifier at the front door. It decides, and only the uncertain or genuinely hard cases go on to an LLM or a person.
How much cheaper is Jev than Claude, GPT and Gemini?
It depends on what you're comparing against. I priced one million classifications of a 500-token text at each provider's list price, read from their official pricing pages on October 20, 2026.
Illustrative workload, not a measurement: a 500-token text. LLMs get about 650 input tokens (text plus instructions). Jev gets 580 (text plus four short questions) and bills no output. List prices per 1M tokens read from each provider’s official pricing page on October 20, 2026. Gemini 3.8 Flash doubles on January 1, 2027.
| Model | Input $/1M tokens | Output $/1M tokens | Label-only answer | 900-token answer | x Jev (label) | x Jev (written) |
|---|---|---|---|---|---|---|
| Jev 1.13 | $0.042 | $0 | $24 | $24 | 1x | 1x |
| Claude Haiku 5.5 | $0.1 | $0.5 | $68 | $515 | 2.8x | 21x |
| GPT-6 Luna | $0.1 | $0.5 | $68 | $515 | 2.8x | 21x |
| Gemini 3.5 Flash-Lite | $0.3 | $2.5 | $208 | $2,445 | 8.5x | 100x |
| Gemini 3.8 Flash | $0.75 | $3.75 | $506 | $3,863 | 21x | 159x |
| Claude Sonnet 5.5 | $2 | $10 | $1,350 | $10,300 | 55x | 423x |
| GPT-5.6 Terra | $2 | $12 | $1,360 | $12,100 | 56x | 497x |
| Claude Fable 5.1 | $10 | $50 | $6,750 | $51,500 | 277x | 2,114x |
| GPT-6 Astra | $10 | $50 | $6,750 | $51,500 | 277x | 2,114x |
Here's how I read it.
- Against the small models (Claude Haiku 5.5, GPT-6 Luna) answering with only a label, Jev is about 2.8x cheaper. That's real, but it isn't dramatic.
- Against Gemini 3.8 Flash it's about 21x cheaper, and Google's price for that model doubles on January 1, 2027.
- Against mid-tier models (Claude Sonnet 5.5, GPT-5.6 Terra) it's about 55x.
- Once the larger models write a 900-token answer first, the gap passes 400x for Sonnet 5.5 and Terra, and reaches about 2,100x for the flagships (Claude Fable 5.1 and GPT-6 Astra).
That last band is where TypeSafe's "up to 400x cheaper" headline lives. It's accurate there. It isn't what you'll save if you're already running a small model with a one-word answer.
Put in dollars, ten million decisions a month would cost roughly $240 on Jev. On Claude Haiku 5.5 with a label-only answer it's about $675. On Gemini 3.8 Flash it's about $5,060. On Claude Sonnet 5.5 it's about $13,500 with a label-only answer and about $103,000 if the model writes 900 tokens each time.
So the saving is mostly a story about avoided waste. If a routing decision goes to a frontier model that reasons at length, move it. If it's already on a small model, choose on speed and calibration, not price. This math also uses list prices. Caching and batch discounts will pull the LLM numbers down, and Jev's bill grows with the number of questions you ask per text.
Is Jev faster?
TypeSafe reports 70 to 500 milliseconds per request. Averaged across its own four internal workflows, it reports 0.4 seconds per case for Jev against 10 seconds for GPT-5.6 Terra and 38 seconds for Opus 5, as Arize relays them.
Averages across TypeSafe’s four internal workflows, reported by TypeSafe and relayed by Arize in September 2026. Arize had not run its own benchmark at the time. The larger models were run with reasoning, which accounts for much of the gap.
Two cautions. TypeSafe measured this itself. And the bigger models were run with reasoning, which accounts for much of the gap. A small LLM answering with one word will be much closer. Another test Arize cites clocked 777 judgments in under 0.7 seconds, which shows how quickly Jev handles a batch. Time the 95th percentile on your own traffic before you believe any of these numbers.
Is Jev as accurate as an LLM?
Nobody outside TypeSafe knows yet. This is what exists.
- TypeSafe's own benchmark across four workflows: Jev averaged 68 percent accuracy, the same as GPT-5.6 Terra, with Opus 5 at 73 percent. The reference answers came from other models, not human labels. TypeSafe's figures also shift a little between write-ups; The Batch reports 67 percent.
- Event moderation at NearHere: Jev scored 96 percent against 86 percent for Gemini Flash-Lite, at about one fifty-eighth the cost per decision.
- A developer's spam test on 18,514 emails: Jev, with no training, scored 98.3 percent. A classic logistic regression model trained on about 14,800 labeled emails scored 98.4 percent. The two disagreed on 466 emails, with no meaningful difference between them.
- Arize says it hasn't run its own benchmark yet.
The spam test is the interesting one. A model that matches a trained classifier with no labeled data could save you weeks. It's still one test.
The calibration result is the part I'd pay attention to. In that test, emails scored under 0.1 were 0.1 percent spam, and emails scored 0.9 or above were 99.9 percent spam. The 0.5 to 0.6 band was 38 percent spam. Sending the 4.6 percent of emails scored between 0.3 and 0.7 to a person left the rest at 99.5 percent accuracy. That's the real prize: a probability you can set a threshold on.
What are the alternatives to Jev?
A few options do similar work. Most of the open ones are days or weeks old, and their claims haven't been checked.
| Option | What it is | Where it's strong | Watch out for | Source |
|---|---|---|---|---|
| Jev | Hosted decision model that returns typed answers with probabilities | Cost per decision, speed, no training data | Early access, no explanations, mostly vendor-reported results | The Batch, Arize |
| Small LLM with a constrained output | Claude Haiku 5.5, GPT-6 Luna or Gemini 3.5 Flash-Lite told to answer with a label | Already in your stack, flexible, can explain when asked | About 3x to 9x Jev's cost on our example even at label-only, calibration varies | Provider pricing pages |
| Laya | Classification model published on GitHub, with a focus on multilingual support | Languages beyond English | Its claim to beat Jev is unverified | The Batch |
| Kev | Model on GitHub built on Qwen 3.5 in three sizes, trying to reconstruct Jev's architecture | Published code you can inspect | Unverified, and a reconstruction, not a copy | The Batch |
| Bespoke Nimble | A Qwen-3.5-9B model fine-tuned as a classifier, published on GitHub | Published code you can inspect | Same: unverified | The Batch |
| Classic classifier (TF-IDF with logistic regression) | A trained model on labeled examples | Matched Jev's accuracy on one spam test and costs almost nothing to run | Needed about 14,800 labeled examples, struggles when categories change | Arize |
| Rules and plain code | Hand-written logic | Predictable and free | Breaks on messy language | MindStudio |
When should you use Jev, an LLM, a classic classifier or plain code?
- Plain code when the rule fits in a sentence and doesn't depend on language.
- A classic classifier when you have plenty of labeled data, stable categories and a need to run it yourself.
- A decision model like Jev when text goes in, a small set of choices comes out, the categories change, and you have no labeled data.
- An LLM when the output has to be written, explained or reasoned through over several steps.
- A mix for most real systems. MindStudio describes three versions of it: a router that tags incoming text, a safety gate that approves, blocks or escalates an agent's proposed action, and a triage layer that decides whether an LLM call is worth making.
The safety gate is the one I'd watch. An agent that proposes dozens of actions can have each one checked cheaply, which is hard to afford when every check is a frontier-model call. It's one reason decision models matter for agent systems.
How to test it on your own data in a day
1. Pull 300 to 500 real examples and have a person label them. 2. Write each decision as several short, separate questions instead of one broad one. The Batch recommends this. 3. Run Jev, a small LLM told to answer with a label, and your current setup on the same examples. 4. Compare accuracy. Then check calibration: of the cases Jev scores 0.9 or higher, are at least 90 percent right? 5. Time the 95th percentile on real traffic and price it with your actual token counts. 6. Pick a threshold, send the uncertain band to an LLM or a person, and cost that too. 7. Run it again every month. This market is moving fast.
Quick answers
Is Jev an LLM?
No, according to TypeSafe. It's transformer-based, but it returns a choice instead of generating text one token at a time.
Does Jev hallucinate?
TypeSafe says it can't. Arize calls that an overreach. Jev can't answer outside the options you give it, but an answer inside them can still be wrong.
Can Jev replace Claude, GPT or Gemini?
For deciding, often. For writing, explaining or reasoning, no.
Who makes Jev?
TypeSafe, a startup founded by OpenAI alumnus Diogo Almeida, according to The Batch. It launched in early access in September 2026 and is also listed on OpenRouter.
How much does Jev cost?
$0.042 per million input tokens and nothing for output, per the OpenRouter listing.
If you're paying LLM prices for decisions
If you suspect your system is paying for a model that writes where a model that chooses would do, that's a good first look for a two-week Architecture Sprint. Our LLM cost optimization work starts with exactly this question: which calls need a big model, and which don't.
Sources
Checked October 20, 2026. Prices change, so confirm before you budget.
- Arize, "TypeSafe's Jev: Can decision models replace LLM judges?" (September 2026)
- The Batch, "Models Built to Do One Thing Well" (September 25, 2026)
- MindStudio, "Jev vs LLM: use cases and architecture patterns"
- OpenRouter listing for TypeSafe Jev 1.13
- Anthropic pricing, OpenAI pricing and Google Gemini API pricing
Want help with your AI stack?
If this post matches problems you're seeing, we can map the fastest path from architecture decisions to production outcomes.
Book a call
Manmeet Singh
Founder & CEO, AIshar Labs · Ex-Apple, Ex-Instacart · 15 AI Patents Filed
Built ML systems at Apple (Search: Maps, Safari, Spotlight) and Instacart (Search, Recommendations, Ranking). Writes about production AI tradeoffs and system design.
Follow on LinkedIn →