dev-tools 8 min read

Jev: TypeSafe's System One model for structured decisions

TypeSafe's Jev returns typed answers with probabilities instead of text, priced at $42 per million input tokens with free output. How the API works.

#ai #typesafe#jev#structured-output#decision-models
By
Share: X in
Abstract split rendering of a chat bubble and a typed data block on a dark slate gradient

TL;DR: Jev is TypeSafe’s first System One model, and it does not write text. You send it state plus typed questions, and it returns structured values with probability distributions and a confidence score. The API costs $42 per million input tokens with output billed at zero, and answers arrive in 70 to 500 milliseconds instead of the 3 to 329 seconds a frontier LLM needs for comparable judgment.

What Jev actually is

TypeSafe AI was founded by Diogo Almeida, who says he worked at OpenAI on the methods behind ChatGPT. After two years in stealth the company released Jev in September 2026, and the model does something a chatbot cannot: it returns data instead of prose.

A language model takes text in and gives text back, so your code has to parse that text, validate it against a schema, and decide what to do when the parse fails. Jev skips the string. You describe the state you want judged and ask a question with a fixed set of options, ordered levels, or a yes/no condition. What comes back is a typed value, a probability distribution across those options, and a confidence number.

The name comes from Kahneman’s System 1 and System 2. TypeSafe’s argument is that most of what people use LLMs for inside software is fast judgment rather than reasoning: route this ticket, score this candidate, is this urgent, which of these five options fits. Those are exactly the tasks where sampling every answer in one shot beats generating a token at a time.

The four primitives

Question typeWhat it asksWhat comes back
ChoicePick one option from a set you definedthe option, probabilities per option, confidence
ScoreRate the state against ordered levelsthe score, probabilities per level, confidence
NoulIs this statement trueone number from 0 to 1
BoxLocate an object in an imagebox edges as fractions of width and height

Any mix of them goes into a single request and every question is evaluated in parallel against the same state. Adding questions barely moves response time, and because each one is evaluated in isolation, adding more does not degrade the others the way a longer chat transcript does.

Here is one request that asks all three text-based primitives at once:

curl https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": "Our API integration started returning 500 errors on every request about 20 minutes ago, and we cannot process any customer orders until this is fixed.",
    "questions": {
      "department": {
        "type": "choice",
        "instructions": "Which team should handle this ticket?",
        "criteria": {
          "technical": "API, infrastructure or bug reports",
          "billing": "Payments, invoices or subscriptions",
          "sales": "Plans, contracts or upgrades"
        }
      },
      "frustration": {
        "type": "score",
        "instructions": "How frustrated does the customer sound?",
        "criteria": [
          "Calm, just stating facts",
          "Frustrated but civil",
          "Very angry, strong language"
        ]
      },
      "is_urgent": {
        "type": "noul",
        "instructions": "Is this message about a production outage?"
      }
    }
  }'

The response mirrors the question keys, so you can match each result back to what you asked without any extra bookkeeping:

{
  "model": "jev-1.13.0",
  "answers": {
    "department": {
      "type": "choice",
      "choice": "technical",
      "confidence": 1.0,
      "probabilities": { "technical": 1.0, "billing": 0.0, "sales": 0.0 }
    },
    "frustration": {
      "type": "score",
      "score": 0.67,
      "confidence": 0.5,
      "probabilities": { "0": 0.33, "1": 0.67, "2": 0.0 }
    },
    "is_urgent": { "type": "noul", "noul": 0.99 }
  },
  "usage": { "input_tokens": 428, "output_tokens": 73 }
}

Note that output_tokens is 73 even though the answer is a handful of structured values. That is the parallel sampler at work, and it is why output is free.

Getting a client in place

The API is plain JSON over HTTP, but the SDKs handle retries and rate-limit backoff for you. Pick whichever matches your stack:

  • Python, 3.10 or later: pip install typesafe-sdk
  • JavaScript and TypeScript: npm install @typesafe-ai/sdk
  • Claude Code: claude plugin marketplace add typesafe-ai/skills then claude plugin install typesafe@typesafe-ai
  • Any other agent environment: npx skills add typesafe-ai/skills --skill typesafe-ai

