What Is Jev? TypeSafe's Decision-Only Model Explained

Quick answer
Jev is TypeSafe AI’s hosted decision model: a state and typed questions go in, choices, scores, and yes/no probabilities come out.
It is not a chatbot and does not generate prose. It evaluates every declared question against the same state in one pass.
TypeSafe calls it a System One model: fast, bounded judgment rather than multi-step reasoning.
Published pricing is $0.042 per million input tokens with no charge for output tokens, and the vendor reports 70-500 ms latency.
It fits routing, triage, tool-call judgment, and verification. It is weak on arithmetic, dates, and open-ended reasoning.

What is Jev?

Jev is a decision model from TypeSafe AI, launched in September 2026. You send it a state, which is any text or JSON your application already has, and a dictionary of questions. Each production question is a Choice, a Score, or a Noul, which is a yes/no probability; Jev 1.14 also has a preview Box type for locating an object in an image. The response contains one typed answer per question, with probabilities for choice and score answers, confidence where the type provides it, and no generated text to parse.

TypeSafe describes Jev as a System One model, borrowing the fast, automatic mode of thinking from Kahneman’s framing. The name is a positioning statement as much as a technical one: the model is meant to sit inside a request path making many small judgments, while a language model handles the slower reasoning and the language. That distinction is the useful way to decide whether Jev belongs in a given part of your app.

How does a Jev request work?

A request has three parts: the state, the model name, and the questions. The questions are evaluated independently and in parallel against the same state, so adding a question barely changes response time. That design is why Jev can answer several judgments about one ticket in a single call instead of making one model call per field.

The response is keyed by the question IDs you supplied. A Choice answer contains the selected option, the probability of every option, and a confidence value. A Score answer contains a numeric position on the rubric, the probability of each level, and confidence. A Noul answer contains a single probability between zero and one. Your code decides what to do with each one.

{
  "model": "jev-1.14.0",
  "state": "Our API integration returned 500s for 20 minutes and we cannot process orders.",
  "questions": {
    "department": {
      "type": "choice",
      "instructions": "Which team should handle this?",
      "criteria": {
        "billing": "payments, invoices, refunds",
        "technical": "bugs, outages, integrations",
        "sales": "pricing, plans, upgrades"
      }
    },
    "urgency": {
      "type": "score",
      "instructions": "How urgent is the customer's problem?",
      "criteria": ["no impact", "minor", "major", "critical"]
    },
    "is_urgent": {
      "type": "noul",
      "instructions": "Does the message convey time-sensitivity?"
    }
  }
}

What does “cannot hallucinate” actually mean?

TypeSafe’s claim is narrower than it sounds. Jev cannot return a value outside the schema you declared, so it cannot invent a department or produce a score outside the rubric. That is a real engineering benefit: the output is always valid for your parser. It is not a guarantee that the selected option is correct, and it does not stop the model from choosing the wrong valid label.

TypeSafe publishes a limitations page for the model, and the failure modes are the ordinary ones for a semantic classifier. It can be literal, weak on numeric precision and date comparison, distracted by large amounts of irrelevant state, and influenced by adversarial text in the input. Those are reasons to keep arithmetic in code, send only relevant context, and test on inputs that resemble the ones you actually receive.

Where is Jev a good fit?

Jev is strongest where the decision is a bounded semantic judgment over text you already have. Routing a support ticket to the right queue, deciding whether a tool call is destructive or off-task, judging whether a generated answer is supported by a passage, ranking retrieval results, and checking whether a response satisfies a policy are all in scope. Those tasks need a label, not an explanation, and they need to happen often enough that latency and price matter.

It is also a natural fit for a guardrail beside a coding agent. Before the agent runs a shell command or writes a file, send the task, the plan, and the pending action to Jev and ask whether it is irreversible, off-task, or outside the declared scope. The model returns probabilities; your code decides whether to hold the action. The model recommends, and the policy still lives in code.

Where is Jev the wrong tool?

Jev cannot write the reply, explain the decision, summarize a document, or generate code. It is not a reasoning model for multi-step problems, and it is not reliable for arithmetic, counting, or date math. If your task needs any of those, use a language model or ordinary code, and use Jev only for the classification-shaped part of the workflow. Trying to replace an LLM with Jev usually produces a worse system and a harder debugging problem.

