What is Jev? TypeSafe's System One model, explained

TypeSafe announced Jev on 15 September 2026 as the first of what it calls System One models: models built to make fast, structured decisions that software can use directly, rather than to write text¹. That one design choice changes how you call it, how it is billed and which jobs it suits. This guide covers what TypeSafe documents about Jev 1.13, read on 6 October 2026, and how to decide whether a workload belongs on it.

What Jev does, and what it does not

A chat model answers in text. When software needs a decision — which queue, is this urgent, how severe — the usual approach is to ask a chat model for JSON, validate it, and parse it back into values. TypeSafe positions Jev as the alternative: you send content and typed questions, and get back typed values with probability distributions that code can branch on, sort by and route with, with no text to parse².

The name System One comes from the fast, intuitive mode of thinking Daniel Kahneman described in Thinking, Fast and Slow³. Jev itself is named after the economist William Stanley Jevons: TypeSafe expects that each fall in the cost of a decision will raise demand for decisions, as more efficient steam engines once raised demand for coal¹. TypeSafe says Jev is trained with a method it calls reinforcement learning for calibrated decisions (RLCD), and that the same weights serve every account, with no fine-tuning on customer data⁴. Beyond describing a new architecture and a parallel sampler, TypeSafe publishes no architecture details¹, so this article makes no claims about them.

What Jev is not for is stated just as clearly. System One models do not write replies, produce code or generate explanations³. For anything a person will read as prose, TypeSafe's own advice is to use a generative model⁵.

One state, many typed questions

Every call goes to one endpoint, POST https://api.typesafe.ai/v1/systemone, with a bearer key⁶. The body has three fields:

• state — the content to judge: a string, a JSON object or an array.
• model — the model name, such as the alias jev-latest or the pinned jev-1.13.0.
• questions — a map of ids you choose to typed questions. The ids are not sent to the model; each answer comes back under its question's id.

Jev ingests the state once and evaluates every question against it in parallel⁴, so one request can carry many judgments about the same content. Most of the cost arithmetic in the companion cost article depends on that property.

{
  "model": "jev-1.13.0",
  "state": {
    "ticket": "Help! My payouts have been failing for 3 days and payroll runs on Friday.",
    "plan": "business"
  },
  "questions": {
    "team": {
      "type": "choice",
      "instructions": "Which team should handle `ticket`?",
      "criteria": {
        "billing": "Payments, invoicing, refunds",
        "technical": "Bugs, outages, integrations",
        "sales": "Pricing, upgrades, new accounts",
        "other": "A request that fits none of the above"
      }
    },
    "urgent": { "type": "noul", "instructions": "Is `ticket` explicitly time-sensitive?" },
    "refund": { "type": "noul", "instructions": "Does `ticket` ask for a refund?" },
    "frustration": {
      "type": "score",
      "instructions": "How frustrated is the customer in `ticket`?",
      "criteria": ["Calm", "Frustrated", "Very angry"]
    }
  }
}

Backticks point a question at a field of the state. TypeSafe recommends an object state for exactly this reason, and recommends filtering out content the questions do not need before the call⁷.

Noul, Choice and Score

• Noul is a yes/no question, or a statement to judge. The answer, noul, is the probability that the answer is yes: near 0 for no, near 1 for yes, near 0.5 for uncertain. Optional criteria describe what counts as true and what counts as false⁶.
• Choice picks one of the options you define in criteria, up to 255 of them. The answer carries the winning choice, the probability of every option (they sum to 1) and a confidence⁶.
• Score places the state on an ordered rubric of up to 10 levels. The score is the probability-weighted mean of the level numbers, so it can fall between levels; the answer also carries a legend, the per-level probabilities and a confidence⁶.

Two pieces of TypeSafe's guidance shape good questions. Score levels should describe situations, not degrees: "broken feature, workaround exists" gives the model something to match, "moderately severe" does not⁸. And a Choice should include an other or "none of the above" option whenever the list might not cover every input, so content that fits nothing is not forced into the nearest category⁹.

Probabilities and confidence are what you act on

The answer says what; the distribution says whether to act on it. TypeSafe computes confidence for Choice and Score from how the probability is spread: all of it on one option gives 1.0, an even spread gives 0. For a Noul it suggests |2p − 1|, so a probability of 0.5 has no confidence and 0 or 1 has full confidence¹⁰. Because every answer carries its full probabilities, you can compute a different measure if your application needs one¹⁰.

TypeSafe's calibration claim is specific: across many predictions from a well-calibrated model, stated probabilities match observed rates, and those rates describe groups of predictions, not a guarantee about any single answer¹¹. In practice a threshold is a policy you set, test and tune per decision. TypeSafe's voice-banking example sends anything below 0.6 confidence to a person, and requires more than 0.85 before a money transfer goes ahead without asking the user to confirm¹². A label that only changes a queue can run at a lower threshold than one that moves money.

Limits, versions and pinning

The current model is Jev 1.13, id jev-1.13.0. A request may hold 64k tokens across the state and all questions, and the state plus the single longest question must fit in 32k. Rate limits are 100K tokens and 80 requests per second, with a warning that they are being adjusted without notice while TypeSafe adds capacity; higher limits come with custom and enterprise plans⁴. Input is text only, and English is where accuracy is currently best; other languages, including CJK scripts, work less well⁴.

