What Is TypeSafe AI?

What Is TypeSafe AI?

TL;DR: Jev is the first public "System One Model" from TypeSafe AI, released in early access on September 15, 2026. Instead of generating text, it returns typed, structured decisions with calibrated confidence scores, and TypeSafe says it does this 40x to 200x faster than frontier LLMs at a fraction of the cost.

Large language models have been impressive at conversation for years, yet most businesses still struggle to plug AI directly into their software. Chat models produce free-form text, which is slow, expensive, and sometimes wrong in ways code can't easily catch. TypeSafe AI built Jev to close that gap. This guide answers the key questions about what Jev is, how it works, and where it fits in a developer's toolkit.

What Is Jev AI?

TL;DR: Jev is an AI model that takes unstructured information in and returns typed, probabilistic decisions out. TypeSafe describes it as a frontier-intelligence function call.

Jev is the first publicly available model from TypeSafe AI, an AI lab focused on building intelligence infrastructure designed for machines rather than chat. Where a chatbot answers with paragraphs, Jev answers with values that your code has already defined, such as a category, a score, or a yes/no choice. Every answer also comes with a probability showing how confident the model is.

The company was founded by Diogo Almeida, who previously worked at OpenAI on the instruction-following research that later became the foundation for ChatGPT. After two years in stealth, TypeSafe launched Jev with a simple thesis: AI needs an interface that software can depend on, not just one that humans enjoy chatting with.

What Are System One Models?

TL;DR: System One Models are a new class of AI built for fast, structured decisions, inspired by the "fast thinking" idea from Daniel Kahneman's Thinking, Fast and Slow.

The name comes from psychology. Kahneman described two modes of thought: System 1, which is quick and intuitive, and System 2, which is slow and deliberate. Most modern LLMs lean toward System 2, reasoning step by step through long chains of text. System One Models aim for the opposite: instant, intuitive judgments that software can act on immediately.

TypeSafe acknowledges that "fast thinking" has a reputation for being error-prone, but argues its models can actually be made more reliable than the alternatives. The name "Jev" honors economist William Stanley Jevons, who observed that making coal use more efficient increased total demand for coal. TypeSafe expects the same pattern with AI: each big drop in the cost of intelligence should unlock far more use cases.

How Does Jev Work Differently From ChatGPT and Other LLMs?

TL;DR: LLMs generate text one token at a time. Jev generates all of its outputs in parallel, in a single query, as predefined structured values.

Traditional LLMs are autoregressive, meaning they produce one token at a time, with each token depending on the one before it. That approach is flexible because the output can be anything, including code, essays, or refusals. The downside is that software must then parse and validate that text, and there is always a chance the model drifts off course.

Jev takes a different path. TypeSafe built a new model architecture, a hardware-aware parallel sampler, and a new training method called Reinforcement Learning for Calibrated Decisions (RLCD). Developers define the possible outputs and their structure in advance, and Jev returns all answers at once. The trade-off is that Jev gives up free-form string generation entirely, which is exactly what allows it to be so fast and predictable.

What Is Reinforcement Learning for Calibrated Decisions (RLCD)?

TL;DR: RLCD trains Jev to give honest probabilities, so when it says it is 90% confident, it should be right about 90% of the time.

Most chat models are trained with methods like RLHF, which rewards answers that human raters prefer, or RLVR, which rewards outputs that can be automatically checked. Neither method specifically teaches a model to know when it might be wrong. Even when you ask an LLM for a confidence score, it often sounds overly sure and gives inconsistent numbers.

RLCD targets that weakness directly. It optimizes Jev to produce calibrated confidence, where higher confidence genuinely corresponds to higher accuracy. This matters enormously for automation. If a model succeeds 95% of the time but can't flag the other 5%, you can't safely let it run unsupervised. With calibrated scores, your code can route uncertain cases to a human and let confident ones proceed automatically.

Can Jev Really Not Hallucinate?

TL;DR: Jev cannot produce type errors or answers outside the schema you define, because its outputs are structurally constrained. TypeSafe says this makes schema mismatches mathematically impossible.

In the context of Jev, "can't hallucinate" means something specific. Because Jev only chooses among outputs that you define ahead of time, it cannot invent a category that doesn't exist, return a malformed JSON object, or call a tool that isn't there. TypeSafe notes this claim would be easy to disprove with a single counterexample, yet it is guaranteed by design.

