Jev Review: Fast AI Decisions Without Text Generation

Here is an example call for a support message. One request, three answers.

1from typesafe_sdk import Choice, Noul, Score, TypeSafeClient
2
3client = TypeSafeClient(model="jev-1.13.0")  # pin the version you tuned on
4msg = "Third time asking: order 4417 arrived broken. Refund me or I cancel."
5
6res = client.system_one(
7    {"channel": "whatsapp", "message": msg},
8    {
9        "intent": Choice(
10            instructions="What does the customer want in `message`?",
11            criteria={"refund": "Money back", "replacement": "A new item",
12                      "status": "A delivery update", "other": "Anything else"},
13        ),
14        "churn_risk": Score(
15            instructions="How likely is this customer to leave?",
16            criteria=["No sign of leaving", "Annoyed but staying", "Threatens to cancel"],
17        ),
18        "wants_human": Noul(instructions="Does the customer ask for a human agent?"),
19    },
20)
21a = res.answers
22print(a["intent"].choice, a["intent"].confidence, a["churn_risk"].score, a["wants_human"].noul)
23

TypeSafe recommends asking many small questions per call and combining the answers in your own code. That is cheap to do, because the state is sent once and each extra question only adds its own tokens.

Jev vs. Traditional LLMs: Key Differences

Two objections come up every time this model is discussed.

The first is JSON mode. Structured outputs on a regular LLM already guarantee a valid shape, so what is new? The LLM still generates token by token, and when you ask it how sure it is, the number you get back is more generated text. The difference is that Jev’s probabilities come out of the model itself.

The second is that none of this is new. NLP engineers have used zero-shot classifiers like bart-large-mnli for years, and those return label probabilities too. KDnuggets put it well: “the problem is old; the architecture and product around it may be new.” I agree with that reading. What Jev brings is scale, plus the ability to mix many different questions in one call. How it does that is anyone’s guess. TypeSafe hasn’t published a paper or the weights, so everything about the internals is the company’s word.

Jev Pricing and Performance

The price is US$0.042 per million input tokens, and output is free. For reference, TypeSafe puts LLM input pricing between US$0.20 and US$10 per million.

On speed, the company reports 70 to 500 ms per call. This number I trust, because other people measured it. An independent pilot got a median of 236 to 256 ms. OpenRouter triaged 60 support tickets at a median of 194 ms, for about US$0.025 per thousand tickets.

The number I would ignore is the one on the homepage: 193.6x faster and 444.6x cheaper than LLMs. It comes from four workflows TypeSafe wrote itself, and the company admits they sit at the high end of what you should expect. TypeSafe also says it can’t prove the price isn’t subsidized. Credit to them for saying so.

You don’t need a TypeSafe account to try it. The same model is on OpenRouter, Vercel AI Gateway and Cloudflare Workers AI at the same input price.

How Jev’s Confidence Scores Work

This is the part I find most useful, and the easiest to get wrong.

Confidence is a separate number from the top probability. For a Choice, it measures how far the top option sits above an even split. With three options, a top probability of 0.85 gives a confidence of 0.78. With four options you need about 0.93 probability to reach 0.9 confidence. A Noul has no confidence field at all, and a value near 0.5 simply means the model doesn’t know.

TypeSafe’s advice is to set thresholds by how expensive a mistake would be.

1def route(a):
2    intent = a["intent"]
3    if intent.confidence < 0.5:
4        return "human"               # unsure: hand off
5    if intent.choice == "refund" and intent.confidence < 0.9:
6        return "confirm"             # costly action: ask first
7    return f"auto:{intent.choice}"

Don’t copy those numbers into production. Independent calibration results are mixed. Jev did well on news classification (calibration error of 0.064) and badly on emotion detection, where in one 100-example pilot it gave zero probability to the correct label 16% of the time while still reporting high confidence. Fit your thresholds on your own labelled data.

Real-World Use Cases

Customer messaging is the obvious fit. Intent, urgency, churn risk and whether to hand off to a human all come back from one call. In OpenRouter’s 60-ticket test Jev got 98.3% on intent and 100% on escalation.

Agents are the second case. Browser Use built an open-source browser agent where Jev picks the next action, and its README reports a Zürich to London search on Google Flights finishing in 7.1 seconds.

Then there is bulk work. Matthew Berman posted that he ran 724 ads from 37 brands through it in 40 seconds for 9 cents. TypeSafe’s own cookbook uses it to rerank search results, lifting top-1 accuracy on a legal dataset from 5% to 18% after a BM25 shortlist.

It also works as a guardrail in front of an LLM or as a judge behind one, and LangChain already has an integration for it.

What it Won’t Do

“Zero hallucinations” is true in a narrow sense. Jev can’t return an option you didn’t give it. It can still pick the wrong one.

