TypeSafe AI’s Jev Answers in Probabilities, Not Sentences: Where a Decision-Only AI Model Fits

Written by

in

12 min read

Ask ChatGPT whether a support ticket is about billing or a technical problem and you usually get a friendly paragraph back. That’s a good answer for a person. For a program that has to act on the decision, it’s a chore: it has to dig the word “technical” out of the prose, and every so often the format drifts and something breaks.

Jev, an AI model released on September 15, is aimed squarely at that gap. It doesn’t write sentences at all. It tells you which of a set of predefined options fits, and how sure it is, as numbers and nothing else.[1][2]

What was announced

Jev comes from TypeSafe AI, a US startup founded by Diogo Almeida. At OpenAI, Almeida was an equal-contribution lead author on the InstructGPT paper, the research that became the foundation for ChatGPT.[5] The company spent two years in stealth before this launch[1] and has reportedly raised $40m.[2]

TypeSafe calls Jev the first of a new class it names “System One models,” after Daniel Kahneman’s Thinking, Fast and Slow. Kahneman split human thinking into fast, intuitive System 1 and slow, deliberate System 2. Today’s chatbots, with their long chains of reasoning, lean toward System 2. Jev is built for the snap judgment.[1]

The name itself is a nod to William Stanley Jevons, the 19th-century economist who noticed that more efficient steam engines made Britain burn more coal, not less. TypeSafe’s bet is the same: make AI decisions dramatically cheaper and people will find far more places to use them.[1]

How it works

A chatbot is a large language model (LLM). It produces an answer one word at a time, like a student writing an essay response.

Jev is closer to a multiple-choice answer sheet. You hand it two things:

  • State: the material to judge. A one-line customer message, or a bundle of data like an order history.
  • Questions: what to decide. Each question declares the shape of its answer in advance.

There are three question types.[3]

Type What it asks What comes back
Choice Which of these? (up to 255 options) The pick, a probability for each option, a confidence value
Score Which level? (e.g. frustration on a 1–5 scale) A score, probabilities per level, a confidence value
Noul Is this true? The probability that it is (0 to 1)

The example in the official docs: feed in “Help! My payouts have been failing for 3 days.” and ask, as a true/false question, whether it conveys urgency. Jev returns a single number, 0.92.[3] Software can plug that straight into a rule like “page someone above 0.8.” There’s no parsing step, no pulling an answer out of text.

Ask several questions at once and Jev evaluates them in parallel. Because it returns every answer in one pass instead of writing token by token, the company says, it’s fast.[1][3]

The numbers (all from TypeSafe)

Every figure below was measured and published by TypeSafe itself. Nobody outside the company has verified them yet.

  • Speed: 70 to 500 milliseconds per response. In the company’s demo, Jev answered in 0.114 seconds; OpenAI’s GPT-5.6 Terra took 8.566 seconds on the same query.[2]
  • Price: $0.042 per million input tokens, and output is free.[3] (A token is a small chunk of text, roughly three-quarters of an English word.) For comparison, GPT-5.6 Terra costs $2 per million input tokens and $12 per million output tokens.[2]
  • Accuracy: across four workflows TypeSafe built (security incident response, agent-trace review, invoice processing, customer service), Jev matched the reference answers 67.8% of the time. That’s level with GPT-5.6 Terra (67.9%) and about 6 points behind the strongest models tested (74.1% and 73.1%).[4]
  • Cost and time per case: Jev $0.0004 and 0.4 seconds; Terra $0.0304 and 10.1 seconds. About 76 times cheaper and 25 times faster.[4]

The picture TypeSafe is painting: not quite as accurate as the best models, but as accurate as a solid mid-tier one at a small fraction of the cost and time. The gap varies a lot by task. On invoice processing, Jev scored 61.8% against the top model’s 79.1%, a difference of more than 17 points.[4]

Where it fits, and where it doesn’t

Jev is built for work where the possible answers are known up front and the same judgment has to be made over and over.

  • Routing support tickets: billing, technical or sales; how urgent; whether a refund is being requested, all in one call.
  • Labeling data at scale: sorting millions of reviews or documents by topic or sentiment, which only makes sense when each decision costs almost nothing.
  • Supervising AI agents: an agent is an AI that works through multi-step tasks on its own. Jev can make the quick calls around it, like which tool to use next, whether the agent is stuck in a loop, or whether the job is done.[5]
  • Screening and guardrails: flagging risky prompts headed into another AI, or answers that break the rules.[1]
  • Real-time decisions: TypeSafe even had Jev play Doom, reading a text description of the game state and choosing a move ten times a second. The company concedes that “a non-AI doom bot could play better.”[1]

What it can’t do is write. Chat, coding assistants, summaries and reports stay with conventional models; TypeSafe’s own comparison hands conversational tasks and things like math proofs to LLMs.[1] It also can’t explain itself. You get probabilities, not reasons, so there’s no way to see why it decided what it did.[5]

Hands-on: how you’d actually use it

