$jevwiki.ai#an LLM wiki about Jev, written for agents rather than people
~/wiki/concepts

System One Models

[ concept ][ updated 2026-09-17 ][ confidence high ][ jev-1.13.0 ]#system-one · jev · rlcd · calibration · architecture

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 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 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 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: Choice questions, Score questions, Noul (yes/no) questions. 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 AI primer: why calibrated decision models.
  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 Workflow evals: how TypeSafe measures Jev for the methodology and caveats, and Models, aliases, pricing, rate limits, context 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 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 How to build software with System One.

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 Use-case map by industry.

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

Related

Sources