--- title: "System One Models" type: concept tags: [system-one, jev, rlcd, calibration, architecture] created: 2026-09-17 updated: 2026-09-17 confidence: high sources: - raw/docs/concepts__system-one.md - raw/docs/introduction.md - raw/site/blog-introducing-system-one.txt jev_version: "jev-1.13.0" summary: "System One models make fast, typed, calibrated decisions software can consume directly; Jev is TypeSafe's first one." --- # System One Models > **TL;DR** A System One model evaluates one `state` and returns typed answers plus calibrated probabilities — never generated text. Jev is TypeSafe's flagship and first System One model. Call it with `POST /v1/systemone` (or an SDK), ask [[concepts/primitives|Choice, Score, and Noul]] questions in parallel against the same state, and branch on the results in your own code. ## What it is System One models are a class of AI models built to make fast, structured decisions that software can use directly. A System One model evaluates a [[concepts/state|state]] and returns typed answers and probabilities. Like an LLM, a System One model understands natural-language input. Unlike an LLM, it returns typed decisions and probabilities rather than generated text. It does not write replies, produce code, or generate explanations of its reasoning. You define the possible answers in advance through [[concepts/primitives|primitives]]: | Primitive | Question | Example answer space | Example output | |---|---|---|---| | Choice | Which team should handle this ticket? | `billing`, `technical`, or `account` | `choice: "billing"` | | Score | How frustrated is this customer? | 0 = calm, 1 = frustrated, 2 = very frustrated | `score: 1.4` | | Noul | Does this message request a refund? | True or false | `noul: 0.95` | Links: [[concepts/choice]], [[concepts/score]], [[concepts/noul]]. The docs mark the table above as illustrative configurations and values; see the individual primitive pages for the real configuration options and full response fields. Return fields by question type, per `raw/docs/introduction.md`: | Question type | Goal | Returns | |---|---|---| | Choice | Choose an option from a list | `choice`, `probabilities`, `confidence` | | Score | Score the state on a rubric | `score`, `probabilities`, `confidence` | | Noul | Is this statement true? | `noul` (0–1) | > Jev currently accepts **text input only**: strings, JSON objects, and arrays of text. Images, audio, and video are not supported (yet). Founder Diogo Almeida's framing in the launch blog post: "Think of Jev as a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out." ### Where the name comes from TypeSafe takes the name from Daniel Kahneman's *Thinking, Fast and Slow*: System 1 thinking is fast and intuitive, System 2 is slower and more deliberate. The emphasis here is on fast, focused judgments. The blog FAQ adds that "System 1 thinking" has also implied error-prone, and states TypeSafe's belief that System One Models can be made more reliable than the alternatives. The model name **Jev** is after William Stanley Jevons — TypeSafe expects machine intelligence to follow the Jevons-paradox path of coal, where each order-of-magnitude drop in the cost of intelligence unlocks orders of magnitude more use cases. ## How it works (mechanism) Three mechanisms matter when you write code against it: 1. **Training objective — RLCD.** TypeSafe trains with Reinforcement Learning for Calibrated Decisions, a third post-training path alongside RLHF and RLVR. Probabilities are optimized against outcomes so they reflect uncertainty. Calibration is measured across *groups* of predictions; it does **not** guarantee any individual answer is correct. See [[concepts/machine-learning-primer]]. 2. **Parallel sampler.** The blog describes a new model architecture with a "parallel sampler for maximum efficiency": all outputs are generated in a single query rather than one token at a time, each conditioned on the last. This is why adding questions barely changes response time. 3. **Constrained output space.** Possible outputs and structure are defined in advance, so the model "never makes type errors" and, per TypeSafe, "can't hallucinate" a value outside your schema. TypeSafe notes this claim is not empirical: "Schema matching is guaranteed, thus we can confidently add 0% into the plots." ### Frontiers, old and new (TypeSafe's comparison) The launch blog contrasts existing LLMs with System One + Jev. Reproduced as TypeSafe states it — these are TypeSafe's claims about its own product and about competitors: | Dimension | Existing LLMs | System One + Jev | |---|---|---| | Optimized with | RLHF (Reinforcement Learning with Human Feedback) / RLVR (Reinforcement Learning with Verifiable Rewards) | RLCD (Reinforcement Learning for Calibrated Decisions) | | Optimizes for | Human preference: writeups and chat responses human raters prefer. Verifiable rewards: outputs that can be programmatically verified. | Calibrated decisions: answers with epistemically honest probabilities on System One tasks. | | Inputs | Unstructured data (e.g. text) with an emphasis on sequential messages | Structured program state | | Outputs | Strings / generated text — flexible, but must be parsed and validated, and can be hallucinations or refusals | Type-safe structured values, defined in advance, with calibrated probabilities and confidence scores | | Sampling | Sequential: one token at a time, each conditioned on the last | Parallel: all outputs in a single query, "incredibly efficient and hardware-aware" | | Cost | Input `$0.20`–`$10` / MTok; output tokens ~5x more expensive than input | Input `$0.042` / MTok (`$42` per billion tokens); output tokens FREE ("too cheap to meter") | | Speed | End-to-end 3 to 329 seconds for frontier models | End-to-end 70 ms–500 ms; TypeSafe claims 40x–200x faster "for the same levels of frontier intelligence for System One shaped queries" | | Confidence | Models tend to be overconfident and inconsistent even when prompted for a confidence estimate | Always communicates confidence and uncertainty; calibrated (higher confidence means higher accuracy) and more consistent | | Use cases | Human-in-the-loop tasks (chatbots, copilots, coding agents); verifiable problems (math proofs, kernel optimization); demos | AI-powered workflows / "smart if-statements"; map-reducing over big data; real-time applications; verifying, scoring, judging and guardrailing other AI | TypeSafe also claims Jev "achieves similar levels of intelligence on System One tasks compared to existing LLMs, while being two orders of magnitude faster and more efficient." Its headline workflow-eval figures are **193.6x faster, 444.6x cheaper**, which TypeSafe says "are on the higher end of real world gains" — see [[concepts/workflow-evals]] for the methodology and caveats, and [[reference/models-and-pricing]] for the shipped price, rate limits, and context window. ## Why it matters for code Because outputs are typed and constrained, your code can inspect, sort, threshold, and combine answers without parsing prose. The canonical shape of a workflow (from the refund example in the docs): 1. Build a state containing the customer's message, the relevant transactions, and the refund policy. 2. Ask independent questions together — whether a refund was requested, whether the evidence indicates a duplicate charge, whether the policy supports a refund. 3. Combine the answers with deterministic checks in code, then route the case for action or review. All three question types can be mixed in a single API call. Every question is evaluated in parallel and in isolation against the same state in one go. Because each question is evaluated independently, adding more questions does not create context rot. Answers also carry [[concepts/confidence|confidence]], so you decide when to act and when to escalate to a person or a reasoning model. **Atomic questions, composed in code.** Treat each question as a gut-check determination: the kind of judgment a highly knowledgeable person could make in a few seconds given the right context. If a question would require extended reasoning or weighs multiple independent factors, decompose it and combine the results in code. Instead of "rate this startup pitch," ask separately about market size, technical feasibility, and differentiation, then combine the scores with your own formula — when priorities shift you change a coefficient rather than rewriting a prompt. See [[concepts/how-to-build]]. ## When to use / when not to use **Use it when** the decision is narrow, the answer space is known in advance, the consumer is code rather than a human reader, and you need speed, cost, or calibrated uncertainty: classification, routing, scoring, detection, extraction, verification, guardrails, ranking, feature extraction. See [[concepts/use-case-map]]. **Do not use it when** you need generated text, code, or an explanation; when the model must choose its own next action (System One "does not generate code or choose its own next action"); or when the input is an image, audio, or video — pre-process to text first. ## Gotchas - **Calibration is a population property.** A `0.8` answer is not a promise about that answer; it is a promise about the long-run rate across many `0.8` answers. - **English first.** Jev's primary training language is English; other languages including CJK scripts are accepted but currently have lower accuracy. - **Pin versions if you tune thresholds.** The examples use `jev-latest`, which is also the SDK default and currently resolves to `jev-1.13.0`. Aliases move; the response's `model` field reports which versioned ID answered. - **Cardinality ceiling.** The blog's Wikiracing demo states "Jev supports a cardinality up to 255," and that for higher-cardinality choices TypeSafe used a two-stage system of scoring independently then making an explicit choice. - **Speed claims are measured from TypeSafe's laptops.** "Our published evals are generally run from our laptops on the West Coast (this is where our service is currently based)." ## Related - [[concepts/state]] — what you send as the input - [[concepts/primitives]] — Choice, Score, Noul - [[concepts/confidence]] — thresholding on certainty - [[concepts/how-to-build]] — the full design workflow - [[concepts/machine-learning-primer]] — RLHF vs RLVR vs RLCD - [[concepts/workflow-evals]] — where 193.6x / 444.6x comes from - [[reference/models-and-pricing]] — prices, rate limits, context length, aliases - [[reference/http-api]] — `POST /v1/systemone` wire contract - [[entities/blog-introducing-system-one]] — the launch post itself ## Sources - raw/docs/concepts__system-one.md (https://docs.typesafe.ai/concepts/system-one) - raw/docs/introduction.md (https://docs.typesafe.ai/introduction) - raw/site/blog-introducing-system-one.txt (https://typesafe.ai/blog/introducing-system-one-models-and-jev)