Meet Jev: Fast AI Decision Model vs LLMs Explained

A Model That Only Answers the Question

Most of what software does with language isn’t writing. It’s deciding. Which team gets this ticket? Is this email a scam? Did the customer ask for a refund? Is the agent about to do something it shouldn’t? For the last few years the default way to make those calls has been to ask a large language model and parse whatever it says back. That works. It is also a bit like hiring a novelist to sort the post.

On 15 September 2026, TypeSafe AI released Jev, a model built for the sorting and nothing else. You hand it a message and a few typed questions. It hands back answers with probabilities attached, in roughly a tenth of a second. It never writes a sentence.

The animation below explains how that works, where it shines, and the one blind spot worth designing around. It takes about two and a half minutes. You’ll make three choices along the way, and each one changes what you see.

The Same Story, Without the Hedgehog

Jev is a classifier, not a chatbot. TypeSafe calls it a “System One” model, borrowing Daniel Kahneman’s term for fast, intuitive judgement. System Two is the slow, deliberate kind: the reasoning a large language model does when it works through a problem one word at a time. Jev skips all of that. It reads the whole input in one pass and returns a decision. There is no chain of thought and no explanation.

	A large language model	Jev
Output	Free-form text, one token at a time	A typed answer with probabilities
Typical job	Writing, summarising, reasoning, conversation	Routing, flagging, scoring, gating
Speed	Seconds per call	Tens to hundreds of milliseconds
Cost	Pay for input and output	4.2¢ per million input tokens; output is free
Explains itself	Yes, if asked	Never
Can say “I don’t know”	Yes	Only if you give it an option for that
Reading window	Up to around a million tokens	Much smaller; reported at 32–64k

Three kinds of question

Every Jev request is a state, meaning the thing being judged (text, JSON, or a chat transcript), plus a set of named questions. Each question is one of three types, and every question is answered in parallel and in isolation against the same state.

Choice picks one option from a list you define, up to 255 of them. It returns a probability for every option and an overall confidence.
Score rates the state against between 2 and 10 ordered levels, such as calm, frustrated, very angry. It returns a continuous score, the full distribution, and a confidence.
Noul is TypeSafe’s name for a yes-or-no question. It returns the probability that the statement is true. It has no separate confidence field.

Setting it up

It’s a single HTTP endpoint. Get an API key from TypeSafe, then send a state and your questions:

curl https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": "The deploy failed twice and customers are seeing 500s. Can someone look now?",
    "questions": {
      "urgent": {
        "type": "noul",
        "instructions": "Does this need attention right now?"
      }
    }
  }'

The answer comes back keyed by your question names, something like {"answers": {"urgent": {"type": "noul", "noul": 0.95}}}, plus a token count. What happens next is ordinary code: page someone above 0.8, queue it below. Python users can go through LangChain instead with pip install langchain-typesafe:

from langchain_typesafe import Noul, TypeSafeClassifier

classifier = TypeSafeClassifier()  # reads TYPESAFE_API_KEY

response = classifier.invoke({
    "state": "The deploy failed twice and customers are seeing 500s. Can someone look now?",
    "questions": {
        "urgent": Noul(instructions="Does this need attention right now?"),
    },
})

urgency = response.nouls["urgent"].noul

Where it fits

The pattern that keeps coming up in early write-ups is Jev filters, the LLM writes, code acts. Run Jev over everything, because it’s cheap enough to. Hand only the interesting fraction to a generative model, for the parts that genuinely need words. Some of the jobs people have tried it on so far:

Triage. Route support tickets by team, urgency and refund intent in one call.
Agent guardrails. Ask “is this tool call risky?” before an AI agent runs it, on every step.
Evals. Grade model outputs against a rubric at a fraction of the cost of an LLM judge.
Feeds and inboxes. Label comments, posts or email as they arrive.

It doesn’t fit anything that needs an answer written out: drafting, summarising, brainstorming, conversation, or explaining a verdict. One tester also tried it as a trading bot. Speed, it turned out, is not the same as being right.

Jev cannot abstain. If none of your options fits, it picks the least-wrong one anyway. In one published test a question about when the cafeteria closes, offered only billing, technical and sales, came back as sales with 0.31 confidence. Three habits follow from that:

Give it an escape route. Add an other or needs_review option whenever your categories can’t cover everything.
Treat low confidence as a signal. Decide what happens below your threshold, usually a human, before you let anything run automatically.
Test the ambiguous cases, not the easy ones. Confidence tells you how concentrated Jev’s probabilities are. It does not tell you it’s right.

Where the Numbers Come From

Jev is less than two weeks old, so treat every figure here as early. The speed and cost comparisons in the animation come from independent hands-on tests, not TypeSafe’s own marketing. TypeSafe’s own claim is “20 to 200× faster and 40 to 400× cheaper” than frontier models, which is a range wide enough to be true of almost anything.

Price, latency, the negation test and the cafeteria case: MindStudio’s hands-on test. The price is 4.2¢ per million input tokens, and eight requests took 92–214 ms each.
1,000 emails in about 6 seconds for $0.09, against about 5 minutes and $0.62 on a GPT model; 1,000 comments in about 5 seconds for $0.05: MindStudio’s 12 use cases.
91.5% agreement with Claude Fable 5.1 across 6,003 rubric checks, at about $160 per million grades against $33,000: Good Start Labs, reported by Langfuse. The same comparison found an open-weights model, DeepSeek V4.1 Flash, agreeing 93.5% of the time for $260, so Jev is not the only cheap judge.
Question types, limits and the request format: TypeSafe’s API reference and LangChain’s integration guide.
What might be inside it: Sebastian Raschka’s educated guess is a small encoder model in the BERT family. TypeSafe hasn’t disclosed the architecture. The interesting part isn’t the classifier itself. It’s that one classifier generalises across jobs that used to need a separately trained model each.

Meet Jev: The AI That Never Writes a Word