TypeSafe Jev: 150ms Typed AI Decisions at $0.042/MTok

On September 15, 2026, TypeSafe AI launched Jev, the first public model in a new category the company calls the "System One Model." It's built for the fast, structured decisions software makes directly, not for chat. The launch drew over 1,500 points on Hacker News, and an early access waitlist opened alongside it. TypeSafe AI emerged from roughly two years in stealth, reportedly having raised a $40M seed round led by DCVC according to press coverage. This article breaks down how Jev works, what it costs, and how to think about using it.

Jev isn't a large language model in the free-text-generation sense. Its defining feature is that it outputs typed values matching a schema you define in advance, rather than generating open-ended strings. Every output is drawn from a predefined set of choices, each attached to a calibrated probability and an overall confidence score. Because outputs are structurally constrained to the schema, TypeSafe AI describes type errors as "mathematically impossible." That said, this only guarantees the output falls within the defined choices — it does not guarantee the choice itself is correct. Jev remains a probabilistic judgment model, and "cannot hallucinate outside the schema" is a different claim from "is always right."

Under the hood, Jev departs from token-by-token autoregressive generation. It uses what TypeSafe AI calls a parallel sampler, generating all candidate outputs in a single pass rather than one token at a time. Training also diverges from the LLM standard: instead of RLHF (Reinforcement Learning from Human Feedback) or RLVR (Reinforcement Learning from Verifiable Rewards), Jev is trained with TypeSafe AI's own method, RLCD (Reinforcement Learning for Calibrated Decisions). The stated goal of this training approach is calibration — making the output probabilities track the model's actual accuracy, rather than just optimizing for a single top answer.

- Smart if-statements inside workflows — pass in state and get back a typed decision instead of hardcoding branch logic
- Map-reduce style classification over large datasets — sorting support tickets or log lines at high speed
- Decision-making inside real-time applications where responses must land in well under a second
- Verifying LLM output — guardrails and jailbreak detection applied as a typed check on generated content
- Demos: a Doom-playing bot issuing 10 queries per second at roughly $7/hour, and a Wikiracing agent

The common thread across these use cases is that they call for fast judgment among a fixed set of options, not open-ended text generation. Jev is designed to be embedded as a piece of software logic, not to power a conversational interface.

It's a fair question whether this is just structured output or JSON mode by another name. The key difference is architectural: an LLM's structured output still runs a free-form generation process and then imposes formatting rules on top, which can be followed imperfectly. Jev's generation process is itself constrained to a typed space of choices from the start. It's also distinct from a classic ML classifier — unlike most classifiers, Jev accepts raw, unstructured natural-language state (a block of text, an event log) directly as input, without requiring feature engineering. Here's how the three approaches compare.

Jev is priced at $0.042 per 1M input tokens ($42 per billion), with output listed as free. Most LLMs charge for both input and output; Jev's design — returning only a decision plus probabilities — keeps output token volume small enough that pricing it at zero is workable.

As a worked example, consider classifying 1 million support tickets at roughly 500 tokens each. Total input volume is 1,000,000 x 500 = 500 million tokens. At $0.042 per 1M tokens, that's 500,000,000 / 1,000,000 x $0.042 = about $21 (output is free, so nothing to add). In TypeSafe AI's own published workflow evaluation, Jev came out 193.6x faster and 444.6x cheaper than the comparison LLM-based approach. The company is upfront that its own team built the eval, and that reference answers were the average of GPT-6 Astra and Fable 5.1 outputs — this is a vendor-run benchmark, not an independent third-party evaluation.

No widely documented SDK or API name has settled yet, so what follows is a conceptual usage pattern rather than a real API reference.

- Step 1: Define the set of choices you want a decision among as a schema (for example: "urgent," "normal," "spam")
- Step 2: Pass the raw state — unstructured text, an event log, whatever you have — directly to Jev
- Step 3: Jev returns a typed choice from the defined schema along with a probability distribution and confidence score
- Step 4: Route any case below a confidence threshold to an LLM or a human reviewer instead of trusting it automatically
- Step 5: For the high-confidence majority, use the typed decision directly as a branch condition in your workflow

A commonly discussed architecture pairs Jev as a fast first-pass router with an LLM handling the heavier reasoning behind it. High-volume events or requests first pass through Jev for a typed judgment; cases with high confidence get resolved immediately. Only the low-confidence cases, or judgments too complex for Jev's schema to express, get escalated to a slower, more expensive but more flexible LLM or a human reviewer. This "cheap fast model for the easy cases, expensive slow model for the hard ones" pattern applies equally when Jev is used to verify LLM output itself, such as in guardrail or jailbreak-detection use cases.

- Currently early access only, gated by a waitlist, with no announced general availability date
- The speed and cost benchmarks come from TypeSafe AI itself; there's no independent third-party verification yet
- Details like context length, supported languages, and parameter count are undisclosed
- Image input is not yet supported
- Accuracy on Japanese-language input has not been officially confirmed and should be tested independently before production use

Jev represents a new category: not an AI that writes text, but one that returns typed decisions fast. Millisecond-scale latency, cheap input pricing, and free output make it a plausible complement to existing tools for workflow branching, large-scale classification, and LLM output verification. That said, the published benchmarks are vendor-run, and specs like context length and supported languages remain largely undisclosed. Given its early access status, teams should validate accuracy and cost against their own use case before adopting it.