choice — pick one option, and rank them all
Returns the chosen option plus a probability on every option you offered and a confidence. Ideal for routing, intent detection, moderation labels and triage buckets.
Released 2026-09-15 by TypeSafe AI · Under a second per call · Zero-shot
What is Jev AI? The model that answers in types, not sentences.
Language goes in. A choice, a score or a single number comes out, each with the odds behind it. Nothing to train, nothing to parse.
It reads like a large modelIt answers like a classifierIt shows its odds
Definition
Jev AI takes language in and returns types out
Jev AI is a decision model built by TypeSafe AI and released on 2026-09-15. You send it a state — unstructured text or a structured JSON object — together with the questions you want answered and the criteria for each one. What comes back is JSON: the option it chose, a probability on every option you offered, and a confidence value. There is no prose in the response because the model has no way to produce any, which is the point rather than a limitation. Developers describing it to each other landed on the same sentence: it is a generic classifier you never have to train, running in a few hundred milliseconds, with the reading comprehension of a much larger model.
Input
The state is whatever you already have
A support ticket. A pull request diff. A call transcript. A product row. A JSON payload straight out of your queue. Jev AI accepts text or JSON, so nothing needs reshaping before it can be judged.
Contract
The questions are named, and so are the answers
You give each question a name and a plain-language description of what you are asking. The response comes back keyed to those same names, so reading it is a property access rather than a parse.
Criteria
The criteria travel with the request
Every option carries its own description of when it applies. That is what removes the training step: the model is told what the labels mean at the moment you ask, not months earlier in a dataset.
Answer types
Jev AI answers in three shapes: choice, score and noul
Each question you send declares which of the three it wants, and each returns something structurally different. Getting the shape right is the one thing the API is strict about, and it is also what makes the answers safe to act on: a choice can never come back as a sentence, and a score can never come back outside the scale you defined.
score — place it on a scale you wrote
You supply an ordered scale, low to high. Jev AI returns a continuous value between the endpoints, the legend it scored against, and the probability mass on each step.
noul — one number, and it may abstain
A noul answer is a single value between 0 and 1. A returned 0.5 means the model declined to take a side — treat it as a third branch, not as an even split.
One call can carry many questions
Several questions share a single state, and the state is most of the token bill — so asking everything at once is both faster and cheaper than asking one at a time.
Side by side
One Jev AI request, the same state asked three ways
One request can carry all three types at once. Here is what each one declares and what each one hands back.
Questions
"sentiment": {
"type": "choice",
"criteria": { "positive": "…", "negative": "…" }
},
"needs_human": {
"type": "noul",
"criteria": { "true": "…", "false": "…" }
},
"urgency": {
"type": "score",
"criteria": [ "Can wait days.",
"Within a day.",
"Within an hour." ]
}Answers
"sentiment": { "choice": "negative",
"confidence": 1 },
"needs_human": { "noul": 0.37 },
"urgency": { "score": 0.81,
"probabilities": {
"0": 0.20,
"1": 0.79,
"2": 0.01 },
"confidence": 0.68 }choice takes an object of options, noul takes exactly the keys true and false, score takes an ordered array. Those three shapes are the only thing the API is strict about.
No training
Why Jev AI needs no training data
Every criterion lives inside the request. Change your categories at two in the morning and the very next call already uses them — no dataset to assemble, no fine-tune to run, no model to redeploy, no drift to monitor. This is the difference between Jev AI and the classifier you were about to build, and it is why a model with a familiar output shape still changes what you can ship.
- 01
Describe the labels
Write one sentence per option explaining when it applies. That sentence is the whole training signal.
- 02
Send it with the state
Criteria and data travel in the same request, so they can never fall out of sync.
- 03
Change them whenever
Add a category, drop one, reword a boundary. The next call reflects it immediately.
- 04
Keep the same code
The response stays keyed to your question names, so a category change never touches your parsing.
Changing your mind
Adding a Jev AI category is an edit, not a project
This is the whole retraining story. Add the option, describe when it applies, send the next request.
Before
"criteria": {
"billing": "Charges, invoices, refunds.",
"shipping": "Delivery, tracking, damage.",
"other": "Anything else."
}After — live on the next call
"criteria": {
"billing": "Charges, invoices, refunds.",
"shipping": "Delivery, tracking, damage.",
"account": "Login, access, data requests.",
"other": "Anything else."
}No dataset, no fine-tune, no redeploy, and no drift to monitor. The response keys never changed, so nothing downstream had to.
Where it goes
Where Jev AI sits in a real pipeline
In front of the expensive model, not in place of it. Route the request, screen the input, score the candidate, gate the tool call — then hand whatever survives to the model that writes. Developers running Jev AI in production describe the same move again and again.
Agent routing
Choosing the tool, the agent or the branch before the big model burns a token on it.
Pre-LLMContext triage
Asking whether there is anything of concern in a long transcript, and passing on only what comes back positive.
Pre-LLMModeration and intent
Ticket triage, content flags and intent detection, where the answer was always a label.
ClassificationScoring and ranking
Lead qualification, review comparison, reranking — anywhere a number matters more than an explanation.
ScoringGuardrails on tool calls
Gating an action on a confidence you chose, and escalating everything underneath it.
SafetyReal-time loops
Game logic, control layers and anything else where ten decisions a second used to be unthinkable.
RealtimeMeasured
What one Jev AI call costs and how long it takes
Read off the usage field of a live request on 2026-09-21, not quoted from a launch post.
One call
594 ms, 464 input tokens, output free
Three typed questions on a short support ticket, one round trip. Output tokens are never billed, so the whole cost is the state and the criteria you sent — which is why up to four questions in one request cost the same as one.
See what plans costAnswers
Jev AI questions, answered
What people ask before they wire Jev AI into anything.
TypeSafe AI, which released it on 2026-09-15 as its first public System One model. Jevx is an independent tool built on that API and is not affiliated with TypeSafe AI.
It is BERT-shaped in what it hands back and nothing like BERT in what it costs you to use. This one is zero-shot: you point it at a brand-new label set by describing the labels, with no dataset and no fine-tune, and it reads the text with the comprehension of a far larger model.
No. It takes text only — a string, a JSON object or an array. Extract the text first and hand it the result.
No. It is a hosted API from TypeSafe, reached here through OpenRouter. Nothing is downloaded and nothing runs on your machine.
The model takes other languages, and English is where it is strongest and where every number quoted on this site was measured. Write your criteria in English even when the state you are judging is not.
Sub-second, and that is the part that changes what you can build: judgements that used to need a three-to-six-second model call now fit inside a request nobody waits on. Our own measured round trip was 594 ms for one call carrying three typed questions.
Stop reading about Jev AI and run one
Paste your own text, name the questions you branch on, and watch the probabilities come back. 200 decisions a day, free, no card — and a failed request costs nothing.