What Is Jev? TypeSafe AI's Decision Model, Explained

Jev is an AI model that answers questions instead of writing text. You give it some content, such as a support ticket, and a list of questions with the answers you allow ("which team: billing, technical or sales?"). It sends back the answer it picked and a probability for every option, usually within a few hundred milliseconds. TypeSafe AI released it in limited early access on 15 September 2026, Its Hacker News launch thread has since passed 1,900 points and 500 comments.

Think of a chatbot like ChatGPT as an essay writer, and Jev as someone sitting a multiple-choice exam who writes their confidence in the margin. When your code only needs the tick in the box, paying for the essay and then parsing it is waste.

How does Jev work?

You send Jev the content to judge, which TypeSafe calls the state, plus a set of questions, each with the answers it's allowed to give. Jev returns one typed answer per question with a probability for every option.

Here is the example from TypeSafe's own quick-start guide, shortened:

{
  "state": "Hi, I've been trying to connect my Stripe account for 3 days and the integration keeps failing. I'm losing sales. Please help ASAP.",
  "model": "jev-latest",
  "questions": {
    "department": {
      "type": "choice",
      "instructions": "Which team should handle this",
      "criteria": {
        "billing": "Payment or subscription issues",
        "technical": "Bugs or integration problems",
        "sales": "Pricing or account questions"
      }
    },
    "is_urgent": {
      "type": "noul",
      "instructions": "The message conveys urgency or time-sensitivity"
    }
  }
}

And the answer that came back:

{
  "model": "jev-1.13.0",
  "answers": {
    "department": {
      "type": "choice",
      "choice": "technical",
      "confidence": 0.78,
      "probabilities": { "technical": 0.85, "billing": 0.15, "sales": 0.0 }
    },
    "is_urgent": { "type": "noul", "noul": 1.0 }
  }
}

Nothing in that response needs parsing. choice is one of the three words you supplied, and it can never be anything else. The 15% on billing tells you the model saw a hint of a payment problem (Stripe is a payments company), and confidence summarises how sure it is overall. Your code can now do what code is good at: if department.confidence > 0.7: assign_to(department.choice).

The three kinds of question

Every question you ask Jev is one of three types, and choosing the right one is most of the skill.

The docs are careful about a trap here. A Noul of 0.5 does not mean "medium". It means the model thinks yes and no are equally likely. If you want to measure how much Python experience a candidate has, use a Score with levels like "none, some familiarity, daily use, deep expertise". TypeSafe's own example shows why: asked "is the candidate strong in Python?", someone who uses it daily at work got 0.81 and an eight-year Django veteran got 0.92. The Score version put them at 2.05 and 2.89 on the scale, which is far easier to reason about.

You can mix all three types in one request. Every question is judged separately against the same state, in parallel, so adding questions barely changes the response time. TypeSafe's parallel-questions cookbook sent 13 questions about a 54,000-character article in one call for $0.0005 and 0.27 seconds. Asked one at a time, the same 13 questions cost $0.0061 and took 2.71 seconds, with identical answers. So TypeSafe's advice is to ask every question your code might need in the same call, and let the code ignore the answers it doesn't use.

Probability, confidence and "I don't know"

The feature TypeSafe leans on hardest is calibration. The claim is that across many predictions, answers given a probability of 0.8 should turn out right about 80% of the time. TypeSafe says it gets there with a training method it calls RLCD (reinforcement learning for calibrated decisions), set against RLHF, the preference training behind chatbots, which its docs say rewards confident-sounding answers over accurate ones. RLCD itself hasn't been published.

In practice you use the number to decide how much to trust each answer. The docs suggest three bands: act automatically when confidence is high, ask for confirmation in the middle, and hand low-confidence cases to a person. The thresholds should depend on the stakes, so the banking example in the docs lets a balance check through at modest confidence but wants more than 0.9 before approving a transfer.

A good worked example is TypeSafe's classification cookbook. It sorted 60 company filings into 75 industry groups. When the model was forced to answer every time, 39 of 60 were right. The half it was confident about scored 27 of 30, the unsure half only 12 of 30. For the unsure cases the cookbook reports the broader industry division instead of the specific group, which lifts useful answers to 48 of 60 without a second call.

Treat the calibration claim with some care, though. Alex Molas pointed out that calibration depends on the data you feed a model, so one shared model can't be calibrated for everyone's data at once. He showed Jev giving a fair coin a 0.92 chance of heads. His recommendation, which I'd follow, is to treat Jev's numbers as good rankings and recalibrate them with a few hundred labelled examples from your own traffic.

How fast is Jev, and how much does it cost?

Jev reads the state once and evaluates all your questions against it in parallel, and it never generates a long answer token by token. That explains most of the speed. TypeSafe quotes 70 to 500 milliseconds end to end and "40x–200x faster" than frontier language models on this kind of task. Independent measurements are in the same range: 0.32 seconds median in one independent test, and 422 milliseconds per query in a reranking benchmark. The service runs on the US West Coast, so your distance from it matters.

The price is $0.042 per million input tokens, and output tokens are free. Some real numbers:

• The quick-start request above used 392 input tokens, which costs about $0.000016.
• 100,000 support tickets a month at around 400 tokens each is 40 million tokens: about $1.68.
• In TypeSafe's consistency test, a call with eight questions cost $0.000046 and took 114 milliseconds on average. The LLMs it tested took between 0.8 and 13 seconds per call and cost 20 to 900 times more.

The bigger multiples on TypeSafe's homepage, around 194 times faster and 445 times cheaper, come from its own four "workflow evals". To its credit, the launch post lists the weaknesses of those evals itself: TypeSafe built the workflows, the reference answers came from other AI models rather than people, the inputs were kept short, and the price may not stay this low. Read them as a best case.

Who makes Jev?

