What Is Jev?

If you have been following AI news over the past few days, you may have seen Jev suddenly appearing across social media, usually alongside claims that it is dramatically faster and cheaper than today's leading AI models. But what exactly is Jev, and why is it different from ChatGPT, Claude or other large language models?

Jev is a new AI model from San Francisco startup TypeSafe AI, built for something much narrower than conversation. Instead of generating open-ended text, it is designed to make fast, structured decisions inside software.

How Does Jev Work?

Most AI models people interact with today are designed to generate language. Ask ChatGPT or Claude a question and the model produces a sequence of words. Even when software only needs a simple decision, such as which department should receive a customer request, whether a transaction looks suspicious or which tool an AI agent should call next, a large language model will normally generate an answer that then has to be interpreted or converted into structured data.

TypeSafe AI thinks that is an inefficient way to build automated systems.

On September 15, the San Francisco startup launched Jev, its first model in a category it calls "System One Models." Jev is currently available in early access. The term "System One Models" is TypeSafe's own, inspired by the distinction between fast, intuitive "System 1" thinking and slower, deliberative "System 2" thinking popularised by psychologist Daniel Kahneman.

Jev is designed specifically for the small decisions that happen inside software.

Instead of asking it to write an answer, developers give Jev some information, what TypeSafe calls the state, and one or more predefined questions. Jev returns structured answers and probabilities that software can immediately use.

For example, a customer support system could send Jev a complaint and ask which team should handle it. The available answers might be "billing," "shipping" or "returns."

Jev does not compose a sentence explaining its reasoning. It might instead return:

Returns: 60%
Billing: 38%
Shipping: 2%

The application can then decide what to do with those numbers. A high-confidence result could trigger an automatic action, while an uncertain one could be sent to a person for review.

Three Types of Decisions Jev Can Make

Jev currently supports three basic types of questions.

Choice asks the model to select from a predefined set of options. A single Choice question can contain up to 255 options, and the model returns a probability for each one.

Score asks it to judge something against an ordered scale.

Noul, TypeSafe's name for its yes-or-no primitive, returns the probability that a statement is true.

Multiple questions can be submitted together and evaluated against the same information. TypeSafe says Jev processes those questions in parallel rather than generating answers sequentially, which is central to its speed advantage.

Why Is Jev So Fast and Cheap?

TypeSafe attributes the speed and low cost to giving up open-ended text generation and evaluating all questions in parallel. The company also acknowledges it cannot yet prove its pricing is not subsidized, though it says it expects prices to go down rather than up.

TypeSafe currently charges $0.042 per million input tokens, with no charge for output tokens. The current Jev 1.13 model supports up to 64,000 tokens across a request, while the state plus the longest individual question can use up to 32,000 tokens. It currently accepts text and structured text data, but not images, audio or video.

TypeSafe reports end-to-end response times of roughly 70 to 500 milliseconds and says Jev can be 40 to 200 times faster than frontier language models on the kinds of tasks it is designed for. In its own workflow evaluations, the company has published even larger peak differences, up to 193.6 times faster and 444.6 times cheaper in some comparisons.

How Does Jev Compare With Large Language Models?

This also makes Jev quite different from simply telling an LLM to return JSON. A conventional LLM is still generating tokens underneath the structured interface. Jev is built around producing constrained decisions in the first place.

TypeSafe argues that this also makes Jev different from simply telling an LLM to return JSON: a conventional LLM still generates its output token by token underneath the structured interface, while Jev, according to the company, is built to produce constrained decisions directly.

Those numbers require context.

The evaluations were created and run by TypeSafe itself. The company explicitly says the published gains are likely to represent the higher end of what users will see in practice and acknowledges that some bias may exist because members of its own model capabilities team designed the workflows. Its reference answers are also based on the average responses of powerful external models rather than independent human ground truth. The same evaluations also show that Jev is not the most accurate option. Averaged across TypeSafe's four workflows, Jev agreed with the reference answers 67.8% of the time, roughly level with Claude Sonnet 5 and GPT-5.6 Terra, but behind GPT-5.6 Sol (74.1%) and Claude Opus 5 (73.1%). On invoice processing the gap was wider: 61.8% for Jev versus 79.1% for Sol. TypeSafe itself notes that because the reference answers were produced by OpenAI and Anthropic models, the test may favour those companies' models and understate how well Jev performs.

How Can Jev Use a Browser if It Does Not Generate Text?

Browser automation offers a useful example of how this model could fit into larger AI systems.

A project from Browser Use has demonstrated an agent using Jev to navigate Google Flights. Jev receives a structured representation of the webpage and rapidly decides which operation to perform and which page element to target. When the agent needs to actually generate text, such as typing a city name, a separate fast language model, Inception's Mercury 2.5, handles that part.

The current Browser Use demo completes one Google Flights task in just over seven seconds. The developers are careful to say that this is a small demonstration on one task, not evidence of general browser-agent reliability.

That distinction explains the role Jev is intended to play.

It does not necessarily replace a Claude or GPT model. Instead, it can sit alongside one.

Jev might decide which tool to call, whether a result is safe, where a request should be routed or whether another model's answer requires review. A generative model can then handle the parts that actually require language.

"Cannot hallucinate" does not mean "cannot be wrong"

TypeSafe prominently describes Jev as a model that cannot hallucinate. That claim needs careful interpretation.

Because developers define the possible output types in advance, Jev cannot suddenly produce an unexpected paragraph, invent a new category or return malformed output outside the schema. In that specific sense, an entire class of output-format and type errors disappears.

But Jev can still make the wrong decision.

If the valid options are "fraud" and "not fraud," the model may confidently choose the wrong one. Constraining the format of an answer does not guarantee that the underlying judgment is correct.

TypeSafe itself documents several weaknesses in Jev 1.13. The model can interpret instructions too literally, performs poorly at arithmetic and counting, struggles with date comparisons and multi-step indirection, and can lose accuracy when large amounts of irrelevant information are included in the input. The company recommends leaving mathematical calculations and deterministic logic to conventional code.

Jev's architecture is only partly disclosed. TypeSafe says it developed a new model architecture, a parallel sampling system and a training method called Reinforcement Learning for Calibrated Decisions, or RLCD. TechCrunch reports that Jev is transformer-based and that outside observers suspect it is built on top of an open-weight LLM. TypeSafe co-founder Diogo Almeida told the publication that it is trained exclusively on synthetic data.

Jev is available as a hosted API, directly from TypeSafe and through platforms such as Vercel AI Gateway and Cloudflare, but not as an open-weight model.

Where Could Jev Be Used?

Jev arrives as much of the AI industry is focused on making general-purpose models increasingly capable. TypeSafe is making a different bet: that many useful AI systems do not need another model capable of writing essays, reasoning across every domain and holding a conversation.

They need millions of small judgments to be made quickly and cheaply.

Potential applications include fraud review, customer-support routing, security-incident triage, agent-trace review, classification, LLM guardrails and choosing actions inside AI agents.

That could make models like Jev particularly useful in systems where a full frontier LLM is unnecessary for every step.

Why Jev Matters

TypeSafe was co-founded by former OpenAI researcher Diogo Almeida, a co-author of the 2022 InstructGPT paper on training language models to follow instructions using human feedback. The company emerged from stealth alongside Jev with a $40 million seed round led by DCVC.

Whether "System One Models" becomes a wider category or remains TypeSafe's terminology is still an open question. Jev was released only days ago, independent evidence remains limited and many of its most striking performance claims still need broader testing.