A single wrong decision that is expensive and rare is also a bad fit. The economics that make Jev attractive assume many decisions, where a cheap call and a confidence gate beat a frontier model call. At low volume, the evaluation work is the same and the savings are negligible. Use the simpler tool until volume makes the decision layer worth building.

How is Jev priced and accessed?

TypeSafe lists Jev at $0.042 per million input tokens, with output tokens free. That is dramatically cheaper than a frontier model per call, but the number that matters is cost per decision: the state and question text are the input, and a long ticket with many questions costs more than a short one. At high volume, even a small per-call price becomes a budget line worth monitoring.

Access is through the TypeSafe console, the official Python and JavaScript SDKs, or the HTTP endpoint at api.typesafe.ai. The model is also available through some gateways. Access terms and free credit have changed since launch, so check the console rather than relying on a launch-week post. For production, pin a version such as jev-1.14.0 instead of the moving jev-latest alias, and log which version answered.

Jev is a shared model. TypeSafe does not fine-tune it on customer data, so you adapt it through the state and question criteria rather than a per-account training job. If your task needs per-customer fine-tuning, that is a reason to look at Laya or a vendor service that offers it, not a limitation you can configure away.

Where this bites vibecoders
The tempting mistake is to treat Jev as a cheaper LLM and send it a prompt: “reply with the department as JSON.” That throws away the interface that makes it useful. Declare the options, ask one atomic question per field, read the typed answer, and put the threshold in code. The second mistake is trusting the answer because it is typed. A valid label can still be the wrong label, so the confidence gate and the fallback path are part of the integration, not an optional refinement.

Where AI coding assistants get this wrong

Prompting Jev like a chat model instead of declaring typed questions.
Putting several judgments into one question, which makes the answer hard to threshold or debug.
Using the jev-latest alias in production and losing the ability to reproduce a decision.
Treating a schema-valid answer as a correct answer.
Asking Jev to do arithmetic, compare dates, or reason through several steps.
Letting a high-confidence routing answer authorize an irreversible action without a code-level check.

Checklist

Write the decision as one or more atomic choice, score, or noul questions.
Give every option a description that distinguishes it from the others.
Use a pinned model version in production and log it with each decision.
Set a confidence threshold and a fallback for answers below it.
Keep arithmetic, permissions, and side effects out of the model.
Measure accuracy and calibration on your own labeled inputs before launch.

FAQ

Is Jev an LLM?

No. It is a decision model that returns typed values and probabilities instead of generating text. It does not write prose, hold a conversation, or follow open-ended instructions. That is the point: the narrower output contract makes it faster and cheaper for classification-shaped work, and useless for generation.

Can Jev write code or review a pull request?

Not directly. It can answer bounded questions about code, such as whether a diff appears to include a test, whether a command is destructive, or whether a change matches a rule. The code generation and the explanation still come from a language model or a human. Jev is the judgment layer beside those tools, not a replacement for them.

How much does Jev cost?

TypeSafe lists $0.042 per million input tokens and no charge for output tokens. Cost per decision depends on how much state and question text you send, so a long document with many questions costs more than a short ticket. Model the cost on your own average input size rather than multiplying the headline rate by request count.

What is a noul?

A noul is Jev’s yes/no question type. It returns a probability between zero and one that the statement is true, such as the probability that a message conveys urgency. Your code chooses the threshold. Because it is a probability rather than a label, you can decide whether a false positive or a false negative is more expensive for that particular question.

Does Jev support images?

Yes, in preview. Jev 1.13 and 1.14 accept images when the request includes the TypeSafe-Danger-Zone-Images: true header, and Jev 1.14 adds Box questions that return a bounding box. TypeSafe calls these features dreamer-ready rather than production-ready, so validate them on your own images and keep a production multimodal model as a fallback.

Can Jev replace my LLM?

Only if every output your app needs is already a closed choice, score, or yes/no answer. Most apps also need text: a reply, an explanation, a summary, or code. The efficient pattern is to use Jev for the branch and keep the LLM for the branch that needs language, rather than forcing all work through one model.