Jev AI by TypeSafe: System One Models Explained — Decisions, Not Strings

Key takeaway

The short answer: Jev is TypeSafe AI's first System One Model — not a chat model, but a frontier-intelligence function call. You send unstructured state plus typed questions (Choice, Score, etc.) and get back type-safe decisions with calibrated probabilities in 70–500 ms. No strings, no hallucinations, no type errors. At $42 per billion input tokens and free output tokens, TypeSafe claims 193.6× faster and 444.6× cheaper than frontier LLMs on automation workflows. This guide is for developers and teams deciding where Jev fits versus LLMs.

TypeSafe AI spent two years in stealth asking one question: models have been superhuman at chat for years — so where is all the automation? On September 15, 2026, founder Diogo Almeida — who helped build the RLHF methods behind ChatGPT at OpenAI — introduced Jev, the first public System One Model. It is not a smaller LLM. It is a different primitive: built for decisions inside software, not words for people.

This page explains what Jev is, how System One Models differ from LLMs, what Jev costs and how fast it is, and where you should (and should not) use it.

What is TypeSafe AI and what is Jev?

TypeSafe AI is an AI lab in San Francisco building machine-native intelligence infrastructure for automation. Its thesis: RLHF made LLMs excellent at pleasing humans in chat, but also made them overconfident, inconsistent, and unreliable for autonomous software. TypeSafe took the opposite research direction.

Jev is its first public model, named after economist William Stanley Jevons — the Jevons paradox idea that every order-of-magnitude drop in the cost of intelligence unlocks orders of magnitude more use cases. The model class name comes from Daniel Kahneman's Thinking, Fast and Slow: fast, intuitive System 1 versus slow, deliberate System 2 reasoning.

Think of Jev as: unstructured state in, typed probabilistic decisions out. You define the questions and the schema in advance; Jev returns only values that match that schema, each with a confidence score your code can branch on.

What are System One Models?

System One Models are a new class of frontier models optimized for structured decisions that software can act on directly, without parsing strings or validating JSON after the fact.

Three things make them different by design:

Decisions, not strings. Outputs are type-safe structured values defined in advance. The model never makes a type error — mathematically impossible to return a malformed schema.
Calibrated confidence. Every decision ships with an epistemically honest probability. Higher confidence means higher accuracy, and similar inputs return similar answers. Your software can act when confidence is high and escalate to a human or a stronger model when it is not.
More like code. Reliable, fast, self-consistent, and hardware-aware. Built to be composed into larger workflows via ordinary branching logic.

Under the hood TypeSafe built a new stack: a new model architecture, a parallel sampler that generates all outputs in a single query (instead of autoregressively token-by-token), and a new training algorithm called Reinforcement Learning for Calibrated Decisions (RLCD).

How is Jev different from an LLM?

Same frontier intelligence on System One tasks, opposite trade-offs everywhere else. This table is drawn directly from TypeSafe's launch post:

Comparison of existing LLMs and Jev System One across eight dimensions
Dimension	Existing LLMs (RLHF / RLVR)	Jev — System One (RLCD)
Optimizes for	Human preference or verifiable rewards	Calibrated decisions with honest probabilities
Input	Unstructured text, emphasis on sequential messages	Unstructured data, emphasis on structured program state
Output	Strings — flexible, but can be hallucinations, refusals, or type errors that need parsing	Type-safe structured values — schema defined in advance, zero hallucinations
Sampling	Sequential, one token at a time	Parallel — all outputs in one query
Speed	3 to 329 seconds end-to-end for frontier models	70–500 ms (40–200× faster at same intelligence)
Cost	$0.20–$10 / MTok input; output ~5× input	$0.042 / MTok input ($42 / billion); output FREE — too cheap to meter
Confidence	Overconfident and inconsistent when asked	Always calibrated; confidence predicts accuracy
Best for	Chatbots, copilots, coding agents with human in the loop	AI-powered workflows, real-time apps, map-reduce over big data, verification and guardrails

The one-line distinction: LLMs produce words for people. Jev produces typed decisions for code. If you need a paragraph, use an LLM. If you need a reliable if / else that software can execute, use Jev.

How fast and how cheap is Jev really?

TypeSafe's headline claim on typesafe.ai is 193.6× faster, 444.6× cheaper on System One workflows — and they publish the nuance, which is rare and worth noting.

Speed per call: 70–500 ms for Jev vs 3–329 s for frontier LLMs in their tests. Evaluations were run from laptops on the US West Coast where the service is hosted, so your latency will vary by region.
Cost per call: $0.042 per million input tokens. Output tokens are free. For comparison, frontier LLM input pricing spans $0.20–$10 / MTok and output is typically 5× input.
Where the 193.6× / 444.6× comes from: four production-like workflows with many independent, decomposed questions — more complex than the simple side-by-side demo on the homepage. TypeSafe notes these are on the higher end of real-world gains and were not in the training distribution, but were made by their own capabilities team so some bias is possible.
Reference answer: workflow evals use the average of GPT-6 Astra and Fable 5.1 as ground truth, which biases toward OpenAI/Anthropic. TypeSafe discloses they likely underestimate Jev and DeepSeek relative to that reference.
Are prices subsidized? TypeSafe says pricing is transparent and they expect it to go down, not up, but long-term sustainability can only be proven over time.

Even halving those multiples, the economics change what is feasible: at ~$7/hour for 10 queries per second in their Doom demo, real-time agent loops that were prohibitively expensive with LLMs become ordinary engineering.

What is Jev good at, and where does it struggle?

Where Jev shines

