Jev: the AI model that writes nothing and decides instead

Who it's for

Anyone whose software calls a language model at points where the only thing that comes out is a decision — sorting, routing, rating, approving.

What you'll be able to do

Understand what separates a decision model from a language model, where it pays off, and what a first call looks like.

As of

September 2026

What Jev is

Jev is the first model in a category its maker, TypeSafe AI, calls a "System One Model". The documentation describes these as "a class of AI models built to make fast, structured decisions that software can use directly" (docs.typesafe.ai, retrieved 20 September 2026). It was introduced on 15 September 2026.

What sets it apart from everything you know as AI is spelled out in the first line on the vendor's home page: "LLMs produce words for people. Jev produces typed decisions and is more like code: reliable, fast, self-consistent, and type-safe" (typesafe.ai, retrieved 20 September 2026).

That isn't a marketing flourish — it's a hard constraint. Jev cannot do anything else. The documentation states that these models "do not write replies, produce code, or generate explanations of their reasoning". You get a number, not a reason.

The three questions Jev can answer

There are exactly three kinds of question, and that is the whole model:

Choice: you supply the options and Jev picks one — along with how the probability is spread across all of them. "Is this ticket about billing, technical support, or something else?"

Score: you supply a scale with labelled steps and Jev places the case on it. "How urgent is this — can wait, this week, today?"

Noul: a yes/no question answered with a number between 0 and 1. Not "yes", but "0.95 yes". That distinction is what matters later on.

The trick is that you can ask all three in a single call. As the documentation puts it: "Adding questions barely changes the response time and costs only the tokens for the extra questions, which are cheap. Asking a question you might not need is close to free." (docs.typesafe.ai, retrieved 20 September 2026).

One caveat: the questions know nothing about each other. "Questions in the same request are independent: one answer does not become context for another question." So you cannot ask "and if so, then…" — every question stands alone.

One ticket, three questions, one call

The example in the documentation is a customer support ticket, and it explains the idea better than any explanation could. The state is a single customer message, with three questions of different kinds hanging off it:

from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

with TypeSafeClient() as client:
    response = client.system_one(
        state={"document": "I was charged twice. Please fix this ASAP."},
        questions={
            "billing": Noul(instructions="Is this ticket about billing?"),
            "tone": Choice(
                instructions="What is the customer's tone?",
                criteria={"calm": None, "frustrated": None, "angry": None},
            ),
            "urgency": Score(
                instructions="How urgent is this ticket?",
                criteria=["can wait", "this week", "today"],
            ),
        },
    )

What comes back is not a sentence but one entry per question. Here is what such an entry looks like for a choice question — the example comes from the API reference and belongs to a different call, but the shape is exactly what you would get here:

{
  "model": "jev-1.13.0",
  "answers": {
    "department": {
      "type": "choice",
      "choice": "billing",
      "probabilities": { "billing": 0.88, "technical": 0.12, "sales": 0.0 },
      "confidence": 0.81
    }
  },
  "usage": { "input_tokens": 318, "output_tokens": 34 }
}

That deserves a second look (docs.typesafe.ai, retrieved 20 September 2026). choice is the decision, probabilities shows how close a call it was, and confidence says how sure the model is. Those two extras are the reason to put a model like this in front of a program: you can draw a threshold. Anything above 0.8 goes through, anything below lands with a person. You cannot do that with a language model that simply replies "billing" — it sounds every bit as certain on a lucky guess as on a safe bet.

When it pays off — and when you still need a language model

A fair summary comes from LangChain, who built Jev into their own toolchain: "Jev isn't a drop-in replacement for an LLM. It doesn't generate text." It doesn't replace a language model — it takes over the points before and after it (langchain.com, 17 September 2026, retrieved 20 September 2026).

What people are using it for

Five days after release this is already reasonably clear, because the major providers' integrations are public.

Picking the next step in a workflow. Vercel lists this as the first official use: "Choosing the next tool or subagent in an agent loop" (vercel.com, 16 September 2026, retrieved 20 September 2026). LangChain turned it into a middle layer that asks Jev which model should handle an incoming request.

Checking before something happens. LangChain's component shows Jev a tool call that is about to run and stops it before it executes. This is the case I find most convincing: a check that costs tenths of a second, but stops an automation from doing something stupid.

Sorting and pre-sorting. Tickets, documents, bank transactions — with the threshold described above, below which a person takes over. The vendor documents this pattern in a section of its own.

Searching without a vector database. This is the most elegant case technically. The weakness of a choice question is that its probabilities always add up to 1, so a line wins even when none of them fit. The documentation solves it by running a yes/no question alongside, whose probability "doesn't depend on the other options, so it can fall near zero when the document has no answer" (docs.typesafe.ai, retrieved 20 September 2026). That gives you "it isn't in here" — something similarity search is notoriously bad at.

What it cannot do