The Python client reads TYPESAFE_API_KEY from the environment and takes the same question objects:

from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

ticket = "Our API integration started returning 500 errors on every request about 20 minutes ago."

with TypeSafeClient(model="jev-latest") as client:
    response = client.system_one(
        state=ticket,
        questions={
            "department": Choice(
                instructions="Which team should handle this ticket?",
                criteria={"technical": "API or bugs", "billing": "Payments"},
            ),
            "frustration": Score(
                instructions="How frustrated does the customer sound?",
                criteria=["Calm", "Frustrated but civil", "Very angry"],
            ),
            "is_urgent": Noul(
                instructions="Is this message about a production outage?"
            ),
        },
    )

The interesting field is confidence, and it is not the same thing as probabilities. Probability is the distribution across your options, so a flat distribution and a peaked one can both be useful. Confidence is a single number derived from the shape of that distribution: 1 when all the mass sits on one option, 0 when it is spread evenly. That is the value to threshold on if your code needs to decide whether to act on an answer at all.

Why the price and the speed look like that

TypeSafe frames the comparison directly against frontier models on the same page as the launch:

Frontier LLMJev
Outputgenerated texttyped value plus probabilities
Samplingone token at a timeevery answer in one query
End-to-end latency3 to 329 seconds70 to 500 milliseconds
Input price$0.20 to $10 per million tokens$0.042 per million tokens
Output priceroughly 5x the input pricefree

The speed claim is 40 to 200 times faster for System One shaped queries. The important caveat is that Jev is not a drop-in replacement for a reasoning model. It does not write code, does not handle audio or video, and the docs are explicit that it is not fine-tuned per account, so the same weights serve every customer and you shape behavior through the request.

Context is 64k per request and 32k per question by default. A TypeSafe-Danger-Zone-Long-Context: true header raises both limits to 262k tokens, at the same price, but the docs warn it is slower and less accurate than staying inside the default window.

Where it breaks

TypeSafe publishes a page called Model jaggedness, and it is worth reading before you ship anything on this. The pattern they describe is that Jev answers the question you wrote, not the one you meant.

  • It reads scoping words and negations at face value, so the exact condition needs to be in the instructions and the boundary cases need to be in the criteria.
  • It is not a calculator and does not count reliably. Keep arithmetic in code and let the model handle the judgment.
  • It cannot reliably compare numeric representations. Convert in code and pass either a computed number or a named bucket.
  • The order of your Choice options can affect the answer. Reorder them and check the result holds.
  • It struggles with extra levels of indirection and with large states full of irrelevant detail. Filter first, then send only what the question needs.

The last one matters most for cost. Sending a 64k document to answer one narrow question works, but the docs note that accuracy shifts as the state grows, and the parallel questions cookbook reports that batching 13 questions into one call is 12.2 times cheaper and 10 times faster than sending them separately with no change in answers.

Who is actually using it

Jack & Jill, a talent marketplace brokered by AI agents, replaced Gemini 3.1 Flash Lite with Jev for 100 percent of calls in one stage of its candidate matching pipeline. They tested both models on 150 live roles with the same candidates.

MetricGemini 3.1 Flash LiteJev
Cost per 1,000 candidates scored$0.755$0.092
Median time to screen each candidate20.3 sec10.3 sec
Winners kept on the shortlist93.9%94.6%

The company projects $500K in annual savings. It is a customer case study published on the vendor’s own site, so treat the figures as claims rather than independent benchmarks.

The more telling signal is that Cloudflare shipped its own take on the idea. In October it previewed Clairic on Workers AI as @cf/cloudflare/clairic, calling it a new class of System One style extraction models, and credited TypeSafe’s Jev as the inspiration. Cloudflare says it intends to release the weights in open source.

Source and Accuracy Notes