On September 15, 2026, TypeSafe AI came out of two years in stealth and released Jev, the first of what it calls System One Models. Jev does not generate text at all: you send it state plus typed questions, and it returns structured decisions with calibrated probabilities in parallel.
Same frontier-level judgment on decision-shaped tasks, two orders of magnitude faster and cheaper than LLMs. Here is what actually shipped, why it matters, and what you should do about it this week.
1. Context: chat models were built for people
TypeSafe founder Diogo Almeida helped build the instruction-following methods behind ChatGPT at OpenAI. His thesis now is blunt: RLHF optimized models for human preferences and conversation, but most AI calls inside real software are not conversations. They are decisions: which tool next, is this output safe, which of forty candidates matches the query.
The class name comes from Daniel Kahneman’s Thinking, Fast and Slow: System 1 is fast, intuitive thinking versus slow, deliberate System 2 reasoning. Jev is named after 19th-century economist William Stanley Jevons of Jevons paradox fame: as intelligence gets cheaper per decision, total demand for decisions explodes.
The launch facts
- • Launch: September 15, 2026, early access behind a waitlist
- • Price: $0.042 per 1M input tokens ($42 per billion), output tokens free
- • Context: 64K tokens per request (32K for state plus the longest question)
- • Latency: 70ms–500ms end to end, per TypeSafe’s launch post
- • Training: new stack with Reinforcement Learning for Calibrated Decisions (RLCD)
2. How Jev works: typed questions over shared state
You declare the answer space before inference. Jev supports three question types: Noul (a calibrated yes/no), Choice (pick among declared options, up to 255 per question), and Score (an ordinal position across 2–10 ordered levels). Every answer ships with a probability distribution plus a confidence scalar derived from its shape.
The model reads the state once and evaluates every question against it in a single parallel pass, instead of decoding tokens one by one. That is where the speed comes from: no autoregressive loop, no JSON to parse, no retry wrapper around malformed output. A Choice cannot invent an option outside your list, which is a type guarantee, not a correctness guarantee.
The three primitives
Noul
Calibrated yes/no. Did the customer request a refund? Returns P(yes) your code can threshold for autonomous action vs human review.
Choice
Pick among options you defined, each with a probability. Up to 255 options; beyond that TypeSafe scores candidates first, then chooses explicitly.
Score
Ordinal position on your rubric (2–10 levels). Urgency 1.7/3 with the full level distribution attached, so code sees the shape, not just the winner.
Golden rule
The model interprets language; code decides what to do with the result. Thresholds, permissions, arithmetic, and side effects stay in your software. A 0.94 probability never authorizes a refund by itself.
3. The evidence: fast and cheap, with caveats attached
TypeSafe’s headline numbers come from its own workflow evals: four production-shaped workflows (security incidents, agent-trace observability, invoice processing, customer service) where every model gets the same compute graph and is scored by agreement with a reference built from GPT-6 Astra and Claude Fable 5.1. That is where the 193.6x faster / 444.6x cheaper homepage claims come from, and TypeSafe itself says to expect those at the high end of real-world gains.
Independent checks add texture. Anthus replayed one decision flywheel against both Jev and the open-source Laya on identical texts, questions, and 140 human labels: Jev 87% vs Laya 80% held-out accuracy, with the feedback layer lifting both. Convai’s own Laya card reports beating Jev on several public sets only after fine-tuning on the benchmark’s training split, and Laya’s base checkpoints score near chance zero-shot. Read every number with its task, hardware, and reference labels attached.
What the numbers actually say
- • Jev vs GPT-5.6 Terra on TypeSafe’s workflows: 67.8% vs 67.9% agreement at ~76x lower cost and ~25x less time per case
- • No type errors by construction: schema matching is guaranteed, so malformed output is off the table
- • Calibration is the real feature: confidence should track accuracy, so code can auto-act when high and escalate when flat
- • Bias disclosure: TypeSafe’s team wrote the eval workflows and the reference averages two frontier LLMs, likely flattering them
Do not generalize
These are bounded decision workflows, not open-ended generation or reasoning, which Jev cannot do at all. Invoice processing in TypeSafe’s own evals is a case where several LLM workflows score materially higher than Jev.
4. What changes for devs: the agent loop gets a fast layer
The practical pattern is a semantic decision layer between unstructured evidence and the code that controls a workflow: classify intent before the LLM, score retrieved passages for relevance or injection after retrieval, judge policy fit before a tool call, verify the response after generation, triage traces after the run. One Jev call with 13 independent questions was reported 12.2x cheaper and 10.0x faster than thirteen sequential calls in TypeSafe’s cookbook.
The endpoint is POST https://api.typesafe.ai/v1/systemone with the model alias jev-latest (currently jev-1.13.0). Input is text only: string, JSON object, or array of text. English is the primary training language; test anything else on your own content. And it is a closed, hosted API with no open weights and no fine-tuning on your data, so version-pin if you tune thresholds against a release.
Replay the Jev vs Laya paired comparison yourself
Verbatim setup from the Anthus Jev-Flywheel harness that produced the 87% vs 80% head-to-head on identical labels.
git clone https://github.com/AnthusAI/Jev-Flywheel && cd Jev-Flywheel
make install
make laya # downloads the 843 MB model; about 2 minutes after thatHonest limits (from TypeSafe’s own docs)
- • No text generation: drafting, chat, planning, and code stay on LLMs
- • Weak at numerical precision, counting, and date comparison: keep exact work in code
- • Closed weights, provider dependence: timeouts, retries, and fallbacks are yours to build
- • Probabilities are estimates: validate calibration on your own labelled traffic, per domain and language
5. What to do this week
Pick one decision in your stack, not the whole agent. Define its allowed outputs, the cost of each error type, and which cases must always reach a person. Then compare complete implementations on the same held-out inputs: deterministic rules, a small classifier, a structured-output LLM, and Jev behind the waitlist.
My recommended playbook
- 1. Enumerate the answer space first: if you cannot list valid outcomes before seeing the case, you need an LLM, not a decision model
- 2. Add none_of_the_above to every Choice with a possibly incomplete option list
- 3. Measure precision, recall, calibration (ECE), latency percentiles, and review share, not just accuracy
- 4. Run in shadow mode against reviewer choices before letting it act, starting with reversible actions
- 5. Log state and schema versions, distributions, routes, and overrides for the audit trail
Watching Laya?
Convai’s Laya (421M ModernBERT encoder, Apache 2.0) is the inspectable, self-hosted route with the same choice/score/noul interface. Anthus found full fine-tuning on 140 labels can beat the frozen-engine layer on accuracy (90% vs 87%) but degrades calibration and shifts answers to unrelated questions, so every other score on the card needs revalidation. Horses for courses: hosted Jev when you have no labels or hardware, Laya when volume, data locality, or spare GPUs dominate.
Conclusion
Jev is a genuinely new interface: frontier-level judgment on bounded questions, delivered as typed values with honest uncertainty, at a price and latency that make per-item checks practical across every retrieval, tool call, and trace in your system.
It does not replace LLMs or rules or reviewers. It gives each part of the stack the job it handles best: code does exact work and owns actions, Jev turns text into bounded answers, LLMs generate and reason, people resolve consequential uncertainty. That separation is the story, and it is worth testing on your own traffic this week.
Sources cited
Primary & independent
- • TypeSafe launch post (Sep 15, 2026)
- • TypeSafe models & pricing docs
- • TypeSafe workflow evals site
- • Chromiak: Typed Decision Models
- • Anthus: Jev vs Laya head-to-head
