What is Jev? A model built to decide, not to write.

Jev answers questions your software can act on directly — a chosen option, a score, or a yes/no probability — and it never writes a sentence. Judging it as a chatbot misses the point. Here is what it actually does, where it fits, and where the marketing outruns the evidence.

Last updated: September 18, 2026

The short answer

Jev is the first model released by TypeSafe AI, announced on 15 September 2026 and available in early access through a hosted API. It is not a language model in the usual sense. It does not generate text, code, or conversation, and there is no chat interface.

Instead, you send it a state — a paragraph of text, a JSON object, a row of records — along with a set of typed questions. It returns structured answers your code can branch on: a selected option with a full probability distribution, a numeric score on a scale you define, or a probability between 0 and 1 that a statement is true. There is no parsing step and no schema validation step, because the output shape is fixed before the model runs.

TypeSafe describes it as a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out.

Why build a model that cannot write a sentence

TypeSafe was founded by Diogo Almeida, a former OpenAI researcher who worked on the methods behind ChatGPT. He is a co-author of the InstructGPT work and helped develop reinforcement learning from human feedback, the technique that taught language models to follow instructions well enough to be useful to people.

His argument for leaving that approach behind is specific. Training on human preference made models excellent at instruction following, and it also produced two traits that block automation: overconfidence, and a tendency to collapse toward a single plausible-sounding answer. If a model can handle a task 95% of the time but cannot tell you which 5% it is failing, you cannot safely hand it the task. A human has to stay in the loop, which caps how much you can automate.

So Jev is trained for a different property. TypeSafe calls the method Reinforcement Learning for Calibrated Decisions, and the goal is that the probability the model reports matches how often it is actually right. The company name refers to type safety in programming: the idea that catching a wrong-typed value at the boundary is cheaper than discovering it deep inside a system.

The model class is named after the fast, intuitive System 1 thinking in Daniel Kahneman's Thinking, Fast and Slow. The model itself is named after William Stanley Jevons, the economist behind Jevons paradox — the bet being that making intelligence far cheaper increases total consumption of it rather than reducing it.

Three question types, answered in one pass

Jev exposes exactly three primitives, and they cover everything it can do.

A Choice question asks the model to pick from a set you define. You get back the highest-probability option, the probability of every option, and a confidence value. The option list can go up to 255 entries; past that, TypeSafe splits the work into scoring each option and then selecting among them.

A Score question rates the state against an ordered rubric you supply, with at least two levels. The returned score is probability-weighted, which means it can land between your defined levels rather than snapping to one of them — useful when you want a finer signal than the rubric offers, and confusing if you expected a discrete answer.

A Noul question is a yes/no judgment that returns a probability between 0 and 1. It is the simplest primitive and the one to reach for when you just need a threshold decision.

The part that matters for cost and latency is that every question in a request is evaluated against the same state in parallel. Adding a fifth or tenth question to a call barely changes how long it takes, and TypeSafe says each question is judged independently, so a long list does not degrade the earlier answers the way a growing chat context does.

The recommended pattern is to keep questions atomic and recombine them in your own code. Rather than asking a model to rate a business proposal overall, you ask separately about market size, technical feasibility, and differentiation, then weight the results with a formula you control. When priorities change, you adjust a coefficient instead of rewriting a prompt.

What calibrated confidence actually means

This is the part of the design that separates Jev from a general assistant, so it is worth being precise about it. Calibration means the number is meant to be taken literally: when the model reports 0.9, it should be right roughly nine times out of ten on that kind of question. Most language models will happily say 0.9 and mean something closer to sounds plausible.

That property is what makes thresholds usable. You set a cut-off, let the model act above it, and route the rest to a person. The system gets faster where it is reliable and stays honest where it is not, which is a different arrangement from a model that must be supervised on every call.

One practical trap: the confidence value is derived from the whole probability distribution, not copied from the top answer. TypeSafe's own quick-start example returns an option at 0.84 probability alongside a confidence of 0.596. If you wire a threshold to the top probability and assume it is the confidence, your routing rules will not behave the way you expect. Read the confidence documentation before building on the number.

What "no hallucination" does and does not mean

TypeSafe claims Jev cannot hallucinate, and the claim needs unpacking because it is narrower than it sounds.

What is genuinely guaranteed is the shape of the output. The model selects from options you defined, or returns a number in a range you defined. It cannot invent an option that does not exist, return a string where a number belongs, or emit malformed JSON. That class of failure is excluded by construction rather than by prompting, which is a real difference from wrapping a language model in a schema validator and hoping.

What is not guaranteed is being correct. Jev can return a valid, properly typed answer that is simply wrong about the world. Almeida acknowledged this at launch. The vendor's framing is that the model will not fabricate a citation or produce a type error, which is true, and also that its answers still need to be right, which is a separate question the architecture does not settle.