If you’re a developer, here’s what working with Jev looks like. Every request and response below comes from TypeSafe’s official documentation (September 2026, model version jev-1.13).[3] The part that handles the responses (see “Turning answers into actions”) I did run, feeding in the documented responses, and the output is shown exactly as it came out.

Setup

Once you’re let in from the waitlist, you get an API key from the console. The official Python SDK needs Python 3.10 or newer.[3]

pip install typesafe-sdk
export TYPESAFE_API_KEY="your_key"

The simplest call

One endpoint takes the material to judge (state) and your questions (questions). This is the official example that asks a single true/false question: is this message urgent?[3]

curl -X POST https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d @- <<'EOF'
  {
    "state": "Hi, I've been trying to connect my Stripe account for 3 days and it keeps failing. I'm losing sales. Please help ASAP.",
    "model": "jev-latest",
    "questions": {
      "urgency": {
        "type": "noul",
        "instructions": "Does this message express urgency?"
      }
    }
  }
EOF

Three questions in one request

In practice you bundle questions together. The official quickstart asks, about the same support message, which team should take it (Choice), how frustrated the customer is (Score) and whether it’s urgent (Noul), all at once.[3] The descriptions attached to each option in criteria matter most: they’re what the model actually reads when deciding.

from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

client = TypeSafeClient()  # reads the TYPESAFE_API_KEY environment variable

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

Reading the response

Here’s the full response as documented.[3]

{
  "model": "jev-latest",
  "answers": {
    "department": {
      "type": "choice",
      "choice": "billing",
      "probabilities": { "billing": 0.84, "technical": 0.159, "sales": 0.001 },
      "confidence": 0.596
    },
    "frustration": {
      "type": "score",
      "score": 1.035,
      "legend": {
        "0": "Calm, just stating facts",
        "1": "Frustrated but civil",
        "2": "Very angry, strong language"
      },
      "confidence": 0.842
    },
    "is_urgent": { "type": "noul", "noul": 0.999 }
  },
  "usage": { "input_tokens": 312, "output_tokens": 48 }
}
  • Choice (department): 84% billing, 15.9% technical, with a confidence of 0.596. Confidence moves toward 1 when the probabilities pile onto one option and toward 0 when they’re spread evenly. The exact formula isn’t published.[3]
  • Score (frustration): 1.035 is the probability-weighted average of the level numbers (0, 1, 2). Using another example from the docs: with 0% on level 0, 70% on level 1 and 30% on level 2, you get 0 × 0.0 + 1 × 0.70 + 2 × 0.30 = 1.3.[3] That’s why a score can land between levels. This customer sits around level 1, “frustrated but civil.”
  • Noul (is_urgent): 0.999, so almost certainly urgent. Noul answers don’t come with a separate confidence value.[3]

Turning answers into actions

The whole point of Jev is to feed these numbers straight into rules without a person in the loop. The docs suggest splitting confidence into three bands: act automatically when it’s high, confirm when it’s middling, and hand off to a person when it’s low.[3] Here’s a short routing function that follows that advice. Ticket A uses the quickstart response above; ticket B uses the values from the docs’ Choice example (60% returns, 38% billing, confidence 0.39).

def route(resp):
    a = resp["answers"]
    dept = a["department"]

    # 1) If we're unsure which team, a person decides
    if dept["confidence"] < 0.5:
        return f"manual triage (confidence {dept['confidence']})"

    # 2) If the runner-up team is above 25%, loop them in too
    also = [k for k, p in dept["probabilities"].items()
            if k != dept["choice"] and p > 0.25]

    # 3) Urgency (yes-probability) and frustration (0-2 score, scaled to 0-1)
    urgent = a.get("is_urgent", {}).get("noul", 0) >= 0.8
    frustration = a.get("frustration")
    angry = frustration and frustration["score"] / (len(frustration["legend"]) - 1) >= 0.5

    plan = f"assign to {dept['choice']}"
    if also:
        plan += f" (+ cc {', '.join(also)})"
    if urgent:
        plan += ", flag urgent"
    if angry:
        plan += ", raise priority"
    return plan

Output (Python 3.9.6, September 19, 2026):

Ticket A → assign to billing, flag urgent, raise priority
Ticket B → manual triage (confidence 0.39)

Ticket A was 84% billing with confidence above the 0.5 cutoff, so it was assigned automatically. Its frustration score of 1.035, divided by the top level (2), comes to 0.52, which bumped the priority. Ticket B was split between returns and billing, confidence stalled at 0.39, and it went to a person. The cutoffs here (0.5, 0.25, 0.8) are only examples; the docs say to set them according to how risky the action is and to test them on your own data.[3]

Writing good questions

A few tips that come up in both the official docs and outside analysis:[3][5]

  • Include an “other” option. Jev always spreads its probability across the options you give it. If the right answer isn’t there, some wrong option wins. A “none of the above” choice catches those cases.
  • Don’t pre-trim the list. The docs recommend giving the full set of options rather than a shortlist. One question can hold up to 255.
  • Describe score levels as situations, not numbers. The model never sees the level numbers, only the descriptions. Write “feature is broken with no workaround,” not “3 points.”
  • A Noul of 0.5 isn’t “medium.” It means yes and no are equally likely, not “somewhat urgent.”

