What Jev Is [September 2026]: The AI That Generates No Text — How System One Models Work, Pricing and Use Cases

On 15 September 2026, TypeSafe AI came out of stealth with $40 million in funding and released its first model, Jev, in early access. The Register covered it the next day as "a model for talking to machines rather than people," it spread across X and Bluesky, and Japanese engineering communities — Qiita and Zenn — filled with hands-on write-ups. Qiita even ran an official campaign, "Have you tried it yet? Let's play with the decision-specialised AI Jev," from 16 September to 2 October.

The reason it caught on is not the benchmarks. It is how easy the positioning is to grasp: an AI that does not generate text. Jev does not chat. Instead of answering a prompt with prose, it picks one of the options you defined up front and returns it with a probability attached. What comes back is "technical", 1.6, 0.92 — values you can drop straight into an if.

This article covers what Jev actually returns, how to choose between its three question types (Choice, Score, Noul), its pricing and speed, the path from the waitlist to your first request, and what to watch for when your input is Japanese — based on TypeSafe AI's official docs and blog plus published hands-on reports.

---

The short version

---

Why it blew up now

Three things landed in one week.

About the Doom demo: the engineer behind it openly admits a non-AI Doom bot plays better. It is a demonstration of speed and cost, not a performance claim.

What matters is that the conversation is not "replace the LLM." It is "take the judgement calls out of the LLM." Classification, prioritisation, guardrail checks — work we have been sending to GPT or Claude for want of anything better, asking for JSON back and retrying whenever the JSON broke. Jev handles exactly that slice.

---

What a System One model is

TypeSafe AI positions Jev as the first release in a new model class it calls System One models. The name comes from Daniel Kahneman's Thinking, Fast and Slow.

• System 1 — fast, automatic, intuitive. Reading a face, hearing anger in a sentence
• System 2 — slow, deliberate, step by step. Long multiplication, weighing a design

Today's LLMs, chain-of-thought included, are built toward System 2. Yet most of the judgement a production system needs is System 1 work: "which team owns this ticket," "is this urgent." Until now we have been wheeling out the System 2 machine every time.

The model name Jev comes from the economist William Stanley Jevons, known for the Jevons paradox — efficiency gains increase total demand rather than reducing it. The bet is that once a decision is cheap and fast enough, the number of decisions explodes.

How this differs from asking an LLM to classify

The published comparison, in numbers. LLM figures are typical ranges across vendors.

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.

---

What comes back: Choice, Score and Noul

There are only three question types. That constraint is precisely 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

Choice — pick one from a fixed set

Unordered classification: ticket routing, document type, language detection.

Choice(
    instructions="Which team should handle this",
    criteria={
        "billing": "Payment or subscription issues",
        "technical": "Bugs or integration problems",
        "sales": "Pricing or account questions",
    },
)

You get choice (the selected key), probabilities (the distribution across every option) and confidence (how peaked that distribution is). The docs recommend including an other or "none of the above" option whenever inputs might fall outside your list.

Score — rate along ordered levels

For scales where each position means something: bug severity, customer frustration, skill level.

Score(
    instructions="How frustrated the customer appears",
    criteria=[
        "Calm, just stating facts",
        "Frustrated but civil",
        "Very angry, strong language",
    ],
)

score lands between levels — 1.6, say — so "somewhere between 1 and 2" is expressible directly. You also get legend (the level table), probabilities and confidence.

Noul — how likely is this statement to be true

Jev's own type. You ask a yes/no question, but what comes back is a probability between 0 and 1, not a boolean.

Noul(
    instructions="The message conveys urgency or time-sensitivity",
)

Near 1 is a strong yes, near 0 a strong no, near 0.5 means it cannot tell. Noul has no separate confidence field — the probability is the confidence.

The docs warn against confusing Score and Noul. Do not express "intermediate skill" as a Noul of 0.5; that reads as "I cannot tell whether this is true," not "it is in the middle."

Stacking questions costs you nothing in latency

This is where Jev 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 a pattern called speculative fan-out: send even the questions that only matter on one branch.

response = client.system_one(
    state=ticket,
    questions={
        "category": Choice(...),        # always used
        "bug_severity": Score(...),     # only if it's a bug
        "has_repro": Noul(...),         # only if it's a bug
        "refund_requested": Noul(...),  # only if it's billing
        "frustration": Score(...),      # always used
    },
)

