Direct answer: Jev is an AI model from TypeSafe that makes decisions rather than text. You send one state and a set of typed questions, and Jev returns answers your code can read: one probability, one option from your list, or one value on your ladder. TypeSafe calls this class System One and released it on 15 September 2026.
It holds when: your question is closed, which means you write the answer space yourself. Limits: Jev writes no sentence, explains no reasoning, and performs no arithmetic.
We wrote this explainer from the official TypeSafe documentation and our own use on 20 and 21 September 2026. The prices and technical limits come from the official pages, not from memory.
Jev answers, it does not compose
A normal language model produces text. You ask for an answer, then your code reads a sentence and guesses the meaning. That guessing step is what usually breaks.
Jev removes the step. You write the question together with its answer space, and the answer comes back as data. There is no sentence to parse and no format to miss.
The 3 question shapes
Noul: a yes or no question
Noul returns one number between 0 and 1. That number is the probability the answer is yes. Example: "Does this message request a refund?". Source: the TypeSafe Noul page.
Choice: pick one from your list
Choice returns one option, a probability for each option, and confidence. You write the option list, up to 255 options. Write options that do not overlap, because that list decides the answer. Source: the TypeSafe Choice page.
Score: a value on your ladder
Score returns one value on an ordered ladder of 2 to 10 levels. The value is probability weighted, so 1.4 sits between level 1 and level 2. Source: the TypeSafe Score page.
All 3 can travel in the same request. The example below sends one customer sentence and 3 questions at once.
{
"state": "Pesanan saya belum sampai dan saya sudah menunggu 5 hari.",
"model": "jev-latest",
"questions": {
"minta_refund": { "type": "noul", "instructions": "Apakah pesan ini meminta pengembalian dana?" },
"tim": {
"type": "choice",
"instructions": "Tim mana yang harus menangani pesan ini?",
"criteria": {
"pengiriman": "Paket, resi, dan keterlambatan",
"tagihan": "Pembayaran, invoice, dan refund",
"teknis": "Aplikasi, akun, dan error"
}
},
"kekesalan": {
"type": "score",
"instructions": "Seberapa kesal penulis pesan ini?",
"criteria": ["Tenang", "Kesal", "Marah"]
}
}
}Confidence decides whether you may act
Every answer carries its own confidence number. Probability answers "how likely". Confidence answers a different question: "may my code act without a person".
That split is what makes a decision model usable in production. You set the threshold in code, for example 0.80 for an automatic action, and the rest goes to a human queue. Source: the TypeSafe confidence page.
TypeSafe writes that calibration is measured across groups of answers, not on a single answer. High confidence therefore does not guarantee that one answer is right.
What Jev does not do
Jev does not replace a generative model. They do different parts of the same flow.
| Job | The right tool |
|---|---|
| Write a reply for a customer | A generative model |
| Pick 1 route out of 3 | Jev |
| Add up an invoice | Plain code |
| Catch an invoice number | Fixed rules |
| Rate how frustrated a customer is | Jev |
| Compare 2 dates | Plain code |
TypeSafe publishes the weak edges of jev-1.13 itself, reviewed on 17 September 2026. The model reads literally, is weak at arithmetic, and degrades when the state is large and full of irrelevant detail. Source: the jev-1.13 jaggedness page.
Price and technical limits
| Measure | Value |
|---|---|
| Input token price | 0.042 USD per 1M tokens |
| Output token price | Free |
| Context limit | 64k per request, 32k for the state plus the longest question |
| Rate limit | 250,000 tokens per second, 1,200 requests per minute |
| Accepted input | Text, JSON objects, and arrays of text |
Every question in one request is evaluated in parallel, and the state is billed once. Stacking 12 questions into one call therefore costs less than 12 separate calls. Source: the TypeSafe models page and the fan-out pattern.
In our test one single question from Jakarta finished in a median of 760 milliseconds, network travel included.
When a decision model earns its place
Use a decision model when 3 things hold. First, your answer is closed. Second, the volume is large. Third, the decision repeats against the same rubric.
We used it on our own CRM assistant: 227 production conversations judged in 20.8 seconds for 0.0094 USD. The full story and the wiring are in our guide to auditing conversations with Jev.
Rama Digital recommends: start from the one decision you repeat most, not from the whole system. One correct rubric beats 10 half-written ones.
How to read the answer that comes back
A Jev answer uses a fixed shape, so your code reads it without extra guards. Each key inside answers carries the name you wrote in the request.
| Shape | Fields returned | How to use it |
|---|---|---|
| Noul | noul | Compare it with your threshold, for example 0.8 |
| Choice | choice, probabilities, confidence | Use choice for the route and confidence for the gate |
| Score | score, legend, probabilities, confidence | Round it when you need a level rather than a fraction |
| The whole request | usage.input_tokens | Multiply by the price to cost every run |
One detail matters. The question key is not sent to the model, so naming a question really_important changes nothing. Only instructions and criteria decide the answer.
The mistakes people make when writing questions
These 4 mistakes appear most often, and every one of them lives in the rubric rather than the model.
- A question about taste. "Is this reply good" carries no condition. Write a condition someone else can check.
- Overlapping options. When 2 options can both be right, the probability splits and confidence falls.
- Criteria that fight the instruction. The instruction asks for one thing, the criteria describe another, and the answer follows either.
- A state that is too fat. Sending a full customer history to judge one reply lowers the answer quality and raises the cost.
Test your rubric on 10 records whose answers you already know. When Jev and you disagree on more than 2, fix the rubric first. Source: the guide to building with System One.
Frequently asked questions
Is Jev a chatbot? No. Jev produces no sentence at all. It returns numbers, choices, and confidence that your code reads.
Does Jev work in other languages? Yes. The state and the questions may be written in another language, and in our test the answers followed the rubric we wrote.
How is it different from plain classification? Plain classification needs training data and a threshold you tune. Jev uses a rubric you write in sentences, then returns probabilities with their confidence.
Are the answers always identical? For the same state the answer is generally stable, but probabilities still move a little. That is why your cut-off belongs in code.
What does a trial cost? A small trial costs almost nothing. Our audit of 287 calls and 1,100 questions stopped at 0.0094 USD.
Next step
The remaining limit: a decision model gives numbers, not repairs. You still write the rubric, set the threshold, and change the system. We wrote about testing your own system in Chaos engineering for vibe coders.
If you want us to map the decision points worth handing to a machine, open AI Diagnostic. To talk it through first, pick an AI Diagnostic slot.