AI-powered workflows / smart if-statements: classify, route, score, extract, or branch where hand-written rules are too brittle. The surrounding code constrains the model's freedom, making it composable.
Map-reducing over big data: turn petabytes of unstructured state into features and insights with parallel, typed decisions.
Real-time applications: 100 ms-class latency lets you put intelligence on the UX hot path — games, interactive agents, live ranking.
Verify everything: score, judge, verify, guardrail, and jailbreak-detect LLM prompts, reasoning traces, and outputs. This is a natural complement to a coding agent's verify phase.

Where Jev is not the right tool

Open-ended generation: Jev gives up string generation by design. If you need a chat response, a code file, or a long-form summary, use an LLM.
High-cardinality choices above 255: Jev supports cardinality up to 255. Above that it uses a two-stage score-then-choose system, which can be slower.
Image inputs (today): current demos use structured state with text, not images — vision is on the roadmap.
Tasks that need deliberative reasoning traces: System One is fast intuition; for deep, verifiable proofs or kernel optimization where you can iterate until a checker passes, a reasoning LLM may still win.

TypeSafe is explicit: Jev can still be wrong — every model can — but because it always returns a calibrated confidence, your software can decide when to trust it.

Two fun demos that show the difference

1. Doom — 10 decisions per second

TypeSafe trained an open-source Jev variant to play DOOM from structured game state (not pixels). The point is not that it beats a hand-written bot — a non-AI bot plays better — but that it reacts to different representations of state and follows instructions in real time. At 10 queries per second the team measured roughly $7/hour, which they note was lower than expected for real-time intelligence.

2. Wikiracing — high-cardinality decisions without hallucinating

Start on one Wikipedia page, reach another using only links you encounter. Each step can mean choosing among hundreds to thousands of links. Jev's advantage here is not hallucinating with high-cardinality choices and finishing in fewer steps — a proxy for intelligence-per-second. TypeSafe notes speedups are smaller here because the comparison was against non-reasoning LLM modes to keep the demo watchable.

Both demos are published with full queries, disagreements, and workflows at evals.typesafe.ai — worth reading if you want to audit the claims yourself.

Is Jev just a smaller LLM with JSON mode?

No, and the difference matters for automation.

JSON mode / structured outputs still generate strings token-by-token and then coerce them into a schema. Type errors and hallucinations remain possible, and you pay for every output token.
Jev never generates strings. Its parallel sampler outputs probabilities for the pre-defined schema directly — no parsing, no validation layer, no output-token bill. Schema matching is guaranteed, so TypeSafe reports 0% type errors and 0% hallucinations by construction, not by benchmark.
Confidence is not a prompt trick. Asking an LLM "how confident are you?" yields an overconfident, inconsistent number. Jev's probabilities are trained via RLCD to be calibrated, so you can set thresholds like if confidence > 0.95: auto_act() else: ask_human() and have that mean something.

How to get started with Jev

Jev is available in early access as of September 2026. TypeSafe is bringing developers off the waitlist as quickly as it can.

Visit typesafe.ai and join the waitlist or sign in if you have access.
Define your questions with typed schemas — Choice, Score, and similar — and the state you want Jev to decide from.
Send state + questions in one parallel query. Get back labels with probabilities and confidence.
Combine decisions in code: threshold, branch, map-reduce, or feed them as verifiers for an LLM agent's outputs.

Docs and API references are linked from the TypeSafe homepage. If you are already running an agentic loop (like Cortex's plan-act-verify loop), Jev slots in naturally as the fast, cheap verifier or router around a stronger reasoning model.

Jev and Cortex: where a System One model fits

Cortex is a BYOK, local-first agentic IDE — your keys stay in the OS credential store and prompts go directly to the provider you choose. Jev fits that philosophy: a machine-native decision layer that can run at 100 ms without proxying your code through a vendor's servers.

Practical pairings we see:

Jev as the router: classify the task, pick the right model tier (cheap bulk vs frontier), and set confidence thresholds for auto vs review.
Jev as the verifier: score diffs, detect risky edits, and gate the verify phase before tests even run.
LLM as the generator: keep Claude, GPT, or DeepSeek for the actual code generation where strings are needed.

You do not need to choose one or the other. The strongest automation stacks compose them — System One for fast, calibrated judgments, System Two for slow, generative reasoning.

The bottom line

Jev is not ChatGPT with a different prompt. It is a new primitive for software that needs to make many fast, structured, auditable decisions — the kind of work where an LLM's flexibility becomes a liability. If your automation is blocked by cost, latency, hallucinations, or unreliable confidence, Jev is worth a serious look. If you need open-ended generation, keep your LLM and use Jev to verify and route around it.

Start at TypeSafe's launch post and typesafe.ai for the full evals, then try it inside your own loop and measure the difference on your workload.

Frequently asked questions

What is Jev AI by TypeSafe?

Jev is TypeSafe AI's first System One Model, launched September 15, 2026. It takes unstructured state plus typed questions and returns type-safe decisions with calibrated probabilities in 70–500 ms, with no hallucinations and no type errors.

How is Jev different from an LLM like ChatGPT or Claude?

LLMs generate strings token-by-token and can hallucinate or make type errors. Jev uses a parallel sampler and RLCD training to output typed decisions directly, with guaranteed schema matching, calibrated confidence, and free output tokens at $42 per billion input tokens.

How fast and cheap is Jev compared to LLMs?

TypeSafe reports 193.6× faster (70–500 ms vs 3–329 s) and 444.6× cheaper on automation workflows, measured against frontier LLMs. Input costs $0.042 per million tokens; output tokens are free.

What is Jev good for?

AI-powered workflows, real-time apps, map-reducing over big data, and verifying LLM outputs. Jev is not for open-ended chat or code generation where you need strings — use an LLM there and Jev as the verifier or router.

Where does the name Jev come from?

Jev is named after economist William Stanley Jevons (Jevons paradox), and System One Models are named after Kahneman's fast System 1 thinking in Thinking, Fast and Slow.