TypeSafe Jev: The Model That Returns Decisions, Not Text

On September 15, 2026, TypeSafe AI released Jev in early access — a model that does not generate strings. Instead of producing text that applications parse, validate, and route for errors, Jev accepts structured program state as input and returns typed values with calibrated probabilities. The output schema is defined before the call. Type errors are architecturally impossible. End-to-end response time is 70 to 500 milliseconds. Input pricing is $0.042 per million tokens, with output effectively free.

TypeSafe’s founder, Diogo Almeida, spent years at OpenAI building the training methods behind ChatGPT — specifically the RLHF work that made language models useful at following instructions. He came away from that work with a question he describes as his driving obsession for the four years since: models have been superhuman at chat for years, so where is all the automation? Jev is his answer, or the first part of it.

What a System One Model Is

TypeSafe borrows the framing from Daniel Kahneman’s Thinking, Fast and Slow. Kahneman’s System 1 is fast, intuitive, pattern-matching cognition. System 2 is slow, deliberate, effortful reasoning. Existing LLMs, Almeida argues, are optimized for human evaluators reading generated text — through RLHF and verifiable reward signals. Jev is trained with what TypeSafe calls Reinforcement Learning for Calibrated Decisions (RLCD), optimizing instead for calibrated accuracy on structured decision tasks.

The model is named after William Stanley Jevons, the 19th-century economist who formalized marginal utility theory. The choice is pointed: Jevons was interested in how agents allocate limited resources toward decisions, not in how they narrate those decisions.

The Architecture Difference: Parallel Sampling

The performance gap between Jev and frontier LLMs is structural, not a matter of scale. LLMs sample autoregressively: each token conditions on the previous one. A 200-token response requires 200 sequential sampling steps, and the model does not know at token 1 what it will decide by token 200. This is appropriate for tasks where the output form cannot be specified in advance and must be discovered through generation.

Jev generates all outputs in a single parallel query. Because the output schema is defined before the call and outputs are typed values across a fixed space rather than tokens in sequence, generation does not scale with output complexity. TypeSafe reports end-to-end latency of 70 to 500 milliseconds, against 3 to 329 seconds for frontier LLMs on comparable structured tasks.

TypeSafe’s published workflow evaluations compare Jev against GPT-6 Astra and Fable 5.1, reporting Jev holding the Pareto frontier of intelligence versus cost by approximately two orders of magnitude on structured automation tasks. The company acknowledges the workflows were built by its own capabilities team and that LLM reference answers skew toward OpenAI and Anthropic models. Independent replication on domain-specific tasks should precede any full deployment commitment.

Why Hallucination Is Architecturally Impossible — and What That Actually Means

This claim is both true and narrower than it sounds, and the distinction matters for how you use the model.

A hallucination in the sense relevant to structured outputs is when a model produces a value outside the expected type or schema: a string where an integer was expected, a label not in the defined set, a confidence score outside [0,1]. For Jev, the output space is fixed at definition time. The model selects from or assigns probabilities across the schema elements specified. It cannot emit values outside that space. So within the defined schema, structural hallucination is architecturally impossible.

This does not mean Jev cannot be wrong. A classification that returns a valid schema value but the incorrect label is a wrong decision, not a structural hallucination. The claim covers output format, not factual correctness of decisions. The practical implication is that validation and error-handling code for schema violations can be removed from the application — a real simplification for high-throughput pipelines.

Calibrated Probabilities as a First-Class Output

Every Jev output includes calibrated probabilities alongside the structured value. TypeSafe’s framing: a model that makes the right call 95% of the time but cannot identify which calls fall in the 5% cannot be embedded in automated workflows without human oversight on every output. A model that returns “61% confidence on this classification” lets downstream routing rules handle low-confidence cases through a different code path or escalation, without engineers instrumenting their own confidence estimation.

This matters most for multi-stage pipelines. When Jev outputs feed into subsequent Jev queries, probability scores propagate through the workflow. A multi-stage classification system can accumulate confidence estimates and only escalate where compound uncertainty crosses a threshold. With string-generating models, confidence scores are themselves generated text, subject to calibration drift — the model outputs “95% confident” not because it has a reliable internal probability but because that phrasing appeared in positive training examples.

The Doom Demo and Real-Time Cost Profile

At launch, TypeSafe demonstrated Jev playing Doom in real time at 10 queries per second. The model classified game state, routed decisions, and controlled action selection without generating a single string. Running cost: approximately $7 per hour. At $0.042 per million input tokens with output effectively free, 10 queries per second across an 8-hour workday costs about $1.21 in input tokens alone — less than rounding error on most cloud compute bills.

The demo is narrow, but the cost profile is real and applies directly to high-frequency automation: content moderation queues, real-time routing decisions in agentic systems, guardrail evaluation at inference time, and intent classification in multi-turn assistants.

What Jev Is Not Suitable For

TypeSafe is direct about the trade. Jev cannot write code, produce explanations, conduct conversations, or handle any task where the output form cannot be specified in advance. The right mental model is a typed probabilistic function in ordinary code: unstructured state in, typed values with confidence scores out. That fits classification, routing, intent extraction, feature scoring, guardrail evaluation, and high-cardinality branching. It does not fit tasks requiring generated reasoning traces, open-ended research, code synthesis, or outputs that vary structurally with content.

What This Means for Engineering Teams

The evaluation question is whether AI calls that currently use a frontier LLM with a structured output prompt — returning JSON that gets parsed, validated, and error-handled downstream — could be replaced with a purpose-built typed model. If the task is classification, routing, feature extraction, or verification, and the output schema is stable, Jev’s latency and cost profile will be significantly better. The engineering simplification is also real: the parser, the schema validation layer, and the error-handling code for malformed outputs all disappear.

For teams building AI agents and automated decision pipelines, Jev is a candidate for the decision nodes — classification, routing, scoring, and gating — while a reasoning model handles generative parts. Mixing model types based on what each node actually needs is a better architecture than defaulting every call to the same frontier model.

Teams working on AI system design should evaluate where calibrated probabilities would change downstream system behavior. Many current pipelines treat AI outputs as binary decisions because reliable confidence extraction from generated text is unreliable. A model that returns calibrated confidence natively changes the design space for exception handling and human-in-the-loop routing: the system can compute compound confidence across pipeline stages and escalate only where uncertainty crosses a defined threshold, instead of routing all uncertain outputs to manual review.

Key Takeaways

• Jev is trained with RLCD rather than RLHF, optimizing for calibrated structured decisions rather than human-preferred generated text. It was built by Diogo Almeida, who previously led the RLHF work behind ChatGPT at OpenAI.
• Parallel sampling generates all outputs in a single query; end-to-end latency is 70–500ms versus 3–329 seconds for frontier LLMs on comparable structured tasks.
• Structural hallucination is architecturally impossible within the defined schema — the output space is fixed at definition time. This does not prevent the model from making wrong decisions, only from emitting invalid types.
• Calibrated probabilities are a first-class output, enabling downstream routing rules based on model confidence rather than requiring engineers to instrument confidence estimation separately.
• At $0.042 per million input tokens with output effectively free, continuous operation at 10 queries per second costs approximately $7 per hour.
• Jev cannot generate text, write code, or handle tasks with variable output structure. It is only suitable where the output schema is known and stable before the call.
• TypeSafe’s published benchmarks were built internally; independent replication on domain-specific tasks has not yet been published.

Work With Origins AI

Origins AI builds production AI systems for engineering teams. If you are designing AI automation pipelines and want to evaluate where typed probabilistic models fit alongside reasoning models, talk to our team.