Jev: intelligence becomes a software primitive

On 15 September 2026, TypeSafe AI released Jev, the first model in a class it calls System One Models. The launch starts with the right question: if models have been superhuman at chat for years, where is all the automation? TypeSafe’s answer is that the missing part is not more language. It is an interface software can depend on.

Jev does not write. It receives a state, a string or structured object containing the material to judge, and a set of typed questions. It returns only bounded answers and probability distributions. TypeSafe calls the result a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out. The exact architecture and the training method behind it remain closed. The output contract is public, usable and different enough to take seriously now.

The output contract is the product

An unconstrained chat model produces a string one token at a time, leaving the application to parse, validate and retry. Strict structured-output modes can also guarantee supported schemas, so schema safety is not exclusive to Jev. The distinction is the native interface: Jev gives up the string. The possible answers are declared before inference, every question is evaluated against the same state, and the model returns a bounded answer and probability distribution inside that answer space.

This is where the launch’s most repeated phrase needs precision. TypeSafe says Jev “can’t hallucinate.” In the narrow interface sense, the claim is coherent: a Choice over billing, shipping and account cannot invent a fourth department, malformed tool name or paragraph instead. One counterexample would falsify the type guarantee. Strict schema-constrained generation can provide the same protection on supported schemas. But hallucination has always bundled two failures together, making something up and getting something wrong. Jev removes the first from its output surface. It can still choose billing when the issue belongs to account, and it can do so with a sharply peaked distribution. TypeSafe’s own agent skill states the boundary better than the homepage: typed output guarantees the interface, not truth.

That is not a small reduction. A malformed value several layers down an automated dependency chain is not a conversational inconvenience. It is a software fault. Removing the fault class makes the model more composable, but it does not make the composition correct by construction.

Three judgments, ordinary code

TypeSafe exposes three primitives. Choice selects one member of a fixed set and returns the selected option, every option’s probability and a confidence value. Score places the state across two to ten authored levels and returns their distribution, its weighted position and confidence. Noul answers one yes-or-no proposition with the probability that it is true. It has no separate confidence field because one number already describes both sides of a binary distribution.

The names matter less than the division of labor. The model judges what the text means. Code owns everything code can know exactly: arithmetic, dates, thresholds, policy, side effects and how several judgments combine.

This is an argument against hiding a workflow in a prompt. Instead of asking a model to “review this support case and decide what to do,” the program asks whether a refund was requested, which team owns the issue, how frustrated the customer is and whether the evidence satisfies the refund policy. Jev evaluates those questions independently in one call. Code combines them into the action. Change the refund threshold and you change a number in code, not a paragraph whose other behavior may move with it.

The architecture is closer to a learned predicate engine than an agent. It fits inside a harness; it does not replace one. In our terms, the model supplies bounded judgment while the harness remains the half you own: the context, rules, permissions, execution and verification around it.

We put the contract on the wire

We used early access to run a bounded smoke test from an Amp Orb on 22 September, pinned to jev-1.13.0. Across 80 requests, mixing Choice, Score and Noul, every answer returned under the requested ID, every Choice stayed inside its declared options, every Score stayed inside its authored scale, and every returned distribution summed to one. That is 80 schema-conformant responses, not a proof of mathematical impossibility, but it is direct evidence that the public contract behaves as described.

The clearest result was the shape of parallel work. We evaluated one support state with six questions, three Nouls, two Choices and one Score, five times as one request and five times as six sequential requests. The batched request had a median client-observed time to response headers of 165 milliseconds. Summing the six individually timed sequential requests produced a median of 690 milliseconds, 4.2 times the batched timing on that metric. Batching used 695 input tokens against 2,735, a 3.9 times reduction, because the state crossed the wire once instead of six times. The answers were semantically identical in every run. Across the whole 80-request exercise, 34,893 input tokens cost about $0.00147 at TypeSafe’s published $0.042 per million input tokens; output is currently unmetered.

We also repeated an intentionally underspecified return question fifteen times. Jev chose information every time, with confidence between 0.99 and 1.00, because “what are my options” is, under the exact rubric we supplied, an explicit request for information. A clearer multi-intent case, “exchange them or refund me, whichever is faster,” spread its answer across the choices and returned confidence of 0.37. That contrast is more useful than a clean demo. Uncertainty is shaped by the question and answer space the developer authors. A confident answer can reveal that the rubric made a distinction crisp; it does not establish that the rubric asked the right thing.

