Jev by TypeSafe, explained

What is Jev?

Jev is a decision model from TypeSafe. You give it a state, such as a message or a record, and one or more questions with a fixed set of answers. Jev picks an answer to each question and adds the probabilities.

TypeSafe calls Jev the first of its System One models: models that make fast, structured decisions software can use directly. They are built for automation, not for conversation. On OpenRouter⁠↗ the model is listed as typesafe/jev-1.13, available since mid September 2026 (the model page says 18 September).

If you search further, you will find sites that look like TypeSafe but are not run by TypeSafe. In our own test of AI search engines, ChatGPT cited such domains twice. The official sources are typesafe.ai⁠↗, docs.typesafe.ai⁠↗ and the Jev documentation on OpenRouter⁠↗. Everything in this article comes from those, or from our own work with Jev.

How is Jev different from a language model?

A language model writes text; Jev picks from options you define. According to TypeSafe, System One models do not write replies, produce code or explain their reasoning. You cannot use Jev as a chat model, and the usual chat completion SDKs do not work with it.

You can force a fixed shape on a language model too, with structured outputs or function calling. You are then asking a text generator to follow a schema. You get one answer, with no distribution over the other options. Jev does give you that distribution: a probability per option, plus a confidence value that says how concentrated those probabilities are. That makes it closer to an LLM classifier than to a chat model.

A language model remains the better choice when the answer has to be a sentence, a summary or a piece of code, or when you cannot write down the possible answers in advance. If you need to read afterwards why a choice was made, Jev will not help either, because it gives no explanation. Jev fits where you know the options and the same kind of judgement comes up again and again.

Which question types does Jev support?

Jev has three question types, which TypeSafe calls primitives. Every question gets a name, a type and an instruction.

• Choice answers which of these options? You list options with a short description. Jev returns the chosen option, a probability for each option and a confidence.
• Score answers which level? You describe an ordered set of levels yourself, for example from calm to very angry. Jev places the state on that scale, with probabilities per level and a confidence. The score can land between two levels.
• Noul answers is this true? You get one number between 0 and 1: the probability that the answer is yes. Noul has no separate confidence.

The documentation uses a support ticket as its example. The ticket is the state, and three questions are asked about it at once: a Noul (does the customer ask for a refund?), a Choice (what is the main request in the message?) and a Score (how frustrated does the customer sound?). Your own code then turns those three answers into an action, such as sending the ticket to the right team with priority.

Questions in one request are answered independently and in parallel. One question never sees the answer to another, so dependencies belong in your own code. If your Choice options do not cover every case, add one such as other or unknown. TypeSafe recommends this itself.

How do you call Jev?

You call Jev through the OpenRouter Decisions API with a regular OpenRouter key. You do not need a separate TypeSafe account. The endpoint is POST https://openrouter.ai/api/alpha/decisions. It is an alpha endpoint, separate from the chat endpoint.

A request has three top level fields: the model, the state and the questions. Here is the shape, following the OpenRouter tutorial⁠↗:

The response holds the result for each question name, the model that actually served the request and a usage block with tokens and cost in dollars. Always check in your code that the returned label is in your own list before you act on it.

There are three ways to name the model. typesafe/jev-1.13 is the current version, typesafe/jev-1.13-20260917 a fixed snapshot and ~typesafe/jev-latest an alias that follows the newest release. If you tuned thresholds on one version, pin that version. Plens runs on the snapshot from 17 September.

The model page lists a context window of 64,000 tokens, but a maximum of 32,000 prompt tokens per request and 3,000 requests per minute. The state goes to an outside provider. If that is not acceptable, read when to run your own AI models.

What does Jev cost?

According to OpenRouter, Jev costs $0.042 per million input tokens, and output is free. TypeSafe puts it as $42 per billion input tokens. You only pay for what you send: the state, the questions and the option descriptions. Our Plens measurement round of 123 answers, described further down, cost about half a US cent in total.

In its launch post⁠↗, TypeSafe writes that it cannot prove the price is not subsidised. The company expects prices to fall rather than rise, but that is an expectation. Do not build a business case on this one number, and check the current price on the model page.

What can Jev not do?

Jev is good at judgements about meaning and weak at anything that needs calculating, counting or ordering. TypeSafe lists the limits of jev-1.13 on a separate page⁠↗, last reviewed on 2 October 2026:

• Arithmetic and counting. "Jev is not a calculator", TypeSafe writes. Counting is unreliable, and errors grow with the count.
• Dates. Jev reads dates as text, not as ordered values. Ordering, durations and time windows are unreliable.
• Literal reading. Jev answers the question you wrote, not the one you meant. Negations and conditions are taken at face value.
• First option. With Choice, Jev leans towards the option listed first.
• Irrelevant state. The more unrelated detail in the state, the lower the accuracy.
• Hostile text. Jev does not treat the state as hostile by default. Injected instructions can shift an answer.
• Writing text. Jev is not trained for it.

The probabilities have a limit as well. According to TypeSafe, calibration is measured across groups of predictions and does not guarantee that a single answer is correct. Confidence says how concentrated the probabilities are, not whether it is safe to act. And Jev accepts text only: no images, audio or video yet.

In practice: arithmetic, planning and hard rules stay in code, and Jev makes the judgement in between. How to find those places is the subject of where Jev fits in your product.

How solid are the claims?

The headline numbers come from TypeSafe, measured on its own evaluations. Our own measurement is small and synthetic.

According to TypeSafe, Jev has "Zero Hallucinations" and is 193.6 times faster and 444.6 times cheaper on its own evaluations. The launch post mentions a response time of 70 to 500 milliseconds. "Cannot hallucinate" refers to the schema: Jev always returns one of the options you gave it. Whether that option is factually right is a separate matter.

In Plens, Jev has a narrow role. It decides one thing per question: which destination, which intent, whether to show a map or not. Arithmetic, planning and the decision rule itself stay in code. Since 10 October we ask the question in English, because Dutch works less well according to TypeSafe. The option dry is listed first on purpose, precisely because jev-1.13 leans towards the first option.

In ARCS, the platform we use for agentic engineering, Jev only runs in shadow mode: it compares its choice with that of the existing planner and does not change the routing. We do not yet have numbers on how often the two agree. More on ARCS is in the frequently asked questions.

Want to know whether Jev makes a decision in your product better, faster or cheaper? We are happy to measure that with your own examples. Get in touch.