What Jev is

Jev is what TypeSafe calls a "System One Model": an AI model built to make fast, structured decisions that software can use directly. The name nods to psychologist Daniel Kahneman's idea that we think in two modes: System 1, fast and intuitive (the answer that comes to you), and System 2, slow and deliberate (step-by-step reasoning). The language models we know are System 2. Jev is System 1.

In practice: instead of generating text word by word, Jev picks from options you define in advance. You tell it "the possible answers are billing, tech support, or sales," you pass it the message, and it returns one of the three. It can also give a score (1 to 5), a yes/no, or a probability. Nothing else.

It was founded by Diogo Almeida, a former OpenAI researcher who worked on the training techniques behind ChatGPT. That someone who helped build the world's most famous chatbot is now shipping a model that doesn't talk is, in itself, part of the story.

Why it "can't hallucinate" (with one important caveat)

Here's what has people excited: because Jev can only pick from the options you defined, it's impossible for it to invent an answer outside that list. If the options are A, B, or C, a made-up D will never show up.

TypeSafe calls this being "type-safe" by design, and it eliminates hallucination in the sense of inventing values that don't exist. On top of that, every answer comes with a probability and a confidence level.

Now the honest caveat, because this is where headlines tend to overreach: not inventing an option doesn't mean always being right. Jev can pick the wrong option from the list, and do so with high confidence. Calibration is not the same as accuracy. It's still a model that can be wrong; what changes is that its mistakes stay inside a controlled, measurable frame instead of in free text that's hard to audit.

Fast and cheap: the numbers, without the hype

This is the other reason for the buzz. TypeSafe reports response times between 70 and 500 milliseconds, and an input cost of US$0.042 per million tokens, with output free. The company claims that, against a top-tier model, Jev can be up to 193 times faster and 445 times cheaper. Take those figures for what they are — a company's headline: in third-party tests the gains were more modest but still huge (a Vercel engineer quoted by TechCrunch reported 5 to 18 times the speed, with better accuracy).

To put it in perspective, it helps to compare the price per million tokens with the language models used for these tasks today:

One caveat for reading the table right: it's not apples to apples. A language model generates text and reasons; Jev only decides. It doesn't replace the LLM at everything, but on tasks where deciding is enough, the cost gap is on another scale. Only at those prices does it become viable to classify millions of reviews, messages, or records — something that would be prohibitively expensive with a large model.

What it's actually good for

Jev shines at repetitive, high-volume decisions where you know the possible answers in advance:

• Classify: detect the intent of a message, the type of a document, or which department a query should go to.

• Detect: fraud signals, policy violations, content that needs review.

• Score: severity of a case, sentiment of a review, quality or relevance on a scale.

• Route: pick the team, the workflow, or even which other AI model should handle a request.

The mental test TypeSafe suggests is simple: if you can frame the task as "given this context, tell me X," where X is an option, a score, or a probability, Jev probably fits.

How to combine it with other models

This is the part we care about most from a systems-design view: Jev doesn't come to replace language models, it comes to work with them. The most sensible architecture uses it as a fast decision layer at the front of everything:

Code → Jev decides → if confidence is high, automate; if it's low, send to human review; if the case is ambiguous or complex, escalate to a reasoning model that does think step by step.

Jev does the quick, cheap "gut check"; the LLM is reserved for what truly needs it: writing the reply, reasoning through a hard case, explaining. It can even act as a dispatcher: Jev looks at the request and decides which bigger, more powerful model should handle it. It's the same logic as not taking the truck to the corner store.

What it doesn't do: limits worth knowing

No tool does everything, and forcing one only adds risk. Jev doesn't generate text, code, or anything creative: if you need a written answer, that's a job for an LLM or a person. It doesn't reason in multiple stages or go looking for information: it works only with the state you give it. Questions inside a single request are answered independently, so if one decision depends on another, you have to chain them. And it's not for vague, multi-factor judgments like "how good is this candidate?", because those don't have a bounded set of answers. Like any model, it can also be sensitive to adversarial attacks or take a phrase literally instead of by intent.

Security and governance: the part that isn't in the headline

A model being fast and cheap doesn't make it safe on its own. The good news is that Jev ships with tools to govern it well.

The most important is automating by confidence: setting thresholds so only high-confidence decisions run on their own, and uncertain ones escalate to a person or a reasoning model. Higher-risk actions should demand stronger evidence. Because each question is evaluated separately, systems become easier to audit and test: you can see what it decided and why. And unlike the old approach of matching keywords, a "semantic if" understands meaning, which makes it more robust against tricks. One more thing: per TypeSafe, the model isn't trained on customer data and doesn't infer anything beyond the state you give it.

None of this is automatic. Thresholds, escalation points, and permissions are design decisions. The technology enables them; someone has to put them in place

Frequently asked questions

• What is Jev? It's the first model from TypeSafe AI, a "System One Model" that doesn't generate text: it makes structured decisions (classify, detect, score, route) by choosing from predefined options, with a probability and a confidence level on every answer.

• Why is Jev said not to hallucinate? Because it can only choose within the options you define, so it can't invent an answer outside that list. The important caveat: it can still pick the wrong option. Not inventing doesn't guarantee being right.

• Is it cheaper than ChatGPT or Claude? For decision tasks, dramatically so: Jev charges US$0.042 per million input tokens and output is free, versus several dollars per million for the large models. But it isn't an apples-to-apples comparison: LLMs also generate text and reason; Jev only decides.

• Does it replace language models? No. The smart move is to combine them: Jev as a fast, cheap decision layer up front, and an LLM (or a person) to write, reason through complex cases, or explain. Jev can even decide which more powerful model handles each request.

• What is Jev NOT good for? Generating text or code, reasoning in multiple stages, gathering information on its own, or judging vague, multi-factor questions without a bounded set of answers.

Jev confirms something we hold to in every system we build: using AI well isn't about always picking the model that knows the most — it's about knowing what you're asking it for. The most valuable part of an agent is almost never the part that writes elegantly. It's the part that makes the right decision, thousands of times a day, fast, cheap, and without going off the rails.

That one of ChatGPT's creators is saying this out loud shifts the conversation. But the real advantage doesn't come from buying the model of the moment. It shows up when someone designs the system around it: what the AI decides on its own, what escalates to a human, under what rules, and with what oversight. That part doesn't come prebuilt. It's the part you have to think through.