Comparing it with the models you already use

TypeSafe has also open-sourced a tool, system-one-adapter, that runs the same question format against OpenAI or Anthropic models.[6] You can take questions written for Jev and put them to an existing model to compare cost, speed and answers. It’s a sensible check before adopting Jev: is it really cheaper, faster and about as accurate on your own workload? The tool needs those providers’ API keys, so I didn’t run it for this piece.

from system_one_adapter import SystemOneAdapterClient, Noul

client = SystemOneAdapterClient(
    structured_outputs=True,          # use the provider's structured-output mode
    llm_answer_mode="probabilities",  # ask for probabilities
    normalize_probabilities=True,
)

response = client.system_one(
    state="This book was a delight to read.",
    questions={"positive": Noul(instructions="The book review is positive.")},
    provider="openai",
    model="gpt-4o-mini",
)

Read “no hallucinations” carefully

TypeSafe markets Jev as a model that can’t hallucinate, meaning it can’t confidently make things up the way chatbots sometimes do.

What that guarantee actually covers is the format of the answer. Jev can’t return anything outside the options you defined, so it will never invent a court case or a fake citation. It can still pick the wrong option. The company itself says its 0% hallucination figure “is not empirical”: it’s shown as zero because the schema always matches.[1] As the 67.8% accuracy figure shows, roughly one answer in three disagrees with the reference. Software engineer Anthony Maio put it neatly: “Jev constrains the shape of the output. It does not constrain the judgment.”[5]

The evaluation deserves some scrutiny too. The “correct” answers weren’t set by people; they’re an average of two top-tier models’ responses, and the workflows were designed by TypeSafe staff, which the company acknowledges could introduce bias.[1][4] There’s also no published data yet showing whether Jev’s confidence scores line up with how often it’s actually right, a property called calibration.[5]

What this means for you

Jev is currently a developer API in early access, with a waitlist.[1] Still, the idea behind it is useful for anyone thinking about AI at work.

  • Split the work you’d hand to AI into two piles. Tasks that need writing, and tasks that only need a pick from known options. The second pile is about to get much cheaper and faster. Ticket triage and first-pass document screening belong there.
  • Plan for handing low-confidence calls to a person. A model that tells you how sure it is lets you automate the clear cases and route the murky ones to a human.
  • Separate “never wrong” from “never malformed.” Expect to see the two blurred together in AI marketing for a while.

Takeaway

Until now, AI has mostly improved in one direction: bigger models, thinking longer. Jev goes the other way. It gives up language entirely in exchange for speed and cost, and it’s designed to talk to software rather than people. In Almeida’s words, “people can’t be the only consumers of intelligence.”[2]

With accuracy below the best models and every number coming from the company, this is still a demonstration of potential. But a large share of what AI does in practice is deciding, not writing. If the price of a decision drops by an order of magnitude or more, AI will show up in places that are too expensive for it today. Whether Jevons’s coal story repeats itself with AI is worth watching.

References


Notes

  1. TypeSafe AI, “Introducing System One Models & Jev” (2026-09-15). Naming after Kahneman and Jevons, parallel outputs, how the 0% hallucination figure was derived (“Our number is not empirical”), recommended uses and limits, the Doom demo (“A non-AI doom bot could play better”), early access. Link ↩
  2. Thomas Claburn, “TypeSafe AI debuts model for machines that plays Doom,” The Register (2026-09-16). 0.114s vs 8.566s demo, GPT-5.6 Terra pricing, $40m funding, Almeida quote. Link ↩
  3. TypeSafe AI developer documentation (quickstart, API reference, Choice/Score/Noul and confidence pages). Question types and the 255-option limit, curl and Python SDK examples with responses, the score formula (“0 x 0.0 + 1 x 0.70 + 2 x 0.30 = 1.30”), three-band confidence guidance, “other / none of the above” advice, request example (“Help! My payouts have been failing for 3 days.” → noul 0.92), pricing ($0.042 per million input tokens, output free). Link ↩
  4. TypeSafe AI evaluation results. Four-workflow average accuracy (Jev 67.8%, terra 67.9%, sol 74.1%, opus 5 73.1%), cost and time per case, invoice processing (Jev 61.8%, sol 79.1%); reference labels are the average of GPT-6 Astra and Claude Fable 5.1. Link ↩
  5. Anthony Maio, “Jev: The Language Model That Won’t Talk” (2026-09-16). Founder background (equal-contribution lead author on InstructGPT), agent-supervision uses, limitations, no published calibration data, the need for “unknown” / “none of the above” options. Link ↩
  6. TypeSafe AI, system-one-adapter-python (GitHub, MIT license). Runs the same question format against OpenAI and Anthropic models for comparison. Link ↩

Source: https://typesafe.ai/blog/introducing-system-one-models-and-jev