If the ticket turns out to be a feature request, you throw bug_severity away. That is fine. Where an LLM would need a round trip — classify, then ask again based on the result — you spend one.

---

Pricing and speed: output tokens are free

As of September 2026 there is one published model, Jev 1.13.

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

The marketing headline is "238x lower input price than Claude Fable 5.1" and "193.6x faster, 444.6x cheaper" on System One workflows.

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.

The order-of-magnitude gap is still hard to ignore. Classifying 100,000 tickets a day at 400 tokens each is 40 million input tokens: $1.68 per day on Jev, with output free. The same job on a model at $2.00 input / $12.00 output runs closer to $140 a day even at 50 output tokens per ticket.

---

Getting started: from the waitlist to your first request

1. Join the early access waitlist

   Sign up at typesafe.ai. As of September 2026 TypeSafe says it is "bringing developers off the waitlist as quickly as we can," and hands-on reports describe an invitation arriving shortly after signing up.

2. Create an API key

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

3. Feel it out in the Playground

   The console Playground takes a state as plain text on the left and questions as JSON on the right, and shows measured latency. Working out your wording here, before you install anything, is the faster path.

4. Call it from the Python SDK

   pip install typesafe-sdk
   

   from typesafe_sdk import Choice, Noul, Score, TypeSafeClient
   
   client = TypeSafeClient()
   
   ticket = "Hi, I've been trying to connect my Stripe account for 3 days and it keeps failing. I'm losing sales. Please help ASAP."
   
   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, just stating facts",
                   "Frustrated but civil",
                   "Very angry, strong language",
               ],
           ),
           "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
   

   For JavaScript/TypeScript: npm install @typesafe-ai/sdk (Node.js 20+). Calling client.systemOne() infers the return types from your question definitions.

5. Or hit the HTTP API directly

   POST https://api.typesafe.ai/v1/systemone, authenticating with Authorization: Bearer <API_KEY>.

   {
     "state": "Help! My payouts have been failing for 3 days.",
     "model": "jev-latest",
     "questions": {
       "is_urgent": {
         "type": "noul",
         "instructions": "Does this convey urgency?"
       },
       "department": {
         "type": "choice",
         "instructions": "Which team should handle this?",
         "criteria": {
           "billing": "Payments, invoicing, refunds",
           "technical": "Bugs, outages, integrations",
           "sales": "Pricing, upgrades, new accounts"
         }
       }
     }
   }
   

   The response carries usage with both token counts, but only input tokens are billed.

   {
     "model": "jev-latest",
     "answers": {
       "is_urgent": { "type": "noul", "noul": 0.92 },
       "department": {
         "type": "choice",
         "choice": "technical",
         "probabilities": { "billing": 0.08, "technical": 0.85, "sales": 0.07 },
         "confidence": 0.82
       }
     },
     "usage": { "input_tokens": 312, "output_tokens": 48 }
   }
   

6. Use it from a coding agent

   TypeSafe publishes an agent skill. For Claude Code it is two lines:

   claude plugin marketplace add typesafe-ai/skills
   claude plugin install typesafe@typesafe-ai
   

   For other agents, npx skills add typesafe-ai/skills --skill typesafe-ai. The skill loads the three question types and the architectural patterns, so the agent can find brittle parsing code in your repo and rewrite it. TypeSafe itself notes that "agents aren't great at writing questions, so expect to edit collaboratively with them." Question design stays a human job.

---

Confidence: catching "I'm not sure" and routing it to a person

Ask an LLM to report its own certainty and you get prose. Jev returns a confidence value between 0 and 1 computed from the probability distribution: peaked means high, spread means low. That makes "send only the uncertain ones to a human" straightforward to write.

The published starting points:

The real point is to scale the threshold with the consequence. There is no reason for "show balance" and "approve transfer" to share one.

if confidence < 0.5:
    route_to_human(user_message)
elif action.choice == "check_balance":
    show_balance(account_id)                 # low stakes: just do it
elif action.choice == "approve_transfer":
    if confidence > 0.9:
        confirm_then_execute(account_id)
    else:
        ask_user_to_confirm(account_id)      # high stakes: verify first

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.

The docs add that these are a starting point only: "start with conservative thresholds, test with your own data, and adjust." One Qiita write-up also found that the confidence formula implied by the official examples is inconsistent — some match a rescaled-maximum formula, one matches an entropy-based one. Where a threshold really matters, compute it yourself from the returned probabilities.