Three deliberately tiny edge cases, counting fruit, ordering two dates and multiplying 17 by 24, all came back correctly in five runs each. TypeSafe explicitly documents arithmetic, counting and date comparison as Jev 1.13 weaknesses, and fifteen toy successes do not overturn that warning. A simple instruction-injection sentence also failed to redirect five account classifications, but the same documentation says state is not treated as hostile by default. A smoke test can confirm the interface and expose behavior worth investigating. It cannot turn a model limitation into a security guarantee.

Uncertainty becomes an interface

The deeper claim is not speed. It is that uncertainty can become part of software architecture. For a Choice or Score, Jev returns the full distribution and a confidence statistic derived from how concentrated that distribution is. For a Noul, the probability itself carries the uncertainty. Code can act on a clear low-stakes decision, request confirmation on a narrower margin, and route an uncertain or consequential case to a person or a reasoning model.

This is where two words that look interchangeable are not. A model’s returned confidence describes the concentration of its answer distribution. Calibration is an empirical property across many labeled outcomes: cases assigned 0.8 should be correct about 80 percent of the time. A single confidence of 1.0 proves only that the model concentrated its distribution, not that the answer was right. TypeSafe says it trains Jev with Reinforcement Learning for Calibrated Decisions, RLCD, so higher reported probability corresponds to higher observed accuracy. That is the claim that would make unattended automation possible, and it is also the claim the public evidence has not yet established independently.

The current workflow evaluations use four programs built by TypeSafe’s own model-capabilities team and compare predictions with reference probabilities averaged from GPT-6 Astra and Claude Fable 5.1. They are more realistic than a standard multiple-choice benchmark, and TypeSafe publishes unusually useful caveats: its own people built the workflows, the reference models introduce their own bias, and competing LLMs run through TypeSafe’s adapter. But the labels are still model consensus rather than independently adjudicated ground truth, and the headline 193.6 times faster and 444.6 times cheaper remains a vendor result on a vendor-designed harness.

Where this honestly stands

Jev 1.13 is an early-access, hosted, text-only model. It has a 64,000-token request limit, with a separate 32,000-token bound on the state plus the longest question, and TypeSafe says English is where accuracy is best. The published rate limits are explicitly moving. Model aliases move too, so an operation with tuned thresholds should pin a version and regression-test before upgrading.

The jaggedness document is the most credible page in the release. Jev reads literally, loses accuracy under indirection and irrelevant context, does not count or calculate reliably, can be moved by adversarial state, and does not guarantee that equivalent phrasings obey the probability identities a person expects. A proposition and its negation do not have to sum to one when asked as separate questions. A Noul and a yes-or-no Choice are different evaluations. Every one of those edges lands back on the builder: retrieve narrowly, ask one judgment at a time, test on domain data, keep invariants in code and never treat a semantic classifier as a security boundary.

There is no published architecture paper, parameter count, RLCD reward specification, calibration curve, expected calibration error or independent replication of the workflow results. The public adapter is useful code, but it adapts conventional LLMs into the System One response shape for comparison; it is not Jev and does not reveal Jev’s internals. LangChain’s integration confirms that the primitive is already useful enough to wire into model routing and tool-call review. It does not verify the model’s accuracy or calibration.

Both readings can be true. TypeSafe has built a genuinely different interface to learned judgment, and the evidence for its strongest model claims is not mature yet.

What to do with this

Do not ask first whether Jev can replace the model you chat with. It cannot, and that is the point. Look instead for places where software currently asks a generative model for a small decision, then parses the answer and hopes the prose did not wander: routing, classification, verification, ranking, guardrails and feature extraction. Those are the candidate seams.

At each seam, write the policy before the prompt. Define the allowed answers, the cost of each error, the cases that must abstain, and the deterministic work that stays in code. Build a labeled evaluation from your own traffic. Test probability and calibration by action class, not only aggregate accuracy. Pin the model once thresholds matter. Log the full distribution and the version that produced it. Treat untrusted state as untrusted even when the output is typed.

Jev’s important move is to make that discipline the native shape of the call. The model no longer owns the sentence, the workflow or the action. It owns one bounded judgment. Everything around it remains software, visible and governed. If calibration survives independent testing, that is not a faster chatbot. It is a new primitive.