Jev by TypeSafe: The System One Model That Answers in Types

Bro, just say true. Your code needs one boolean. Your LLM hands you an essay. Every dev who has wired a model into an if statement has felt this. Jev, from TypeSafe AI, is built for that exact moment: you send it some text and a few typed questions, and it sends back values your code can use directly — no essay, no parsing. We read TypeSafe's docs end to end and ran the idea through two examples side by side: 📧 a spam filter and 🧪 a vibe check for AI-written pull requests. Facts come from TypeSafe's docs and independent write-ups (linked at the end). The PR example is ours, and its numbers are made up to show the shape — we label them every time.

TL;DR

• Jev is TypeSafe's flagship model and, per its docs, the first "System One" model: it reads a state (your text) plus typed questions and returns typed answers with probabilities. It does not write replies, code or explanations.
• Three answer types: Noul (how likely is this true, 0–1), Choice (one option from your list) and Score (a level on your rubric). Mix them in one call.
• Choice and Score come with a confidence number. The docs' playbook: high → act, medium → confirm, low → hand it to a human. Scale the threshold with the risk.
• Pricing on the Models page: $0.042 per million input tokens, output tokens free. Text-only, English works best.
• Speed and cost multipliers on TypeSafe's homepage are vendor claims. A comparison run by the makers of the rival open CLM-8B found Jev had the higher success rate on two tasks but was slower on all four. LLMs for words, Jev for decisions. 🫡

The pain: you asked for a boolean, you got a TED talk

Here's the whole problem in one line of TypeScript. You want a boolean. An LLM gives you text. The compiler is not impressed:

declare function askLLM(prompt: string): Promise<string>;

const isSpam: boolean = await askLLM("Is this email spam? Answer true or false.");
// ❌ Type 'string' is not assignable to type 'boolean'.

So you add "respond ONLY with JSON", write a parser, write a retry for when the parser fails, and pay for every output token of the model thinking out loud. TypeSafe's docs call it a mismatch: LLMs produce text for humans, so you coerce text generation into a decision, then parse it back. Tiny yes/no, chunky invoice — and your app asks it all day long.

What Jev actually is (it's not a chatbot)

TypeSafe calls Jev its flagship model and the first System One model. The name nods to Daniel Kahneman's Thinking, Fast and Slow: System 1 is fast and intuitive, System 2 is slow and deliberate. Jev is pitched at the fast, focused judgments — the gut-checks a knowledgeable person makes in a few seconds.

You send a state (the text to judge) and typed questions; Jev returns typed answers plus probabilities. No text generation, no parsing. It reads natural language like an LLM — it just never writes any. On its homepage, TypeSafe says it went the opposite way from RLHF-tuned chat models (which it blames for mode dropping, overconfidence and unreliability): a new architecture, a new sampler and a training algorithm called RLCD — Reinforcement Learning for Calibrated Decisions. Per MarkTechPost, Jev entered limited early access on September 15, 2026.

Two lanes: spam vs vibe-coded PRs

Everything below runs in two lanes at once. The spam lane uses shapes and values recorded in TypeSafe's docs wherever they exist. The PR lane is our own example: a merge gate for pull requests your AI agent wrote at 2am. Same model, same three primitives, very different stakes.

The three primitives: Noul, Choice, Score

Noul: "is this true?" as a number

A Noul returns the probability that the answer is yes. You pick the threshold in code. TypeSafe's docs recorded jev-1.13.0's answers to one question across six customer messages — a nice look at how the number moves:

The docs' own gate is one line: wants_human = response.answers["is_human_escalation"].noul > 0.9. Their rules of thumb: raise the threshold when a false yes is expensive, lower it when missing a true yes is expensive, ask one yes/no per Noul, and phrase it so high = yes.

spam = r.answers["is_spam"].noul
if spam > 0.9: move_to_spam()
elif spam > 0.2: send_to_review()
else: deliver()

if r.answers["touches_payments"].noul > 0.5:
    request_human_review()

Choice: one option from your list (and nothing else)

A Choice picks from a fixed set of up to 255 options. You get the winner, a probability for every option (they sum to 1) and a confidence number: flat distribution → low, one clear peak → high. The docs suggest adding an "other" option so the model is never forced into a bad fit.

Score: a level on your rubric

A Score takes 2–10 ordered levels and returns the probability-weighted average level, so it can land between levels. The docs' big lesson: describe situations, not degrees. On a misaligned-button bug report, numbers-only levels ("0", "1", "2") scored 0.55 with confidence 0.33; descriptive levels ("Cosmetic; no impact to functionality"…) scored 0.0 with confidence 1.0. Same report, way more certain.

One state, many questions, no context rot

An LLM writes its answer one token at a time, and a long multi-part prompt can drift. Jev's docs describe something different: every question in a call is evaluated in parallel and in isolation against the same state, so adding questions barely changes response time and one question can't pollute another. Extra questions still cost input tokens, though.

Confidence: act, confirm, or call a human

TypeSafe's Confidence page opens with a line we'd frame: "If an intelligent system, whether human or machine, cannot express honest uncertainty, the system cannot be trusted." Choice and Score return a confidence between 0 and 1, derived from the probability distribution. Noul skips it — with two outcomes, the probability already says it all.

The key rule: thresholds scale with risk. The docs' banking example sends anything under 0.5 confidence to a human, lets a low-stakes balance check go straight through, and still asks for confirmation on a transfer unless confidence is above 0.9. Here's that logic as a sketch — the action names are from the docs, the layout is ours:

intent = response.answers["intent"]

if intent.confidence < 0.5:
    route_to_human()
elif intent.choice == "check_balance":        # low stakes
    show_balance()
elif intent.choice == "approve_transfer":     # money moves
    if intent.confidence > 0.9:
        confirm_then_execute()
    else:
        ask_user_to_confirm()

Atomic questions, composed in code

Jev is built for gut-checks, not essays. So instead of asking "rate this startup pitch", the docs say to ask market size, technical feasibility and differentiation as separate questions and combine them with your own formula. Their composite-scoring example: priority = 0.6 × severity + 0.3 × frustration + 0.1 × report quality (each normalised by its top level), which gave 0.664 on their sample. Want different priorities? Change a coefficient in code instead of rewriting a prompt.

risk = (0.5 * is_spam
        + 0.4 * has_phishing_link
        + 0.1 * urgency / 2)

risk = (0.6 * touches_payments
        + 0.3 * (1 - has_tests)
        + 0.1 * cursed / 2)

LLMs for words, Jev for decisions

Jev doesn't replace your LLM. It replaces the part where you were forcing an LLM to be an if statement. TypeSafe's use-case map lists the shapes it's for — classification, detection (spam, fraud, urgency, jailbreaks, sensitive data), scoring, routing, verification — and use cases like semantic code linting, LLM guardrails and model routing.

Fun detail: TypeSafe's use-case map literally lists Harness Engineering — model routing, semantic context retrieval, LLM error detection and guardrails, reasoning-trace classification. That's the checks-around-the-agent layer we cover in what harness engineering is. A PR vibe check is a harness gate with a typed brain.

Receipts and a reality check

Also on the Models page: no per-customer fine-tuning (same RLCD-trained weights for every account), no training on customer requests or responses, and zero data retention for enterprise. You customise Jev through the state, your instructions and criteria, and how you split questions.

For an outside view: Contrastive-LM's open CLM-8B is also a System One model, and its authors benchmarked it against Jev zero-shot, as reported by MarkTechPost and Superpower Daily. In short, Jev had the higher success rate on two of the four tasks, while CLM-8B was faster on all four. The numbers, task by task, are in our full CLM-8B vs Jev benchmarks.

One more receipt: as a best-of-N verifier on held-out subsets (compared against fine-tuned CLM heads), Jev scored below simply taking the first attempt — 71.1% vs a 73.7% pass@1 on DeepSWE, 83.1% vs 84.0% on Terminal-Bench 2.1. Small subsets, not leaderboard runs, but the lesson stands: benchmark your own decisions before trusting anyone's multiplier. Including ours. 👀

Vibe it: set it up in five minutes

The Python SDK needs Python 3.10+ and reads your key from TYPESAFE_API_KEY:

pip install typesafe-sdk

TypeSafe also ships an agent skill so your coding agent knows how to write Jev calls. In Claude Code:

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

And the quick start from TypeSafe's docs, verbatim — one call, all three primitives:

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 the integration 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)  # "technical"
print(response.answers["frustration"].score)  # 1.0
print(response.answers["is_urgent"].noul)  # 1.0

