Jev
: How to use it, features, and the business problems it solves

What Jev is

Jev is a System One model released on 15 September 2026 by TypeSafe AI, based in San Francisco. Rather than generating text like an LLM, it does one thing: given a state (text or JSON), it returns typed judgements with probabilities attached.

What comes back is a label like "technical", a level like 1.6, a probability like 0.92. No string is generated, so there is no parsing step and no retry loop for malformed output. It is built for the same judgement repeated at volume — support triage, LLM guardrails, RAG re-ranking.

As of 19 September 2026 it is in early access behind a waitlist, with developers invited in order.

What "System One model" means

The name comes from Daniel Kahneman's Thinking, Fast and Slow: System 1 is fast and automatic, System 2 slow and deliberate. TypeSafe's argument is that today's LLMs are all built toward System 2, while most of the judgement a production system needs is System 1 work.

"Which team owns this ticket." "Is this urgent." Until now, every one of those meant wheeling out the chain-of-thought machine.

TypeSafe says this behaviour required a new architecture, a new sampler, and a training algorithm it calls RLCD (Reinforcement Learning for Calibrated Decisions). Its stated reasoning: RLHF optimised for human preference, and the side effects — mode dropping, overconfidence, unreliability — are what force a human back into the loop. Jev goes the other way.

How often the type broke (left: structured output, right: tool calls; lower is better). Source: TypeSafe AI blog

These are the two charts TypeSafe publishes. On structured output error rate: Jev 0%, GPT-5.6 Luna 0.58%, Claude Haiku 4.5 45.5%. On tool call error rate: Jev 0%, Claude Opus 5 0.67%, GPT-5.6 Sol 17.0%. What is measured here is whether the answer came back in the type you specified — not whether the judgement was right. These numbers are why the retry path never quite goes away, even in JSON mode.

Three question types decide what you get back

There are only three. That constraint is exactly why the output type cannot break.

The Primitives page in the official docs; the left nav lists Choice, Score and Noul alongside Confidence and Patterns. Source: TypeSafe AI documentation

The docs warn against confusing Score and Noul. "Intermediate skill" is not a Noul of 0.5; that reads as "I cannot tell whether this is true."

Stacking questions costs nothing in latency

This is where the design pays off. Every question in a request is evaluated in parallel, and the docs state that adding questions "typically doesn't add any latency to the response."

That licenses speculative fan-out: send the questions that only matter on one branch too. If the ticket turns out to be a feature request, throw the bug-severity answer away — you still spent one round trip where an LLM would have spent two.

Part of the incident triage pipeline TypeSafe publishes. The probability thresholds (P > 0.75, 0.15–0.60) are the branch conditions themselves. Source: TypeSafe AI blog (excerpt)

The security-alert example TypeSafe publishes is the clearest implementation of this. One alert gets two Bool questions about whether the activity was authorised and one Score question about how strong the evidence is, and then: act above 0.75, auto-close below 0.15, and in between (0.15–0.60) either notify the user or escalate to Tier 2. The thresholds are the operating policy.

How to use it

1. Join the waitlist

   Sign up via "Join Waitlist" on the official site. As of September 2026 Jev is in early access, with TypeSafe saying it is inviting developers "as quickly as we can."

2. Create an API key

   Create an account at console.typesafe.ai and generate a key. It is shown exactly once. The environment variable is TYPESAFE_API_KEY.

3. Work out your wording in the Playground

   The console Playground takes a state as plain text on the left and questions as JSON on the right, and reports measured latency. Settle instructions and criteria here before installing anything.

4. Call it from an SDK

   Python is pip install typesafe-sdk; JavaScript/TypeScript is npm install @typesafe-ai/sdk (Node.js 20+).

   from typesafe_sdk import Choice, Noul, Score, TypeSafeClient
   
   client = TypeSafeClient()
   
   response = client.system_one(
       state=ticket,
       questions={
           "department": Choice(
               instructions="Which team should handle this",
               criteria={
                   "billing": "Payment or subscription issues",
                   "technical": "Bugs or integration problems",
                   "sales": "Pricing or account questions",
               },
           ),
           "frustration": Score(
               instructions="How frustrated the customer appears",
               criteria=["Calm", "Frustrated but civil", "Very angry"],
           ),
           "is_urgent": Noul(
               instructions="The message conveys urgency or time-sensitivity",
           ),
       },
   )
   
   print(response.answers["department"].choice)  # "billing"
   print(response.answers["frustration"].score)  # 1.035
   print(response.answers["is_urgent"].noul)     # 0.999
   