Two aliases exist. jev-latest points to the most recent stable release and is the default in TypeSafe's SDKs; jev-preview points to the newest release, official or not, and currently resolves to the same model⁴. Each response's model field reports the versioned id that answered. TypeSafe's advice is direct: once you have tuned confidence thresholds against a version, pin that version's id and move to the next on your own schedule⁴. A threshold tuned on one version is not guaranteed to mean the same thing on the next.

How Jev is billed

TypeSafe charges per input token, $0.042 per million for jev-1.13.0 ($42 per billion), and does not charge for output tokens⁴. The API reference's own examples show what a small request reports: one short sentence of state and one question come to about 300 input tokens⁶. So each request carries a fixed overhead, which makes many tiny requests relatively expensive and rewards putting several questions about the same content into one call.

TypeSafe's homepage compares Jev with frontier LLMs on its own workflow evaluations and reports large multiples in speed and cost; it also says those multiples are probably the high end of real gains¹³. Treat them as the vendor's claim. The cost article works the arithmetic against chat models at their list rates, including where the gap is small.

Where Jev 1.13 is weak

TypeSafe publishes a list of Jev 1.13's known failure modes, last reviewed on 2 October 2026⁵. It is worth reading before any design review:

• Literal reading. It answers the question as written, not as meant. State the exact condition and put boundary cases in the criteria.
• Numbers, counting and dates. It is not a calculator and does not count reliably. Extract values with a question and compute in code.
• Indirection. Several hops of reasoning cost accuracy. Point the question at the relevant field instead.
• Large, irrelevant state. Accuracy falls as unrelated content grows. Filter before the call.
• Adversarial content. Text written to steer the answer can move it. Test with hostile inputs before deploying widely.
• Choice option order. Jev 1.13 leans toward the first option listed. Reorder the options and check that answers hold.

The list doubles as the design rules for any Jev integration: atomic questions, filtered state, arithmetic in code, and a test set with hostile inputs in it.

Jev or a chat model with structured outputs?

Chat models with structured outputs can return the same labels, so the decision is less about capability than about the shape of the work.

Jev fits when code consumes the answer as a value from a set you can write down, the judgment is a quick read of the content, and the volume is high enough for per-call cost and latency to matter. A generative or reasoning model fits when a person reads the answer as text, or when the decision needs planning, multi-step reasoning or arithmetic that cannot move into code. Many systems end up with both: Jev for the many small judgments, a larger LLM for the few that need it. The use-case guide and the cost article both come back to that cascade.

Evaluating Jev on your own decisions

TypeSafe deliberately publishes no public benchmark scores and tells users to evaluate on their own work¹⁴. Its one public comparison is a set of four workflow evaluations that score every model against the average answers of GPT-6 Astra and Claude Fable 5.1 at high thinking. TypeSafe states that its own team built the workflows and that the reference favours those two vendors' models¹⁵. On that harness it reports Jev matching the reference 67.8% of the time on average, at $0.0004 and 0.4 seconds per case; on the same chart, Claude Sonnet 5 run as a workflow also scores 67.8%, at $0.1174 and 78.1 seconds per case¹⁵. That is a useful prior about where Jev sits, not an answer for your workload.

A practical evaluation uses a few hundred decisions you already know the outcome of:

1. Build the labelled set from past tickets, moderated posts or reviewed claims, and keep the hard cases in it.
2. Write atomic questions and run them over the set with a pinned version.
3. Plot accuracy against confidence. The useful result is not one accuracy figure but the threshold above which Jev is right often enough to act on alone.
4. Price the remainder. Whatever falls below the threshold goes to a person or a larger model. Cost per successful task is the number that compares one design with another.

Running Jev through INFRO

TypeSafe is one of the provider kinds INFRO added in September 2026. The gateway implements TypeSafe's endpoint at the same path, POST /v1/systemone, with the same request body, and forwards each request to TypeSafe over the customer's own TypeSafe connection, so TypeSafe bills the customer's account directly. TypeSafe connections are available in production: Jev through INFRO shows the setup, and the System One reference the request, the response and the errors.

With a TypeSafe connection in place, the request above goes to https://api.infro.io/v1/systemone with an INFRO gateway key, and model names the catalog id typesafe/jev-1.13, which INFRO sends to TypeSafe as jev-1.13.0: a pinned version, as TypeSafe advises. TypeSafe's SDKs send jev-latest by default, which INFRO passes to TypeSafe as typed; each response names the version that answered, and pinning a version remains TypeSafe's advice. Pointing an SDK at INFRO takes two environment variables: TYPESAFE_BASE_URL=https://api.infro.io, and TYPESAFE_API_KEY set to an INFRO gateway key.

curl https://api.infro.io/v1/systemone \
  -H "Authorization: Bearer $INFRO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "typesafe/jev-1.13",
    "state": "Help! My payouts have been failing for 3 days.",
    "questions": {
      "urgent": { "type": "noul", "instructions": "Is this explicitly time-sensitive?" }
    },
    "metadata": { "workflow": "support-triage" }
  }'

Before the call, the gateway checks the request against the key's scope and any spend limit, using the request's size in bytes as an upper bound on its input tokens, since output is free. The response returns TypeSafe's answers unchanged, with usage.input_tokens, usage.cost — the estimated TypeSafe charge at the catalog rate, or at a rate you have entered for your organization — and the route and connection that served it. The metadata stays in INFRO: it is not forwarded to TypeSafe, and it lets Jev decisions be grouped by workflow in usage and traces, next to the rest of the organization's AI traffic.