It doesn’t write and it doesn’t explain its answers. TypeSafe’s own notes on the model’s weak spots are worth reading before you build anything. It reads instructions literally. It is unreliable at counting and at comparing dates. It leans toward the first option in a Choice, and it gets worse as you pad the state with irrelevant text. It also doesn’t treat the state as hostile, so prompt injection is your problem.

A Choice tops out at 255 options and input is text only. The service runs in the US. Your data isn’t used for training, though zero retention is reserved for enterprise contracts.

On TypeSafe’s own workflow eval Jev scores around 68%. The reference answers there come from frontier LLMs, so that figure measures agreement with them and says little about real-world accuracy.

Language is where I’d be most careful. An independent audit found accuracy dropping in Russian (88.3% to 77.3% on XNLI) and in Spanish (85.0% to 78.6%).

Laya: An Open-Source Alternative to Jev

Days after the launch, Nandakishor Mukkunnoth of ConvAI Innovations released Laya under Apache 2.0. He says the core idea was in papers he published in 2025 and that TypeSafe didn’t credit them.

Laya is a family of small encoder models. There is an English one (421M parameters), a multilingual one covering more than 100 languages (322M), and one fine-tuned for typed decisions. A router picks between them per request. Its server speaks the same /v1/systemone protocol as Jev, so switching an existing client means changing the base URL.

It is fast. The project reports 32.8 ms per question on a T4 GPU, and a community port for Apple Silicon reports 13.42 ms.

Accuracy is another story. Laya’s README claims a win over Jev on its own typed-decisions benchmark (0.766 against 0.727). To its credit, the same README lists where it loses. Questions with many options are one (0.425 against Jev’s 0.870 on Banking77). Calibration is the other, and it needs a refit before the confidence means anything. Without fine-tuning, the base model scores 0.362 on that typed-decisions benchmark, so plan on training it with your own data.

An independent test of 78 cases on an M4 Pro Mac mini had Jev at 0.974 and Laya at 0.590. Laya answered in about 30 ms there, and Jev in about 302. It is a small sample, but a big gap.

OpenAI Decisions API: How It Compares to Jev

Two weeks after Jev launched, OpenAI announced a Decisions API at its DevDay. It went into public beta on October 6, 2026, so everything here is a first look.

The shape is almost identical. You call POST /v1/decisions with an input and a list of questions, and typed answers come back. The question types map one to one onto Jev’s: a predicate is a Noul, a choice is a Choice and a score is a Score. Choice and score answers carry probabilities and a confidence value.

The difference is underneath. Jev is a model built only for this job. OpenAI’s version is GPT-6 Luna, the cheapest model in its GPT-6 family, restricted to picking from your options.

You notice that in two places. It reads images, which Jev can’t, so a screenshot or a photo of a damaged parcel can be the input. Images have to be sent inline as base64, because the endpoint doesn’t accept URLs. 

And it costs more: US$0.10 per million input tokens against Jev’s US$0.042, with output free on both. A million 500-token classifications come to about US$50 on OpenAI and US$21 on Jev. Unless you run tens of millions of decisions a month, price won’t settle this.

Speed looks like a tie. OpenAI says the endpoint answers about 10x faster than the same model through its regular API, and its DevDay slide showed 150 ms against 1.6 s. OpenRouter’s telemetry has both products at a median of roughly 0.2 s.

For regulated teams there is one more point in OpenAI’s favor. Eligible customers get zero data retention, HIPAA support and data residency in the US or Europe.

What’s missing is evidence. OpenAI hasn’t published accuracy or calibration numbers. The only early comparison I found comes from Every, which had preview access. On a replay of 78 computer-use steps the Decisions API picked the right control 76 times against 73 for Jev, and the two tied on a classification test. Every also says OpenAI’s version trailed on its broader evals. That is too little to call a winner, so the advice in OpenAI’s own docs applies to both: set thresholds from your own labelled examples.

Side by side

Output is free on all three.

Which AI Decision Model Should You Choose?

One warning if you move between them: thresholds don’t transfer. Laya computes confidence differently. OpenAI’s formula appears to match Jev’s, since the examples in its docs work out to the same numbers, but the probabilities behind it come from a different model. Fit your thresholds again after any switch.

Final Verdict: Where Jev Fits Into Your AI Stack

The setup that makes sense to me is one of these models running next to an LLM. The LLM keeps the work that needs reasoning or writing, and the decision model takes the high-volume calls around it.

Of the three, Jev is the cheapest hosted option and the one with the most public testing behind it. OpenAI’s API reads images and probably lives in an account you already have. Laya is the one you control. Whichever you pick, measure it on your own traffic before you trust the confidence numbers.

A last detail I liked is that the model is named after William Stanley Jevons, the economist who noticed that making coal cheaper to use made people burn more of it. TypeSafe is betting the same will happen with AI decisions. OpenAI needed two weeks to announce its own version, which tells me the bet is a reasonable one.