Jev is an AI model by TypeSafe AI that does not write text: you give it a context and typed questions, and it returns structured answers with probabilities. It can pick an option from a list, score on levels or answer yes or no. TypeSafe presents it as the first model in the category it calls System One.
A question from the app. Pick an answer.
Jev is an AI model made by TypeSafe AI.
Which of these tasks would you use Jev for?
An email is free text, and Jev does not generate text. That is a job for an LLM.
It is a decision between fixed options: Sales, Support or Billing. Exactly what Jev does.
Chatting means generating text, turn by turn. Jev does not converse: it returns decisions.
You give Jev a state (a text, a JSON or a list of texts) and one or more questions. Each question is one of three types. Choice picks an option from a set and gives the probability of each one. Score uses ordered levels, say from "not urgent" to "very urgent": it returns the probability of each level and a score that is the average of the levels weighted by those probabilities, so it can fall between two. Noul answers yes or no and returns the probability that it is yes.
Choice and Score also include a confidence score computed from those probabilities. Noul does not: 0.03 is a firm "no", not doubt; doubt sits near 0.5. How to read those numbers is in calibrated probability.
You can send several questions together about the same state. Each one is answered on its own: one answer does not feed another within the same call. If you need one result to build the next question, that is two calls.
This is the example from the TypeSafe quickstart: a support message and three questions, one of each type. Each question has a name you choose (department, frustration, is_urgent). The options go in criteria: in Choice, each one with its name and a description of what belongs there; in Score, the levels in order.
In the response below, department picked technical at 0.85 with a confidence of 0.78. frustration landed on level 1, "frustrated but civil". is_urgent came back 1.0: a firm yes and, like every Noul, with no separate confidence. Your code reads those fields and decides what to do.
{
"state": "Hi, I've been trying to connect my Stripe account for 3 days and the integration keeps failing. I'm losing sales. Please help ASAP.",
"model": "jev-latest",
"questions": {
"department": {
"type": "choice",
"instructions": "Which team should handle this",
"criteria": {
"billing": "Payment or subscription issues",
"technical": "Bugs or integration problems",
"sales": "Pricing or account questions"
}
},
"frustration": {
"type": "score",
"instructions": "How frustrated the customer appears",
"criteria": [
"Calm, just stating facts",
"Frustrated but civil",
"Very angry, strong language"
]
},
"is_urgent": {
"type": "noul",
"instructions": "The message conveys urgency or time-sensitivity"
}
}
}{
"model": "jev-1.13.0",
"answers": {
"department": {
"type": "choice",
"choice": "technical",
"confidence": 0.78,
"probabilities": {
"technical": 0.85,
"sales": 0.0,
"billing": 0.15
}
},
"frustration": {
"type": "score",
"score": 1.0,
"confidence": 1.0,
"legend": {
"0": "Calm, just stating facts",
"1": "Frustrated but civil",
"2": "Very angry, strong language"
},
"probabilities": {
"0": 0.0,
"1": 1.0,
"2": 0.0
}
},
"is_urgent": {
"type": "noul",
"noul": 1.0
}
},
"usage": {
"input_tokens": 392,
"output_tokens": 65
}
}The descriptions are not decoration: Jev weighs the text against the options you give it. With a bare label ("sales") it is left unsaid where one option ends and the next begins. TypeSafe recommends that, when two options are similar, each one says what it covers, what belongs to its neighbor instead and a few examples. It is what you would explain to someone new on the team.
An LLM can write emails, summaries or code, and also return structured data. Jev focuses on typed decisions and probabilities: it does not write answers, generate code or explain its reasoning.
The format is guaranteed: it cannot return a value outside the schema you asked for. Being right is not. It will pick a valid option, but it may be the wrong one. That is what the probabilities are for.
With the same message, you would ask an LLM to "reply only in JSON with these three fields" and get back something like the example below (illustrative, not an actual run). It looks similar, but it is text written token by token. Asking for JSON in the prompt alone does not ensure the format; some LLM APIs constrain it with a schema, and that still does not ensure being right. And it does not say what probability it gave each option: if you ask for a certainty number, it writes one, and it is not calibrated. A common setup combines them: Jev decides fast and, when confidence is low, the case goes to an LLM or a person.
And the name? Diogo Almeida, CEO of TypeSafe, said it comes from the Jevons paradox.
{ "department": "technical", "frustration": "Frustrated but civil", "is_urgent": true }It is for quick, bounded judgments: which team gets a ticket, whether a message asks for a refund, how urgent a complaint is. Your code decides what to do with the answer: act, ask for confirmation or hand the case to a person. In TypeSafe's Confidence page example, transfers require confirmation even with confidence above 0.9: Jev reads the intent and the code controls the operation.
It is not for writing, chatting or doing math: TypeSafe says it is not a calculator. It only reads text, so a photo or an audio clip has to become text first. And more context does not always help: irrelevant context can make the result worse. It is not trained on customer data or fine tuned per customer either: your business details go in the state and the instructions.
According to the TypeSafe docs, it costs USD 0.042 per million input tokens, and output is not charged. Each extra question also adds input tokens. A request allows up to 64k tokens in total, and the state plus the longest question, up to 32k. To run the numbers for your volume, see how AI cost is calculated.
English is its main training language and where it does best today. Other languages work, but not as well. If your texts are in another language, test it with your own real examples and watch the confidence before setting thresholds.
The current version is jev-1.13.0, with the alias jev-latest. Aliases move: if you tuned your thresholds on one version, pin that version.
There is an open alternative: Laya, by Convai Innovations, under the Apache 2.0 license. It answers the same Choice, Score and Noul questions, accepts the same request format as Jev and you can run it on your own computer, as a local model. Its confidence is computed differently: if you switch from one to the other, test your thresholds again on your data. And OpenAI has one of the same kind: the Decisions API, in public beta since October 2026.