# What is Jev? TypeSafe's System One model, explained URL: https://infro.io/blog/what-is-jev-typesafe Author: INFRO Editorial (https://infro.io/blog/editorial) Publisher: INFRO Published: 2026-10-06 Last modified: 2026-10-06 Last reviewed: 2026-10-06 (next review due 2026-11-05) Topic: Evaluation and models Format: Guide > Jev is TypeSafe's first System One model, launched on 15 September 2026: it generates no text, and instead answers typed questions (yes/no, one-of-N choice, or a rubric score) about a piece of content with calibrated probabilities. Jev 1.13 is billed at $0.042 per million input tokens with output free, holds 64k tokens per request, and fits high-volume decisions that code consumes; evaluate it on your own labelled data before relying on it. Key takeaways: - Jev answers typed questions about a state — noul (yes/no), choice (one of up to 255 options) or score (up to 10 levels) — and returns probabilities, never text. - One request carries many questions about the same content, because the state is read once and every question is evaluated against it in parallel. - Jev 1.13 is billed per input token at $0.042 per million; output tokens are free, so the cost of a decision is set by how much you send. - Pin `jev-1.13.0` once you tune thresholds against it; `jev-latest` moves with each release. - TypeSafe publishes Jev 1.13's weak spots — literal reading, arithmetic, dates, irrelevant context, adversarial text, option order — and they are also the design rules for using it. 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[1]. 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[2]. The name System One comes from the fast, intuitive mode of thinking Daniel Kahneman described in *Thinking, Fast and Slow*[3]. 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[1]. 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[4]. Beyond describing a new architecture and a parallel sampler, TypeSafe publishes no architecture details[1], 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[3]. For anything a person will read as prose, TypeSafe's own advice is to use a generative model[5]. ## One state, many typed questions Every call goes to one endpoint, `POST https://api.typesafe.ai/v1/systemone`, with a bearer key[6]. 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. [Diagram: A Jev request: the state is read once and every question is answered against it. Field names from TypeSafe's API reference, read 2026-10-06.] Jev ingests the state once and evaluates every question against it in parallel[4], so one request can carry many judgments about the same content. Most of the cost arithmetic in the [companion cost article](https://infro.io/blog/jev-cost-per-decision) depends on that property. ```json { "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[7]. ## Noul, Choice and Score [Diagram: The three question types and what each returns, from TypeSafe's API reference and primitives pages, read 2026-10-06.] - **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[6]. - **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`[6]. - **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`[6]. 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[8]. 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[9]. ## 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[10]. Because every answer carries its full probabilities, you can compute a different measure if your application needs one[10]. 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[11]. 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[12]. A label that only changes a queue can run at a lower threshold than one that moves money. ## Limits, versions and pinning [Diagram: Jev 1.13 as published on TypeSafe's models page, read 2026-10-06.] 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[4]. Input is text only, and English is where accuracy is currently best; other languages, including CJK scripts, work less well[4]. 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[4]. 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[4]. 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[4]. 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[6]. 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. > **Example: A month of ticket triage** > Illustrative arithmetic on the published rate. 100,000 tickets a month, one request each, each reporting 1,200 input tokens for the ticket, the plan and four questions. > > 100,000 × 1,200 × $0.042 / 1,000,000 = $5.04 for the month. Output is not charged, however many questions the request carries. 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[13]. Treat them as the vendor's claim. The [cost article](https://infro.io/blog/jev-cost-per-decision) 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[5]. 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](https://infro.io/blog/structured-output-reliability) can return the same labels, so the decision is less about capability than about the shape of the work. [Diagram: A first-pass test for whether a decision belongs on a System One model.] 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](https://infro.io/blog/jev-use-cases) 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[14]. 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[15]. 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[15]. 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](https://infro.io/blog/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](https://infro.io/providers/typesafe) shows the setup, and the [System One reference](https://infro.io/docs/api/systemone) 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. ```bash 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. ## Questions ### Can Jev generate text, extract free-form fields or write code? No. TypeSafe states that System One models do not write replies, produce code or explain their reasoning. For extraction, TypeSafe suggests producing candidate values with a parser or a generative model and asking Jev to choose the right one, which turns extraction into a Choice. ### Is Jev deterministic? TypeSafe says it designs Jev for consistency — similar answers when the meaning is similar — rather than strict determinism. Log the versioned model id from each response, and re-check your thresholds when you move to a new version. ### Does TypeSafe train on the data I send? TypeSafe's models page says Jev is not trained on customer requests or responses, and that zero data retention is offered to enterprise customers. Read TypeSafe's legal pages for the terms that apply to your account. ## Sources 1. Introducing System One Models & Jev — TypeSafe. https://typesafe.ai/blog/introducing-system-one-models-and-jev (accessed 2026-10-06) 2. Introduction — TypeSafe. https://docs.typesafe.ai/introduction (accessed 2026-10-06) 3. System One — TypeSafe. https://docs.typesafe.ai/concepts/system-one (accessed 2026-10-06) 4. Models — TypeSafe. https://docs.typesafe.ai/models (accessed 2026-10-06) 5. Jev 1.13 jaggedness — TypeSafe. https://docs.typesafe.ai/model-jaggedness/jev-1.13 (accessed 2026-10-06) 6. API reference — TypeSafe. https://docs.typesafe.ai/api (accessed 2026-10-06) 7. State — TypeSafe. https://docs.typesafe.ai/concepts/state (accessed 2026-10-06) 8. Score — TypeSafe. https://docs.typesafe.ai/primitives/score (accessed 2026-10-06) 9. Choice — TypeSafe. https://docs.typesafe.ai/primitives/choice (accessed 2026-10-06) 10. Confidence — TypeSafe. https://docs.typesafe.ai/confidence (accessed 2026-10-06) 11. AI primer — TypeSafe. https://docs.typesafe.ai/introduction/machine-learning-primer (accessed 2026-10-06) 12. Confidence-gated routing — TypeSafe. https://docs.typesafe.ai/patterns/confidence-routing (accessed 2026-10-06) 13. TypeSafe homepage and FAQ — TypeSafe. https://typesafe.ai/ (accessed 2026-10-06) 14. Lies, Damned Lies, and Benchmarks — TypeSafe. https://typesafe.ai/blog/antibenchmaxxing (accessed 2026-10-06) 15. Workflow evals — TypeSafe. https://evals.typesafe.ai/ (accessed 2026-10-06) ## Revision history - 2026-10-06: TypeSafe connections opened in production: linked the setup page and the System One reference, and corrected the SDK note — TypeSafe's default `jev-latest` now works through INFRO, and the SDK needs only two environment variables.