---

Where it actually pays off

Drawing from the official cookbooks and the published deployments.

Real-time decisions: what the Doom demo shows

The official Doom demo passes a text representation of the game state — not images — and calls Jev about ten times a second to choose the next action, at roughly $7 an hour. Read it not as a gaming result but as a demonstration that an AI decision can sit inside a sub-150 ms loop. Embedded UI branching and in-game chat moderation belong in the same bucket.

What developers are trying

Qiita's campaign had 14 articles posted as of September. They fall into three groups.

• Batch judgements in Japanese — one author used an article outline as the state and asked 12 questions at once (8 Scores, 4 Choices): technical depth, practicality, beginner accessibility and so on. The publishing-platform choice came back Qiita 92% / Zenn 8% at 84% confidence; technical depth scored 1.97/2.00 at 96% confidence. The Playground reported 96 ms + 212 ms
• Can it replace LLM-based branching? — a study done without early access, working only from the SDK and public docs, that reverse-engineered the confidence formula and found an inconsistency: SDK 0.6.0's type validation rejects the official Quick Start example
• Comparison as an agent architecture — placing a setup where an LLM picks the next step (Amazon Bedrock AgentCore) beside one where Jev returns a classification and the program branches, framed as "who owns the decision about how the process proceeds — the program or the AI"

Abroad, Browserbase is using it for browser-agent decisions, and other developers for a live trading agent and for email triage at scale. None of these have published numbers.

---

Using it on non-English input

This is the part that matters most outside English-speaking markets. The state documentation says, in substance:

In practice, Japanese hands-on reports show urgency judgements coming back at 0.97–0.98 — it works. But "it works" and "it is accurate enough to ship" are different claims. A realistic path:

1. Write instructions and criteria in English — leave the state in its original language and give the model its directions in the language it is strongest in
2. Measure once against labelled data — 100–300 past tickets with human labels, compared against Jev's output. That is where your threshold actually comes from
3. Start with a high threshold and keep people in the loop — automate only above 0.9 at first, and raise coverage as you learn

---

Where it struggles: TypeSafe publishes its own weak spots

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

On top of that, mathematical relationships between related questions are not guaranteed. Ask "is A" and "is not A" as two separate Nouls and the probabilities will not necessarily sum to 1. If you need that consistency, collapse them into one Choice.

And one more: the docs state that Jev is vulnerable to adversarial content inside the state. If you feed user input straight in, prompt injection remains your problem to solve.

---

What to move to Jev, and what to leave alone

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

Jev | Typed judgements only, in 70–500 ms

A model narrowed to classification, scoring and truth values. It writes nothing. Use it where the options can be enumerated in advance and the same judgement repeats at volume. Its job ends at returning the value and its probability — what happens next is your application code's decision.

See the Jev details

Claude | Writing and long reasoning stay with the LLM

Summarising, drafting, code generation and multi-step reasoning are Claude's territory. Jev handles the guardrails around it and the verification after it — whether a citation really appears in the source. These are complements, not competitors: Jev sits thinly on either side of the LLM.

See the Claude details

ChatGPT | For classification alone, a small model is also an option

If all you need is classification or extraction, ChatGPT's API has cheap models too — GPT-5.6 Luna runs $0.20 per million input tokens. The gap to Jev is roughly 5x on price, plus output billing and the parsing step. If you are already on OpenAI, check whether the cheap model suffices before you compare.

See the ChatGPT details

Dify | Move workflow branching conditions off the LLM

In workflow tools like Dify, conditional branches are often decided by an LLM node. That is exactly a decision whose options are known in advance, so moving it to Jev takes that step from seconds to milliseconds — which shows up in the latency of the whole flow.

See the Dify details

Claude Code | Find the judgement sites in your repo and rewrite them

With the official skill installed, Claude Code can hunt through a repository for brittle parsing and regexes straining to express a judgement, and convert them into Jev calls. Keep the questions and confidence thresholds in one file so they stay reviewable.

See the Claude Code details

---

Frequently asked questions

---

In summary

What Jev introduces is not new capability but a new division of labour. Take the part of the job where the options are known in advance, hand it to a specialised model that is orders of magnitude faster and cheaper, and leave generation and reasoning with the LLM.

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