The Model That Only Makes Decisions: What Is Jev and How Do You Use It?

When a support ticket comes in, we need to figure out whether the user has a payment problem, wants technical support, or has an issue with their account. When we call a frontier LLM for this, the model first generates text, and then we try to convert that text into JSON. The format sometimes breaks, a category we never defined can come back, and more time and money than necessary can be spent on a classification that is only a few words long.
Jev, developed by TypeSafe AI, treats this kind of task directly as a decision problem. You send the application's state and the questions you want answered; Jev returns probabilistic results whose types are determined in advance. For example, you can ask in a single request which category the ticket belongs to, how urgent it looks, and how angry the user is. Since the model's answer space is constrained on the code side, you don't need to parse the results separately.
This approach makes Jev resemble an intelligent function that can be called inside software. The latency and cost advantages are important, but in my opinion, this way of using it is what really differentiates the product.
What is Jev?
Jev has three basic question types:
Choice: Picks one of the options you define.Score: Scores a situation on a scale you define.Noul: Returns the probability that a statement is true, between 0 and 1.
Three question types may look limited at first glance. Jev's area of use is, after all, limited to the small, fuzzy decisions we constantly make inside software. Thanks to this limitation, you can wire the results into your application in a faster, cheaper and more controllable way.
A short TypeScript example:
import { choice, noul, score, TypeSafeClient } from "@typesafe-ai/sdk";
const client = new TypeSafeClient();
const result = await client.systemOne({
state: ticket,
questions: {
department: choice("Which team should handle this?", {
billing: "Payment and refund issues",
technical: "Bugs and integration problems",
other: "Anything else",
}),
urgent: noul("The customer needs an urgent response"),
frustration: score("How frustrated is the customer?", [
"Calm",
"Frustrated",
"Very angry",
]),
},
});
In this example, three different questions are evaluated in a single call and in parallel. Rather than being satisfied with describing the space the model can return in the prompt, you constrain it up front on the code side as well. Jev can still pick the wrong category, but it can't invent a fourth category you didn't define. So the hallucination risk shifts from producing an invalid output to picking the wrong one among valid options.
Why does the confidence value matter?
Along with its decisions, Jev also returns a confidence value. On the product side this value is quite important because not all decisions carry the same risk. We can't use the same confidence threshold for opening the user's balance screen and for approving a bank transfer.
async function handleRequest(message: string) {
const response = await client.systemOne({
state: message,
questions: {
intent: choice("What should happen next?", {
checkBalance: "Show the current balance",
approveTransfer: "Approve a money transfer",
other: "Anything else",
}),
},
});
const intent = response.answers.intent;
if (intent.confidence < 0.5) return routeToHuman();
if (intent.choice === "checkBalance") return showBalance();
if (intent.choice === "approveTransfer" && intent.confidence < 0.9) {
return askForConfirmation();
}
}
A lower threshold may be acceptable for a read-only operation. For a money movement, on the other hand, we expect higher confidence or ask the user for confirmation again. So when setting thresholds, you need to look at the cost of a wrong decision for the relevant action before looking at the model's overall success rate.
Should we leave everything to Jev?
Using Jev correctly starts with knowing which jobs not to leave to the model. It isn't reliable for operations like sorting dates, counting items and exact arithmetic; also, it doesn't produce text, code or summaries. Security rules, money calculations and date comparisons should stay in normal code. It is more appropriate to use Jev for narrowly scoped evaluations that are hard to express in code.
When you build a browser agent, a drone or a bot that takes automated actions, this boundary becomes even more important. Jev can tell you which action looks more sensible; the safety reflex, permission checks and the execution of the decision should still be the code's responsibility. In the end, the responsibility for a mistake in production won't belong to the model.
How big should the state be?
When using LLMs, we may think that giving more context will always improve the result. Jev makes decisions only based on the state you send, and filling this field with unnecessary data can distract the model and reduce accuracy.
So the right flow is this:
- Fetch the information you need with code or a search system.
- Filter out unnecessary fields.
- Send Jev only the state needed for the decision.
- In case of low confidence, use a human or a stronger model.
In this setup, Jev doesn't replace RAG or the search system; it becomes a cheap decision layer that runs after retrieval. You can't expect a correct decision to come out of a weak source. Garbage in, garbage out is still alive, bro, it's just that now it comes with a confidence value.
Where would I use it?
I would consider Jev for these jobs:
- Support ticket routing
- Content moderation
- Relevance checking of documents or search results
- Applying guardrails to LLM output
- Labeling and prioritization at very high volume
- Request flows that need to make a decision in under a second
And I wouldn't use it for these:
- Text or code generation
- Complex, open-ended reasoning
- Arithmetic, date calculations and counting
- Decisions that require presenting a written justification to an auditor
- Systems where a wrong decision directly triggers an irreversible action
According to the figures TypeSafe shares, Jev runs at much lower cost and latency compared to frontier LLMs. We shouldn't forget that these benchmarks are based on the company's own tests and haven't been independently reproduced yet. The claim of "zero percent structured output errors" also doesn't mean every decision is correct; it only says that the answer doesn't go outside the defined schema. Before moving to production, you should run evals on your own data and set thresholds based on those results.
Conclusion
It is more accurate to consider Jev a fast, probabilistic decision primitive that can be embedded in software. Instead of sending every request to a large model and generating long texts, you can use it directly for classification and scoring jobs with a well-defined scope.
Still, preparing the right state content, setting suitable thresholds for risky actions, keeping exact calculations in code, and safely halting the system in low-confidence cases are the developer's responsibility. When you don't ask the model for things the code can compute exactly, and use Jev for narrow decisions that are hard to express in code, it provides a meaningful architectural advantage.