TypeSafe Jev explained: a System One model for software

An if statement has no use for a confident paragraph. It needs a value.

That is the cleanest way to understand TypeSafe Jev. Give the model some state and a set of typed questions. It returns Choice, Score, or Noul answers, along with probabilities your software can inspect. It does not write an email, explain its chain of thought, or keep a chat going.

Jev is TypeSafe AI's first public System One model. The name borrows Daniel Kahneman's distinction in Thinking, Fast and Slow: fast judgments on one side, slower deliberation on the other. TypeSafe has turned that distinction into a product boundary. Jev is for narrow decisions inside software. Language models remain the tool for prose, code, planning, and open-ended reasoning.

That boundary is more interesting than the launch slogan.

This is the overview for a seven-part Jev series on oguzhan.co. The daily posts will examine the primitives, confidence and RLCD, speed and price, agent guardrails, context compaction, the Doom and Wikiracing demos, and the fast-growing list at cobanov/awesome-jev.

What Jev actually returns

TypeSafe AI introduced Jev in September 2026 after two years in stealth. Founder Diogo Almeida's pitch is aimed at machines consuming intelligence, rather than people reading model output.

The request has two main parts:

1. state: a string, JSON object, or array of text containing the material to judge. 2. questions: named instructions with one of three answer types.

Those answer types are small on purpose:

Choice selects from a closed set and returns the selected option, a probability distribution, and confidence.
Score places the input on ordered rubric levels, with probabilities and confidence.
Noul returns the probability that a yes/no proposition is true, expressed as a number from 0 to 1. It has no separate confidence field.

Several questions can share the same state in one call. The model evaluates them in parallel, including a mix of Choice, Score, and Noul. Your application then owns the policy: accept a high-confidence route, send a doubtful case to review, reject an unsafe action, or use the result to prepare another request.

No prose has to be parsed. No improvised label can appear outside the options you supplied.

That is type safety. It is not truth.

The “no hallucination” claim needs a footnote

TypeSafe says Jev cannot hallucinate. Read the claim narrowly.

Jev cannot invent a fourth department when a Choice allows only sales, billing, and support. It cannot answer a Noul question with a story. The output stays inside its declared shape. A conventional chat model can be constrained with a JSON schema, but it still generates a string token by token before the application receives the result.

Jev can still choose the wrong department.

It can assign a high risk score to a harmless order, miss personally identifiable information, or report 0.9 for a false proposition. The Register's Thomas Claburn made the same distinction in the launch coverage: comparing a typed decision model with a natural-language model changes what “hallucination” means.

TypeSafe's own jev-1.13 jaggedness notes are useful here. They list weak counting and arithmetic, brittle date comparisons, literal readings of instructions, distraction in large state, adversarial content, and broken relationships between related questions. A Noul and a yes/no Choice about the same subject need not satisfy the neat identity you expected.

Keep arithmetic in code. Filter bloated state before sending it. Test each primitive and threshold on labeled examples from your own traffic.

Why build this instead of better structured output?

Chat models are general string machines. That generality is valuable when the output is for a person, or when the task needs exploration. It also carries costs that become obvious inside a high-volume workflow.

A ticket router does not need three paragraphs explaining why billing should handle a refund. A moderation gate does not need a conversational preamble. An agent deciding whether to run a tool needs a bounded risk signal quickly enough to remain inside the loop.

TypeSafe's bet is that these jobs deserve a model and sampler designed around decisions from the start. Its training method is called RLCD, or Reinforcement Learning for Calibrated Decisions. The stated goal is probability estimates that honestly reflect uncertainty, rather than prose optimized for human preference.

I have not found an independent reproduction of the complete RLCD stack. For now, RLCD is TypeSafe's account of its training system, not a public recipe with outside validation.

Confidence needs the same restraint. For Choice and Score, TypeSafe derives confidence from the returned probability distribution. A sharp peak produces a higher score; a flat distribution produces a lower one. It is not a second model checking the first. More important, TypeSafe does not choose what 0.72 means in your product. You do.

A support queue may safely auto-route at a threshold that would be reckless for a payment, deletion, or external email. Calibration belongs to the workflow.

The benchmark numbers are company numbers

TypeSafe published workflow evaluations in which Jev sits on much of the reported speed-cost Pareto frontier. The largest figures on the company material are about 193.6 times faster and 444.6 times cheaper than LLM baselines in that harness.

Those numbers need their surrounding paragraph.

The workflows were built by TypeSafe's capabilities team. Reference probabilities came from larger external systems, described in the launch material as an average of GPT-6 Astra and Fable 5.1. The comparison models were wrapped in a System One-compatible interface so that they returned comparable decisions. That wrapper can cost more than asking a model for ordinary free-form output.