There is a second limitation worth naming: Jev does not explain itself. You get a probability, not a reason. For a routing decision that is usually fine. For an automated decision that someone may later have to defend to an auditor, a company, or a regulator, having no reasoning trace is a real constraint, and it is one of the reasons the transparency question comes up in every serious write-up of the launch.

Speed and price: separating measurement from marketing

Some of TypeSafe's numbers are easy to check. Input costs $0.042 per million tokens, which is $42 per billion. Output tokens are not charged at all, which follows from the architecture: there is no autoregressive generation loop to meter. Vendor-reported latency is between 70 and 500 milliseconds end to end, against the 3 to 329 seconds the company measured for frontier language models.

The headline claims need more care. TypeSafe advertises 193.6 times faster and 444.6 times cheaper, and these come from evaluations the company ran itself. The workflows were written by members of its own capabilities team, the reference answer is the average of two competing models rather than a ground truth, and the runs happened on the company's own machines on the West Coast. TypeSafe states plainly that these figures are on the higher end of what it expects in the real world, and that the reference choice likely biases results toward the competing models. Treat them as vendor claims. There is no independent benchmark to compare against yet.

The operational limits matter if you are planning production use. A request can carry 64,000 tokens in total, with the state plus the single longest question capped at 32,000. Input is text only — images, audio, and video must be converted to text or structured fields first. Rate limits are stated as 250,000 tokens per second and 1,200 requests per minute, and TypeSafe says these are adjusting dynamically while it serves high demand, which means they can change without notice.

Two further constraints are easy to miss. English is the primary training language and where accuracy is best; other languages, including CJK scripts, are handled but the vendor does not claim equal accuracy and recommends testing before relying on them. And Jev cannot be fine-tuned. Every account is served by the same weights, so you shape behaviour through the state you send and the questions you define, not through training on your own data. TypeSafe states that customer requests and responses are not used for training.

Where it fits

The intended use is the decision your code currently makes with brittle hand-written rules. Classifying an incoming support ticket and routing it to billing, technical, or sales. Sorting invoices. Triaging security alerts. Scoring content against a policy. Selecting which tool an agent should call next, or checking another model's output for a jailbreak attempt before you act on it.

The pattern these share is that the answer is a bounded judgment, not a piece of writing. TypeSafe's demonstrations lean into the same idea: a bot playing Doom from structured game state at roughly ten queries per second for about seven dollars an hour, and a Wikipedia link-racing game where each step chooses among hundreds of options. The games are stunts, but they make the operating envelope visible — decisions fast enough and cheap enough to sit inside a running program.

The other direction is bulk processing. Because each decision costs a fraction of a cent, it becomes practical to apply a judgment to every record in a large dataset rather than sampling some of them.

Where it does not fit

Jev is not a replacement for ChatGPT, Claude, or any other assistant. It cannot draft, summarize, explain, translate, or write code, and it has no conversational memory to work with. If your task ends with something a person reads, this is the wrong tool.

It also will not replace the tools in this directory. Those products solve problems for people at a desk — writing, meetings, planning, design. Jev solves a problem for software. The overlap is close to zero, which is precisely why we have not listed it as a directory entry.

Finally, it is early access. The vendor is onboarding developers from a waitlist, rate limits are moving, and the pricing is explicitly not yet proven sustainable in the long run — TypeSafe says it cannot demonstrate the price is not subsidized, and expects prices to fall rather than rise. That is an honest statement, and also a reason not to build a product with a service-level guarantee on top of it today.

Does this matter if you do not write code?

Not directly, and not yet. There is nothing here to sign up for, no workflow to adopt, and no report to write. If that is your situation, the honest advice is to note the name and move on.

It is still worth understanding the shift it represents. The past three years of AI progress have mostly been about making models better at talking to people. Jev is a bet that the next phase is about models that fit inside software — that the interesting work is not a better conversation but a more trustworthy decision, and that a model which admits uncertainty is more useful than one which is confident and occasionally wrong.

If that bet is right, the practical effect on everyday tools will be quieter than a new chatbot. Software you already use gets more reliable at the edges: fewer obviously wrong answers, more cases correctly handed to a human, and automation that can finally run without someone watching every step. When you evaluate AI tools from here, the question worth asking is whether the product can tell you when it does not know. That property matters more than raw capability, and it is the one Jev was built around.

Where to verify this yourself

Jev is documented publicly, and the primary sources are worth reading directly rather than through coverage: the launch announcement, the API documentation, and the separate workflow evaluations site where the vendor's numbers and their stated caveats live. The model is also listed on llmreference.com for a neutral specification summary.

Reviews on this site are based on official documentation, published pricing, and release material. We have not run Jev in production, and we do not present laboratory benchmarks as our own testing.