Jev: TypeSafe AI's System One Model
What it is: Jev is TypeSafe AI's "System One model," launched 2026-09-15 — five days before this page was written, so treat everything here as early, vendor-stated information rather than a mature, independently-verified product. TypeSafe AI describes it as "a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out." It is not a chat model: it's a non-autoregressive parallel sampler on a non-transformer architecture that answers one of three typed question types — Choice (categorical), Score (numeric/rubric), or Noul (yes/no probability) — instead of generating free text. See our System One model explainer for the category-level framing.
Important caveat: All benchmark and pricing figures below are vendor-reported by TypeSafe AI at launch and have not been independently reproduced. TypeSafe reports a 0% structured-output error rate for Jev — that means every output is schema-valid, not that every output is correct. On TypeSafe's own benchmark, Jev is accurate 67.8% of the time, so roughly a third of its answers are wrong even though 100% are well-typed. "Can't hallucinate" here refers narrowly to format, not correctness.
What It Does Best
Low-latency typed decisions. TypeSafe AI reports 70–500ms end-to-end latency, versus 3–329s for frontier LLMs on comparable calls in its own comparison — a claimed 40x–200x speedup, driven by a non-autoregressive architecture that doesn't generate output token by token. See non-autoregressive models for the mechanism.
Guaranteed schema conformance. Because Jev's output is inherently typed rather than generated text passed through a schema checker, TypeSafe reports a 0% structured-output error rate — output cannot fall outside the schema you define, up to a cardinality cap of 255 categories.
Calibration-focused training. Jev is trained with RLCD (Reinforcement Learning for Calibrated Decisions), TypeSafe's stated alternative to RLHF (chat models) and RLVR (verifiable tasks), aimed at making Score and Noul outputs honestly calibrated rather than just directionally plausible. See RLCD explained.
Key Features
Three question types: Choice (categorical, up to 255 options), Score (numeric/rubric), Noul (yes/no calibrated probability) — see Jev question types for worked examples
API: HTTP POST to https://api.typesafe.ai/v1/systemone, model route jev-latest
SDKs: official Python and JavaScript SDKs (confirm exact method names and parameters against TypeSafe's own docs — we haven't been given those specifics)
Playground: console.typesafe.ai, with early access currently via waitlist
Open-source adapter: a package referenced as system-one-adapter-python lets other LLMs emit Jev-compatible structured outputs
Input format: text-based structured program state; images are not supported yet as of launch
Pricing
Input: $0.042 per million tokens (vendor-published rate as of the September 2026 launch)
Output: free / unmetered — vendor-published; TypeSafe describes output tokens as “too cheap to meter”
Per-case cost: TypeSafe reports roughly $0.0004 per case on its four-workflow benchmark, versus $0.0304–$0.1761 for frontier LLMs on the same tasks — a vendor comparison specific to those workflows, not a universal ratio.
Access: currently waitlist-gated for early access; no published self-serve general-availability pricing tier beyond the token rate above, as far as the facts we have confirm.
When to Use It
✅ High-volume, repeated decisions with a fixed, enumerable answer space (categories, scores, yes/no)
✅ Latency-sensitive paths where a multi-second LLM call is a bottleneck
✅ Front-line triage/routing before escalating to a frontier LLM (see LLM routing patterns)
✅ Guardrail or verification checks on another model's output (see guardrailing LLM outputs)
✅ You need a calibrated probability, not just a label, and can validate that calibration on your own data
When NOT to Use It
❌ Open-ended text generation, summarization, or conversation — Jev doesn't generate strings at all
❌ Tasks needing image or other non-text input — not supported at launch
❌ Accuracy-critical decisions where TypeSafe's own benchmark shows frontier LLMs (Sol, Opus 5) scoring meaningfully higher (74.1% and 73.1% vs Jev's 67.8%)
❌ Category lists that could exceed 255 options
❌ Anywhere you need independently-audited accuracy numbers today — none exist yet for a five-day-old model
Common Use Cases
Support ticket routing: Choice question classifying incoming tickets into a fixed taxonomy
Invoice fraud scoring: Score question rating risk on a defined rubric
Churn-risk flagging: Noul question returning a calibrated probability
LLM output guardrailing: fast typed check on a generated response before it ships
Incident/observability triage: one of TypeSafe's own four benchmark workflows
Jev vs Alternatives
vs frontier chat LLMs (GPT-5.6 Terra, Sol, Opus 5): Jev is far faster and cheaper per TypeSafe's benchmark, but two of those three models outscored it on accuracy (74.1% and 73.1% vs 67.8%); LLMs also handle open-ended generation Jev structurally cannot. See Jev vs LLM.
vs JSON mode / function calling: both aim for schema-conformant output, but JSON mode/function calling constrain an autoregressive LLM's token generation, while Jev is non-autoregressive by architecture — no string is ever generated. See typed decisions vs JSON mode.
vs a classical ML classifier: a purpose-trained classifier can also be fast and typed, but Jev is pitched as a general-purpose decision layer usable without training your own model per task — an advantage untested outside TypeSafe's own benchmark so far.
Unique Strengths
Category-defining positioning: "System One model" is a new framing (Kahneman's System 1/2) for a fast-decision model family, distinct from both chat LLMs and classical classifiers.
Architecture-level schema guarantee: the 0% structured-output error rate comes from not generating text at all, not from a post-hoc validator — genuinely different from constrained decoding.
Calibration as a first-class training objective: RLCD specifically targets honest probabilities on Score/Noul outputs, which most general-purpose LLMs are not trained for.
No entrenched competition yet: as a five-day-old category launch, there's no comparable non-autoregressive typed-decision API with a public track record to weigh it against.
Bottom line: Jev is a genuinely different architecture aimed at a real gap — fast, cheap, schema-guaranteed decisions where a full LLM call is overkill. Its speed and cost claims (vendor-reported, unverified independently) are dramatic; its accuracy is roughly on par with one frontier LLM and behind two others on TypeSafe's own benchmark. The 0% structured-output error rate is a real and useful guarantee about format — it is not a correctness guarantee, and at 67.8% benchmark accuracy, Jev is wrong in a well-typed way roughly a third of the time. Worth piloting for high-volume routing/scoring/classification tasks; not a replacement for frontier LLMs on open-ended or accuracy-critical work, and not yet backed by independent benchmarks.