Jev and the Missing Interface Between AI and Software

Picture a support ticket arriving while an app is processing hundreds of requests. The software needs to decide which team should see it, whether the message sounds urgent, and whether a policy applies. A large language model (LLM)—an AI model trained to understand and generate text—can make those judgments, but it usually returns prose. The program then has to parse that prose, validate the fields, and decide whether the answer is trustworthy.

On September 15, 2026, TypeSafe AI announced Jev, its first System One model. The pitch is not another chatbot. Jev is designed to return typed, probabilistic decisions that software can consume directly. The useful question is what a System One model changes: instead of treating text as the universal interface, it treats a structured judgment as the interface.

Strings are a poor software contract

An LLM’s natural output is a string. That flexibility makes chat models useful for writing, brainstorming, coding, and explanation, but strings are a loose contract for software. Even when a model is instructed to return JSON, the application still has to parse the response, check that the fields exist, and handle malformed or unexpected values.

Jev takes a different path. Its output is type-safe, meaning the answer always follows the data shape the developer declared. A question can allow only billing, technical, or account, for example. The model cannot invent a fourth label or return a paragraph where the program expects a value.

That prevents type errors and malformed structures by construction. It does not make every judgment correct. A model can still misunderstand an ambiguous message and choose the wrong allowed option. The important difference is that the mistake arrives in a form the surrounding software can inspect, measure, and route.

The phrase can’t hallucinate also needs careful reading. A hallucination is a plausible-sounding but false claim. Jev avoids the free-form text behavior that lets a model invent fields, unsupported labels, or imaginary tool calls, but semantic mistakes remain possible. Confidence and probability are there to expose that uncertainty rather than hide it behind fluent prose.

What is a System One model?

The name draws on Daniel Kahneman’s distinction between fast, intuitive System 1 thinking and slower, deliberate System 2 reasoning. System One models are aimed at focused judgments: the kind of decision a knowledgeable person could make quickly when given the right context.

A System One model still understands natural-language input. The difference appears in what comes out. Instead of asking for a long explanation, you give the model a state—the information being evaluated—and a set of typed questions about that state.

TypeSafe organizes those questions around three primitives. Choice selects one option from a fixed set. Score places the state on an ordered scale, such as calm, frustrated, or angry. Noul answers a yes-or-no question by returning the probability that the statement is true.

The current Python software development kit (SDK), a library for calling the service from code, makes the pattern look like this:

from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

state = {
 'message': 'The invoice was charged twice and I need a refund.',
 'customer': {'plan': 'pro'},
}

with TypeSafeClient as client:
 response = client.system_one(
 state=state,
 questions={
 'team': Choice(
 instructions='Which team should handle `message`?',
 criteria={
 'billing': 'Charges, invoices, refunds, or subscriptions',
 'technical': 'Bugs or integration problems',
 'account': 'Login, permissions, or profile issues',
 },
 ),
 'urgent': Noul(
 instructions='Does `message` express urgency or time pressure?',
 ),
 'frustration': Score(
 instructions='How frustrated does the customer appear in `message`?',
 criteria=[
 'Calm and matter-of-fact',
 'Frustrated but civil',
 'Very angry or threatening to leave',
 ],
 ),
 },
 )

team = response.answers['team']
if team.confidence < 0.75:
 route_to_human_review(state)
elif team.choice == 'billing':
 route_to_billing(state)

One request can mix all three question types. The response contains a selected choice, a numeric score, or a yes probability, depending on the primitive. For Choice and Score, it also includes a probability distribution: a table showing how likely each allowed option or level appears to be.

The same model is available through TypeSafe’s application programming interface (API), including the POST /v1/systemone endpoint. The SDK examples use jev-latest as the model name.

Why parallel decisions change the economics

Most chat models are autoregressive. That means they generate one token at a time, with each token depending on the previous one. A response that contains several decisions may therefore spend time generating words that the application never needed.

Jev is designed around parallel evaluation. Independent questions that use the same state can be sent together and evaluated at the same time. Asking whether a ticket is urgent, which department owns it, and how frustrated the customer sounds does not require three separate conversational exchanges.

That design supports speculative fan-out: asking every narrow question a workflow might need, then letting ordinary code ignore the answers that do not apply. It also makes a map-reduce pattern practical for large datasets—apply the same judgment to many records, then aggregate the resulting scores or labels.

TypeSafe’s launch materials describe end-to-end response times between 70 and 500 milliseconds, while its documentation describes most queries as taking around 100 milliseconds. Real latency still depends on network distance, state size, service load, and the number of requests. Even with those caveats, the target is different from a model meant to write a long answer for a person to read.

Confidence turns uncertainty into code

A probability is useful only when it has a sensible relationship with reality. Calibration is the property that makes this possible. Across many predictions, outcomes assigned a probability of 0.8 should be correct roughly 80 percent of the time. That is a group-level behavior, not a guarantee about one particular answer.

TypeSafe returns full probabilities for Choice and Score, along with a confidence value that summarizes how concentrated the distribution is. A distribution spread across several options signals uncertainty. A distribution concentrated on one option signals a clearer judgment. Noul returns the probability of yes directly.

This gives software a control signal. High-confidence, low-risk decisions can run automatically. Medium-confidence decisions can request confirmation or collect more evidence. Low-confidence decisions can go to a person or a more capable reasoning model. The threshold should reflect the consequence of failure: opening the wrong support screen is different from approving a bank transfer.

RLCD changes what the model is trained to do

The technical idea depends on a different training objective. Reinforcement learning from human feedback (RLHF) trains models toward responses people prefer. Reinforcement learning with verifiable rewards (RLVR) rewards outputs that can be checked programmatically, such as a mathematical answer or a passing test.

TypeSafe calls its approach Reinforcement Learning for Calibrated Decisions (RLCD). The target is not an impressive paragraph. It is a decision whose allowed form is known in advance and whose probability reflects observed accuracy. The model is therefore trained around the contract that software needs.

That makes Jev narrower than a general-purpose LLM in one dimension and more useful inside applications in another. It is a good fit for routing, classification, scoring, moderation, verification, guardrails, and ranking candidates. It is not meant to replace open-ended writing, code generation, long explanations, or autonomous planning.

A practical system can use both kinds of models. An LLM might draft an answer, while Jev checks whether the cited source supports it, detects a prompt injection, or decides whether a human review is required. The LLM supplies breadth; the System One model supplies bounded judgments that ordinary code can compose.

The larger idea behind Jev is not that chat has stopped mattering. It is that chat may be the wrong interface for much of the work software needs AI to perform. TypeSafe is betting that intelligence becomes far more useful when it behaves like a dependable programming primitive: constrained enough to inspect, fast enough to call in a request path, and honest enough to say when the evidence is thin.