The docs' recorded response for that call: technical with confidence 0.78, frustration 1.0, is_urgent 1.0 — and a usage line of 392 input tokens, 65 output. Under the hood it's a single POST to https://api.typesafe.ai/v1/systemone with a bearer key. Here are both lanes as full calls (our code, using the SDK's shapes; no outputs claimed):

r = client.system_one(
    state=email_text,
    questions={
        "is_spam": Noul(instructions="The email is spam"),
        "team": Choice(
            instructions="Which team should handle this email",
            criteria={
                "sales": "Pricing, quotes or buying questions",
                "support": "Help with an existing account",
                "other": "None of the above",
            },
        ),
    },
)

spam = r.answers["is_spam"].noul
if spam > 0.9:
    move_to_spam()
elif spam > 0.2:
    send_to_review()
else:
    route_to(r.answers["team"].choice)

r = client.system_one(
    state=f"{commit_message}\n\n{diff_summary}",
    questions={
        "touches_payments": Noul(
            instructions="The diff changes payment code",
        ),
        "verdict": Choice(
            instructions="What should happen to this pull request",
            criteria={
                "ship_it": "Small, clear, low-risk change",
                "needs_review": "Plausible, but a person should check it",
                "rewrite": "Unclear or unsafe; start over",
            },
        ),
        "cursed": Score(
            instructions="How useful the commit message is",
            criteria=[
                "Says what changed and why",
                "Vague: updates, misc fixes",
                "Cursed: fix stuff lol, asdf",
            ],
        ),
    },
)

a = r.answers
if (a["touches_payments"].noul > 0.5
        or a["verdict"].choice != "ship_it"
        or a["verdict"].confidence < 0.9):
    request_human_review()

When NOT to use Jev

• Anything whose output is words: customer replies, summaries, explanations. Jev doesn't generate text. Use an LLM.
• Writing or fixing code. Your coding agent writes the code; Jev can judge it.
• Images or audio. Jev is text-only — convert to text first or pick a different tool.
• Non-English-heavy workloads without testing. The docs say other languages, including CJK, are handled, but not as well as English.
• Questions that need extended reasoning. Decompose them into atomic gut-checks — or, if they can't be split, that's a job for an LLM. Not in the type, bro.

The one-line version: LLMs for words, Jev for decisions, your code for the rules in between. No yapping. 🫡