Agreement with two large models is not ground truth. It is agreement with two large models.

The result is still worth examining because the interface and sampling approach are genuinely different. It just does not settle accuracy for your fraud queue, support archive, or agent policy. Re-run the comparison on those.

Price, latency, and version labels

At launch, TypeSafe listed Jev at $0.042 per million input tokens, with output priced at zero, and reported end-to-end latency of roughly 70 to 500 ms on its service. OpenRouter listed typesafe/jev-1.13 at the same input and output prices. TypeSafe's model documentation described a 64k total request budget, with 32k available to state plus the longest question.

The headline is striking. The comparison is also unusual: a parallel decision model returning a few fields is being measured against models that may generate long reasoning or tool traces.

Pin the model version when testing. jev-1.13.0 names a target; jev-latest moves. Record the provider too:

OpenRouter: typesafe/jev-1.13
Vercel AI Gateway: typesafe-ai/jev
Cloudflare Workers AI: typesafe/jev

Vercel exposed Jev through AI SDK 7's experimental evaluate API on 16 September 2026. Its Boolean type corresponds to TypeSafe's Noul. Cloudflare's model page uses the original Noul name.

Provider IDs and response wrappers differ. A benchmark that silently changes either one is not a benchmark you can reproduce.

Doom is a latency demo, not a vision demo

Jev playing Doom was the launch clip built for sharing. The qualification matters more than the clip: the bot reads structured game state represented as text. It does not look at pixels.

TypeSafe reports roughly ten queries per second in the demo and an estimated cost near $7 per hour at that rate. A classical game bot can play Doom better. The useful point is that a typed model can repeatedly choose actions against changing state without producing a sentence between frames.

Wikiracing tests a different edge. Jev's Choice type is capped at 255 options, while a Wikipedia page may contain far more links. The demo uses a two-stage score-then-choose pattern for larger sets. Keeping the final selection inside real links avoids a free-text model inventing a destination during a multi-hop run.

Neither demo proves general intelligence. One demonstrates reactive decisions under latency pressure. The other demonstrates constrained navigation over a large candidate set.

That is enough. Demos become less useful when made to carry claims they were not built to support.

The community arrived quickly

The public map at cobanov/awesome-jev had already passed 100 community projects in the 19 September research notes. A few groups show where developers think the interface fits:

Agent checks: jev-guard scores tool calls into allow, ask, or deny; is-malicious examines source and CI files before execution; Canny challenges coding agents that claim a task is finished without evidence.
Context compaction: projects such as fast-jev-compaction use typed decisions to rank what should remain in an agent's working context.
Local clients: the official JavaScript and Python SDKs sit beside smaller Ruby, Python, Zod, and command-line wrappers.
Open experiments: LitJev, openjev, kev, and NanoJev explore similar decision heads on open models.

The last group should not be described as a reproduction of TypeSafe's private RLCD system. They are independent experiments around the same product shape.

Where Jev belongs

Use Jev when the question is narrow, the allowed answer space is known, latency matters, and application code can own thresholds. Intent routing, triage, rubric scoring, moderation gates, citation checks, agent tool selection, and map-reduce classification all fit that shape.

Do not use it for an essay, an open-ended plan, creative work, or several steps of reasoning disguised as one question. Do not use it as a calculator. Do not treat a schema-valid answer as an audit result. A high-impact action still needs deterministic checks and, where appropriate, a human path.

The practical architecture is simple:

1. Turn the current object or event into state. 2. Ask narrow Choice, Score, and Noul questions in parallel. 3. Apply product-specific thresholds in code. 4. Escalate uncertainty. 5. Measure false positives and false negatives on real examples.

Jev is not “a cheaper GPT.” It is a decision layer that gives control back to the program around the model. That is a smaller claim, and a more useful one.

Seven days of Jev on oguzhan.co

This overview is day 0. The series ran from 20 to 26 September 2026, and every part is live:

If you only read one, start with the primitives post. It covers the smallest useful unit: one typed question.

Every Jev post on oguzhan.co, with a suggested reading order, is collected on the Jev hub.

Sources

Related: start with Jev primitives: Choice, Score, and Noul, then Jev confidence and RLCD for calibrated routing.

Oğuzhan Koçaklı

Oğuzhan Koçaklı writes and advises on AI engineering, agents, GenAI products, and applied ML. Daily digests and deep dives in EN + TR at oguzhan.co.

All posts

LitJev and TypeSafe Jev: System One decisions for software