This is where it gets interesting, for an unusual reason: the most honest source on Jev's weaknesses is TypeSafe itself. The vendor maintains a page listing where the model gets things wrong. In its own words: "jev-1.13 is fast, calibrated, and good at common-sense judgment but it is not perfect" (docs.typesafe.ai, retrieved 20 September 2026). What that page lists:

• Arithmetic: "Jev is not a calculator."
• Counting: "jev-1.13 does not count reliably."
• Dates: which of two dates comes first, how far apart they are, or whether one falls inside a window — unreliable, according to the vendor.
• Literalness: "jev-1.13 answers the question you wrote, not the one you meant."
• Large states: the more material in the text that has nothing to do with the decision, the less accurate the answer.
• Attacks: "State is data, and jev-1.13 does not treat it as hostile by default." The state you pass in is, to the model, simply content — text written to steer it deliberately can move the answer.

That last point deserves a warning of its own, because it cuts against what Jev is currently being credited with.

There is at least one independent measurement. Mike Taylor ran twelve passages of text through four checking questions each and got a median of 0.35 seconds per passage against 8.83 seconds for Claude Fable 5.1 at high effort — finding six of seven planted errors against seven of seven. His own conclusion: he wanted "a more thorough accuracy check before putting it into production" (every.to, 15 September 2026, retrieved 20 September 2026).

A caveat for German text

Most reports skip past this, but it is the most important line here. The model page says: "English is the primary training language and where accuracy is currently best. Other languages, including CJK scripts, are handled but not equally well; test on your own content before relying on Jev for a non-English workload, and pay close attention to Confidence when routing" (docs.typesafe.ai, retrieved 20 September 2026).

So if you want to sort German tickets, emails or forms, you cannot simply assume it works. Take fifty cases where you know the right answer, run them through, and compare. That is an hour's work and it beats any extrapolation from a blog post — including this one.

Trying it yourself

You need a TypeSafe account and a key from the console; the documentation points to console.typesafe.ai. The key goes in the environment variable TYPESAFE_API_KEY. On access itself, the announcement post says developers are brought "off the waitlist as quickly as we can" — so there is a waiting list, and how long you sit on it isn't documented.

The Python SDK needs at least version 3.10:

pip install typesafe-sdk

For JavaScript and TypeScript, from Node.js 20:

npm install @typesafe-ai/sdk

If you only want a feel for it, you don't need an SDK at all. The quickstart shows the bare call:

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 the integration keeps failing. I'm losing sales. Please help ASAP.",
    "model": "jev-latest",
    "questions": {
      "urgency": {
        "type": "noul",
        "instructions": "Does this message express urgency?"
      }
    }
  }
EOF

And in JavaScript the smallest useful call looks like this:

import { choice, TypeSafeClient } from "@typesafe-ai/sdk";

const client = new TypeSafeClient();
const response = await client.systemOne({
  state: { document: "I was charged twice. Please fix this ASAP." },
  questions: {
    category: choice("What is this ticket about?", {
      billing: null,
      technical: null,
      other: null,
    }),
  },
});

console.log(response.answers.category.choice);

If you already route through a gateway, Jev is available there too — on Vercel as typesafe-ai/jev (vercel.com), on Cloudflare as typesafe/jev (developers.cloudflare.com), on OpenRouter as typesafe/jev-1.13 (openrouter.ai), all retrieved 20 September 2026. Watch out, though: Vercel uses its own spelling, where the yes/no question is called boolean rather than noul. The vendor's examples won't run there unchanged. I found nothing about these routes in TypeSafe's own documentation — if you use one, follow that provider's guide.

What it costs

The price is the real headline. The model page quotes 42 US dollars per billion input tokens, which works out at 0.042 dollars per million — and adds a curt sentence: "Output tokens are free." The announcement post puts it more colourfully, "FREE (too cheap to meter)". That makes sense once you understand there is no output in the usual sense: no text is produced, only a number.

The rest of the figures from the model page, all retrieved 20 September 2026: 64,000 tokens per request, with state plus the longest single question capped at 32,000 between them. 250,000 tokens per second and 1,200 requests per minute — with an explicit note that, for now, these throughput limits can change without notice. Text only — "No image, audio, or video input". Customer data is not used for training (docs.typesafe.ai). The response time of 70 to 500 milliseconds isn't on that page but in the announcement post (typesafe.ai/blog, 15 September 2026, retrieved 20 September 2026).

Where I land on it

I think the category is right and the model is too young to build anything important on. The category is right because in every second automation I build, a large language model gets called for a job whose entire output is one word — and you pay for that in waiting time, in money, and in a result you then have to take apart again. A number with a confidence value is simply the better format for a program.

It is too young because, as this post goes out, it is five days old, in early access, available in exactly one version, with no published availability guarantee and no notice period for version changes. Even the throughput limits come with a caveat: they "can change without notice", says the model page. Nobody knows today which parts of this will still be standing in a year.

So the sensible response is neither "adopt it" nor "ignore it", but to try it somewhere a mistake costs nothing: a pre-sorting step with a person behind it anyway. That is where you find out, on your own data, whether the accuracy holds up for your case — including in German.