This does not mean Jev is always correct. It can still choose the wrong option among valid ones, which is where its confidence scores become important. TypeSafe's point is that type safety is the minimum requirement for automation. A hallucinated tool call is a minor annoyance in a chat agent, but it can break an entire system when it sits deep inside a chain of dependent code with strict latency requirements.

How Fast and Cheap Is Jev Compared to Frontier LLMs?

TL;DR: TypeSafe reports response times of 70 to 500 milliseconds and input pricing of $0.042 per million tokens, with output tokens free.

According to TypeSafe, end-to-end responses from Jev take between 70ms and 500ms, compared with several seconds to several minutes for frontier LLMs. For comparable "System One" style tasks, the company estimates Jev is roughly 40x to 200x faster. On pricing, input tokens cost $0.042 per million (about $42 per billion), and output tokens are not billed at all, whereas LLM input costs typically range from about $0.20 to $10 per million tokens with output costing several times more.

On TypeSafe's own workflow evaluations, the company reports Jev ran 193.6x faster and 444.6x cheaper, though it openly says these figures are likely at the high end of real-world gains. TypeSafe is also transparent that its long-term pricing sustainability is still unproven, and that its latency tests were run from the US West Coast, where its service is currently hosted.

How Did TypeSafe Test Jev's Intelligence?

TL;DR: TypeSafe created "workflow evals" that compare Jev's decisions against the averaged answers of top frontier models on identical code-based workflows.

Rather than scoring models against a single ground-truth label, TypeSafe gave every model the same workflow written in code and compared its predictions with a reference answer. That reference was the average output of GPT-6 Astra and Fable 5.1, which TypeSafe treats as the smartest available models. By this measure, the company says Jev sits on the Pareto frontier of cost and quality across nearly two orders of magnitude.

TypeSafe is candid about the limits of this approach. The workflows were written by its own capabilities team, which could introduce bias, although they were not part of Jev's training data. Using OpenAI and Anthropic models as the reference may also tilt results toward those vendors. Full examples, disagreements, and queries are published on the company's evals site for anyone who wants to check the work.

What Can You Build With Jev?

TL;DR: Jev is designed for "smart if-statements" in code: classifying, routing, scoring, extracting, verifying, and powering real-time applications.

TypeSafe positions Jev as a fuzzy decision rule that drops into ordinary software wherever hand-written logic is too brittle. Typical tasks include classifying support tickets, routing requests, scoring leads, extracting fields from messy data, and branching workflows. Because the surrounding code limits what Jev can do, these pieces compose into more reliable systems than a free-roaming agent.

Other use cases include processing very large datasets to turn raw records into features, powering real-time features where 100ms responses keep the user experience smooth, and acting as a verifier that scores LLM outputs, judges reasoning, or detects jailbreak attempts. TypeSafe also showed playful demos, including a bot playing Doom at about 10 decisions per second for roughly $7 an hour, and a Wikiracing agent navigating Wikipedia links to reach a target page.

What Are Jev's Current Limitations?

TL;DR: Jev doesn't write text, supports up to 255 options per choice, currently works on text-based state rather than images, and is still in early access.

Jev is not a replacement for chatbots, coding agents, or any task where you need generated prose or code. It deliberately trades string generation for speed and structure. Each choice supports a cardinality of up to 255 options; for larger sets, TypeSafe uses a two-stage process that scores options independently first and then chooses, which can add some latency.

The Doom demo also ran on game state represented as structured text, not on screen images, although TypeSafe hints that image support may come later. And since Jev is newly launched, independent third-party benchmarks are still limited, so developers should test it on their own workloads before relying on it in production.

FAQs

Who makes Jev?
Jev is built by TypeSafe AI, founded by former OpenAI researcher Diogo Almeida.

Is Jev available to use now?
Yes, Jev is in early access, and TypeSafe is moving developers off its waitlist as quickly as it can. Documentation is at docs.typesafe.ai and the console is at console.typesafe.ai.

Is Jev just a smaller LLM?
No. TypeSafe describes it as a different class of model with its own architecture, parallel sampling, and training method, rather than a compressed chat model.

Can I compare Jev with my existing LLM?
TypeSafe publishes an open-source Python adapter on GitHub that constrains LLMs to output structured decisions compatible with its API, making side-by-side comparisons easier.

When should I use an LLM instead of Jev?
Use an LLM for chat, writing, code generation, and open-ended reasoning. Use Jev when your code needs a fast, structured decision with a trustworthy confidence score.