Jev in Practice: A Model That Delivers Decisions, Not Text

On 15 September, TypeSafe AI shipped Jev, the first System One model: no chat, no reasoning monologue, just typed decisions in milliseconds. The trigger for this post was a German-language practice video by Julian Ivanov that walks ten use cases, shows two apps built with the model, and talks openly about limits and data protection.

German-language practice overview from September 2026: two demo apps, how the model works, guardrails and model routing in a support bot, browser automation, data protection.

We already covered Jev in the week 38 digest, focused there on the marketing number of the week. This post is the full assessment: what the model is, what the first month of practice proved, and what any of this could run on our own hardware.

What Jev is

Three question types, nothing else. A Choice picks from at most 255 predefined options, for example the team that should own a ticket. A Score rates on a scale, for example how frustrated a customer is. A Noul answers yes or no with a probability, for example whether a message requests a refund. The docs trace the name to Kahneman: System 1, the fast intuitive judgment, against the slow deliberation of large reasoning models. The name is the program: Jev understands text, answers in typed form, and writes nothing.

Access runs through the TypeSafe API with a waitlist and, since 18 September, through OpenRouter as typesafe/jev-1.13: $0.042 per million input tokens, free output, a 32,000-token context, P50 latency of 0.27 seconds. The endpoint deserves attention: it is the Decisions API, not the OpenAI-compatible chat route, so existing chat SDKs do not work against it.

What is actually new

Decision models of this kind are as old as machine learning. It used to be one trained classifier per application, the label set cast in concrete, every change a retraining run. What is new in Jev is not the idea but the generalization. Questions are defined per request, the answer space sits inside the request, and new options need no training. The probabilities are trained with strictly proper scoring rules and are therefore calibrated by design, the cost sits at classifier level, while the quality approaches what an LLM-as-judge delivers.

The exemplary division of labor is what the build catalog calls Jev Engineering: an LLM writes, Jev decides, code acts. Readers of our write-up on the in-house stack will recognize the logic. We run it today with two models on our own hardware; Jev refines the same logic with a third, extremely cheap layer.

What the first month showed

The madewithjev.com catalog counted 473 projects and 107 guides on 22 September, one week after launch. The published cost numbers are the real reason to look:

All five runs together cost less than an espresso. Median per decision across 15 published runs: $0.000068. (Quelle: madewithjev.com, entries retrieved 22.09.2026)

The independent confirmations point the same way: OpenRouter's own Ori Eval measured Jev more than five times faster than the next fastest judge model on the platform, and the publication Every had 1,709 passages judged for under a cent. The example from the video, 724 live ads broken down by hook, format and CTA in half a minute, is on the list: 40 seconds, nine cents.

Guardrails and model routing in the support bot

The pattern behind the support bot in the video uses confidence as the switch:

The verified rebuild: 100 emails pre-classified in 1.42 seconds, 96 of 100 correct after the re-check, roughly 7 cents total. (Quelle: From Julian Ivanov's video, rebuilt after nutlope's fraud-detection run)

The published evidence is a fraud-detection run: 100 emails Jev pre-classified in 1.42 seconds, every prediction below 95 percent confidence routed to Kimi K3, 96 of 100 correct in the end, about 7 cents total. One caveat remains, stated in the video and across the community: the raw number beside the decision is not a promise. Two independent measurements, Samuel Sacco on 18 September and 8,000 judgments by Adil Muhammad Pervez, reach the same finding: the ordering of options is trustworthy, the calibration of the number itself is not. Anyone automating thresholds has to fit them on their own labels first, or the switch floats in nothing. For us this is also a guardrail question: the jaggedness docs list what the model cannot do, no counting, no date sequences, and adversarial text smuggled into the state can move the answer; our counter-patterns are in the agent-jacking post.

Browser automation on very little model

A build by Browser Use shows the extreme, at 17.9 thousand stars within a week: a browser agent where Jev picks the operation and the element from the page's numbered table at every step, one request for both decisions, with a small LLM only as the text supplier when something must be typed. The demo finds a flight from Zurich to London in 7.1 seconds for $0.0039, and median browser protocol calls dropped from 1,092 to 101. The failure next to it is just as instructive: without WebMCP, driving clicks only, the agent solved 25 of 49 tasks in the WebMCP benchmark; with WebMCP, where the site exposes its own tools as options, 49 of 49 at roughly one percent of the comparison cost. The quality of the decision space beats the quality of the model.

What Jev cannot do, and where data protection starts

Arithmetic, counting, date sequences: the limits stand openly in the docs. And the marketing has to survive measurement: the Lindfors counter-check over 24 Norwegian documents found a tie with DeepSeek V4.1 Flash without reasoning on stance classification, and real costs at one sixth to one fourteenth of the reference, not the advertised several-hundred-fold.

For running this in Austria, the question behind performance weighs heavier: Jev is a hosted US API, no EU region, no weights, no self-hosting, and no LiteLLM provider exists. Personal data and anything NIS2-relevant is therefore off the table, full stop. What remains is the contract in-house: the Python adapter puts the typed-answer API shape onto your own endpoints, and the pattern itself is open regardless.

Laya, the open answer

Two weeks after launch, Convai Innovations answered with Laya: Apache 2.0, 421 million parameters on ModernBERT-large, one forward pass per decision, measured at 32.8 milliseconds on a T4, up to 332 questions per second batched, plus a multilingual variant covering 100-plus languages. That fits comfortably on one of our own cards, alongside the running inference lane.

The model card is honest, and that is what makes it usable: on the typed-decisions benchmark the fine-tuned variant scores 0.766 against Jev's published 0.727, Brier 0.062 against 0.148; the Jev figures are third-party, not Convai's. The same card names the prices: the base checkpoint sits near chance without fine-tuning, 0.362 against 0.461 for the majority class, the probabilities are over-confident without a temperature fit, and on 77 options at once (Banking77) Laya falls to 0.425 against Jev's 0.870. The independent Luni benchmark dataset adds a warning against comparing across benchmark boundaries. Laya is not a finished Jev, it is a fast base we would have to specialize ourselves.