5. Set thresholds on confidence

   Use the returned confidence to split automatic action from human review. The published starting points are: above 0.9 act automatically, 0.5–0.9 confirm or flag, below 0.5 do not act. The real point is to scale the threshold with the consequence of the action.

6. Let a coding agent do the rewrite

   TypeSafe publishes an agent skill. For Claude Code: claude plugin marketplace add typesafe-ai/skills then claude plugin install typesafe@typesafe-ai. It is useful for finding brittle parsing code in an existing repo and converting it. TypeSafe notes that "agents aren't great at writing questions, so expect to edit collaboratively with them."

Features

Pricing

Usage-based on input tokens only; output tokens are free (the docs say "too cheap to meter").

The comparison the official site leads with. In the output column on the right, only Jev reads FREE. Source: TypeSafe AI

The official site claims "238x lower input price than Claude Fable 5.1" and "193.6x faster, 444.6x cheaper" on System One workflows, alongside a single-task measurement of $0.000081 in 0.114s for Jev versus $0.013880 in 8.566s for LLMs.

Accuracy against cost; the x axis is dollars per workflow on a log scale. Source: TypeSafe AI blog

This chart places Jev more honestly than any ratio does. Jev is not the most accurate model. Averaged over the four workflows it lands around 68%, about six points short of GPT-5.6 Sol at roughly 74%. Where Jev sits is the same accuracy band for two orders of magnitude less money: Luna reaches ~67% at ~$0.003 and Terra ~68% at ~$0.04, while Jev gets ~68% at ~$0.0004.

So the question is not whether Jev is smart. It is whether this particular workload is worth six accuracy points. If your design already routes the uncertain cases to a person, cheaper wins; if a single miss is expensive, staying on Sol is the safer call.

Using it on non-English input

Non-English state is accepted, but the docs state that CJK scripts have lower accuracy than English. English is Jev's first language and where it performs best. Documentation and console are English-only; there is no localised UI or support.

Hands-on tests in Japanese returned 0.97–0.98 on urgency judgements, so it does work. But "it works" and "it is accurate enough to ship" are different claims. The order to follow:

1. Write instructions and criteria in English — leave the state in its original language, give the directions in the model's strongest language
2. Measure once against labelled data — 100–300 past items with human labels
3. Start with a high threshold and keep people in the loop — automate only above 0.9 at first

Where it struggles

TypeSafe documents Jev 1.13's failure modes itself, on a page called model-jaggedness. Read it before shipping.

Also, mathematical relationships between related questions are not guaranteed: ask "is A" and "is not A" as two Nouls and the probabilities need not sum to 1. If you need that, collapse them into one Choice.

And it cannot generate text — TypeSafe states it was not trained to, and that forcing it through chaining is poor and slow.

The company behind it

TypeSafe AI is based in San Francisco and emerged on 15 September 2026 after two years in stealth, with a $40 million seed round led by DCVC (Forbes reported a valuation near $200 million).

That the person who co-invented RLHF is now building in the opposite direction — citing RLHF's overconfidence and unreliability as the reason — is part of why the launch drew the attention it did.

How it compares to other AI models and APIs

Jev does not replace a general-purpose LLM. It exists to move one slice of the work out of it.

• Claude — handles writing and long reasoning; Jev sits on either side of it for guardrails and output verification. A complement, not a competitor
• ChatGPT — for classification and extraction alone there is GPT-5.6 Luna at $0.20 per million input tokens. The gap is roughly 5x on price, plus output billing and the parsing step. If you are already on OpenAI, check the cheap model first
• Dify — the LLM node deciding a workflow branch is exactly a decision with known options; moving it to Jev takes that step from seconds to milliseconds
• Claude Code — with the official skill installed, it can find brittle parsing in a repository and convert it into Jev calls

Frequently asked questions

Information on this page reflects what TypeSafe AI published on its site, documentation and blog as of 19 September 2026. Jev is in early access; specifications, pricing and rate limits may change. Check the official site for current details.