--- title: "LitJev and TypeSafe Jev: System One decisions for software" description: "Jev returns typed Choice, Score and Noul answers with probabilities, not prose. Pricing, 70-500 ms latency, the Doom demo and open experiments like LitJev." canonical_url: https://www.oguzhan.co/typesafe-jev-system-one-decision-model/ author: "Oğuzhan Koçaklı" author_url: https://www.oguzhan.co/about/ date_published: 2026-09-19T08:26:56+00:00 date_modified: 2026-10-09T07:21:13+00:00 language: en translations: tr: https://www.oguzhan.co/tr/typesafe-jev-system-one-karar-modeli/ --- # LitJev and TypeSafe Jev: System One decisions 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](https://github.com/cobanov/awesome-jev). ## What Jev actually returns TypeSafe AI [introduced Jev](https://typesafe.ai/blog/introducing-system-one-models-and-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](https://www.theregister.com/ai-and-ml/2026/09/16/typesafe-ai-debuts-model-for-machines-that-plays-doom/5296711) 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](https://docs.typesafe.ai/model-jaggedness/jev-1.13) 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](https://vercel.com/changelog/typesafe-ai-jev-now-available-on-ai-gateway). Its Boolean type corresponds to TypeSafe's Noul. Cloudflare's [model page](https://developers.cloudflare.com/ai/models/typesafe/jev/) 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](https://github.com/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: 1. [**Primitives:** what Noul means, plus Choice, Score and the state-plus-questions API](https://www.oguzhan.co/jev-primitives-choice-score-noul/) 2. [**Confidence and RLCD:** calibrated probabilities, thresholds and jaggedness](https://www.oguzhan.co/jev-confidence-rlcd-calibrated-decisions/) 3. [**Speed and cost:** the parallel sampler, 70-500 ms claims and pricing](https://www.oguzhan.co/jev-speed-cost-parallel-sampler/) 4. [**Agents and guardrails:** jev-guard, Canny, is-malicious and safe fallbacks](https://www.oguzhan.co/jev-agent-guardrails-schema-valid-not-safe/) 5. [**Context compaction:** what the model may rank and what code must preserve](https://www.oguzhan.co/jev-context-compaction-verbatim-prune/) 6. [**Real-time demos:** Doom, Wikiracing and the text-state qualification](https://www.oguzhan.co/jev-realtime-doom-wikiracing-browser/) 7. [**LitJev:** zero-training Qwen reproduction of the public /v1/systemone schema](https://www.oguzhan.co/litjev-open-jev-reproduction-qwen/) 8. [**Ecosystem and limits:** providers, open experiments and jobs that should stay with an LLM](https://www.oguzhan.co/jev-ecosystem-openrouter-vercel-cloudflare/) 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](https://www.oguzhan.co/ai/). ## Sources **Related:** start with [Jev primitives: Choice, Score, and Noul](https://www.oguzhan.co/jev-primitives-choice-score-noul/), then [Jev confidence and RLCD](https://www.oguzhan.co/jev-confidence-rlcd-calibrated-decisions/) for calibrated routing. - [TypeSafe AI: Introducing System One Models and Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) - [TypeSafe documentation: Primitives](https://docs.typesafe.ai/primitives) - [TypeSafe documentation: Jev 1.13 jaggedness](https://docs.typesafe.ai/model-jaggedness/jev-1.13) - [cobanov/awesome-jev](https://github.com/cobanov/awesome-jev) - [The Register: TypeSafe AI debuts model for machines that plays Doom](https://www.theregister.com/ai-and-ml/2026/09/16/typesafe-ai-debuts-model-for-machines-that-plays-doom/5296711) - [Vercel: TypeSafe AI’s Jev on AI Gateway](https://vercel.com/changelog/typesafe-ai-jev-now-available-on-ai-gateway) - [OpenRouter: typesafe/jev-1.13](https://openrouter.ai/typesafe/jev-1.13) - [Cloudflare Workers AI: Jev](https://developers.cloudflare.com/ai/models/typesafe/jev/)