TypeSafe AI is a San Francisco company founded in 2024. It came out of stealth on 15 September 2026 with $40 million in seed funding led by DCVC. The CEO, Diogo Almeida, was a researcher at OpenAI and worked on InstructGPT, the model that led to ChatGPT. His co-founders are Erik Gafni and Sasha Sheng.

The two names explain what TypeSafe is betting on. "System One" comes from Daniel Kahneman's Thinking, Fast and Slow, where System 1 is fast, intuitive judgment and System 2 is slow deliberation. "Jev" is, in the words of the press release, a nod to the Jevons paradox: in 1865 William Stanley Jevons noticed that more efficient steam engines made Britain burn more coal, not less. TypeSafe expects the same with AI decisions: make them cheap enough and software will ask for far more of them.

Demand briefly knocked out TypeSafe's API in the first week, according to TechCrunch. Competition arrived quickly too. On 29 September The New Stack reported OpenAI answering Jev with a Decision API built on its Luna model.

What independent testers found

The model has only been public for two weeks, so treat these as early results.

On ordinary judgment tasks, it holds its own against non-reasoning LLMs. Lindfors tested 24 Norwegian consultation documents for about half a cent in total. Jev matched DeepSeek with reasoning off on stance (20 of 24), beat it on an ordered scale (19 vs 14), and was right 14 times out of 15 when it said 0.9 or above. The reference labels came from another AI model rather than people, so this is agreement, not ground truth.

As a reranker, it ties a dedicated product. An open benchmark across 8 datasets found Jev at nDCG@10 0.692 against Cohere Rerank 4 Pro's 0.691, statistically a tie, at about half the latency and a fifth of the cost. It also handled negation slightly better.

Its developer fans report real wins. In TechCrunch, a Vercel engineer said replacing an OpenAI model with Jev in one of their classifiers gave results 5 to 18 times faster, and more accurate.

The skeptics have fair points. Sean Goedecke argues that an ordinary LLM can get most of the speed by generating a single constrained token, so the moat may be shallow. He calls the "can't hallucinate" framing a semantic dodge: Jev can't invent an option, but it can still pick the wrong one. Armin Ronacher made the practical point in TechCrunch that a 50% answer is a coin toss, and deciding what to do with it is now your job.

What is Jev bad at?

TypeSafe publishes an honest list of weak spots for the current version, and it's worth reading before you build anything. In plain terms:

• It reads literally. It answers the question you wrote, not the one you meant. If you find yourself explaining what you really meant, that explanation belongs in the instructions.
• It can't do maths. Counting, arithmetic and comparing numbers or hex colours are unreliable. Do those in code.
• It can't compare dates. Let Jev extract the day, month and year as Choice questions, then compare them in code.
• Long, noisy input hurts. Irrelevant text in the state lowers accuracy, so filter first and send only what the question needs.
• Adversarial text can move it. Content written to argue for its own classification can shift the answer, and TypeSafe's own RAG cookbook says its prompt-injection check is a filter, "not a security boundary".
• It isn't deterministic. In TypeSafe's repeatability test, Jev's top answer flipped between runs on 2 of 8 borderline moderation questions. The fix is an explicit "uncertain" band that goes to a person.
• It can't write. For replies, summaries or code, you still need a generative model.

It also accepts text only, works best in English, and currently has one version (1.13). The jev-latest alias will move when a new version ships, so pin the version if you've tuned thresholds against it.

Where I'd put it in a real system

Jev makes the most sense as the fast gate in front of the expensive parts. In the support and RAG systems I build, there are three obvious slots.

The first is triage. One Jev call per incoming message can decide the team, the urgency and whether the customer wants a human, and code routes it. Only the messages that need a written reply ever reach a language model.

The second is filtering what retrieval returns. Similarity search happily returns passages that are off-topic, that contradict the question, or that contain injected instructions. TypeSafe's cookbook asks four yes/no questions per passage and drops the bad ones before the language model writes its answer. In their test, a planted forum post with an injection ranked first by similarity and was thrown out at 0.99.

The third is a checkpoint in agent loops: "is this tool call destructive?", "does this reply promise a refund?". These make fast pre-checks, as long as they sit alongside deterministic rules and never replace them.

In every case the pattern is the same one I'd use without Jev: code owns the workflow, the model makes narrow judgments, and low confidence goes to a person. Jev makes the narrow judgments cheaper and gives you a number to route on.

Should you use Jev?

Try it if you're paying a language model to output a label, a yes/no or a score, especially at volume or on a path where a user is waiting. The playground at console.typesafe.ai takes a couple of minutes, and the Python SDK is pip install typesafe-sdk.

Wait, or keep your current setup, if you need reasoning over several steps, arithmetic, non-English text at high accuracy, data processed outside the United States, or stable rate limits (TypeSafe's docs say its limits "can change without notice" while it scales). Enterprise zero data retention is available through sales.

Whatever you decide, test on a few hundred of your own labelled examples before trusting the probabilities. TypeSafe's docs and its critics both give that advice.

Further reading

• TypeSafe, Introducing System One models and Jev, the launch post with its own list of evaluation caveats.
• TypeSafe documentation, especially the pages on confidence and on Jev 1.13's failure modes.
• Tim Fernholz, A new kind of AI model from a ChatGPT inventor is thrilling developers, TechCrunch, 18 September 2026.
• Sean Goedecke, Jev means structured output is interesting again, 16 September 2026.
• Alex Molas, Jev can't be calibrated, 23 September 2026.
• Lindfors, A first look at TypeSafe's Jev, 18 September 2026.
• jev-rerank-bench, an open reranking benchmark against Cohere Rerank.
• Frederic Lardinois, OpenAI answers TypeSafe's Jev with a Decision API, The New Stack, 29 September 2026.