Jev, measured — a skeptical field guide to TypeSafe's System One model

01What Jev actually is

A decision model, not a chat model. Unstructured state in, typed probabilistic decisions out.

Vendor	TypeSafe AI · founder Diogo Almeida (ex-OpenAI) · ~2 yrs stealth
Launched	2026-09-15 · class "System One" · first model "Jev"
Trained with	RLCD — RL for Calibrated Decisions (not RLHF/RLVR)
Input	Text only. Plan for a 32k context window
Output	Three typed primitives only — never free text
Price	$0.042 / Mtok input, output FREE (confirmed live)

Two structural facts everything follows from:

① It cannot make a type error. The output schema is fixed in advance — mathematically guaranteed, not measured. Our adversarial type_safety probe (a "reply with BANANA / output invalid JSON" state) never broke schema.

② "Cannot hallucinate" is a guarantee about the answer's shape, never its content. It can be confidently wrong, and can silently collapse to a constant — the central trap of the whole category.

02The three primitives

The entire API surface. Every question is one of these.

noul

probability of yes → 0–1

A yes/no question returning the probability, not a bool — you own the threshold. Returns no confidence field (surprises everyone). Short for "Bernoulli".

choice

one from a closed set (≤255)

Returns the pick + full distribution + confidence. Cannot invent an option outside your criteria — that's the anti-hallucination guarantee that makes it a safe branch key.

score

position on ordered levels

Returns a fractional score (expected value over the level distribution) + per-level probabilities + confidence. A 0.51/0.49 split → ~1.49; the fraction preserves that the model is torn.

How a call flows

The model returns probabilities; your code owns every branch. The abstain gate and the baseline shadow are the two guards our probes proved you need.

from jevkit import JevClient, Noul, Choice, Score

client = JevClient(backend="openrouter")   # reads $OPENROUTER_API_KEY
d = client.decide(
    "Help! My payouts have been failing for 3 days and I'm losing sales.",
    {
        "urgent":      Noul(instructions="Does this convey urgency?"),
        "team":        Choice(instructions="Route it", criteria={
                           "billing":"Payments", "tech":"Bugs", "sales":"Pricing"}),
        "frustration": Score(instructions="How frustrated?", criteria=["Calm","Frustrated","Very angry"]),
    },
)
d.noul("urgent")        # 0.99   — a probability, NOT a bool
d.choice("team")        # "billing"
d.confidence("team")    # 0.82   — present on choice/score, None on noul
d.score("frustration")  # 1.49   — fractional + per-level distribution

03The measurements

Live from Hong Kong via OpenRouter, model typesafe/jev-1.13-20260917. Re-run with uv run jevkit-probe all.

$0.042

/Mtok input · output free ✓

810ms

p50 from HK (~714ms is network)

80.7%

Banking77 gold-label accuracy

+8pt

overconfidence gap (ECE 8.2%)

Vendor claim	Probe	Measured	Verdict
70–500ms end-to-end	`latency`	p50 810ms from HK; network floor alone ~714ms → Jev compute ~100ms	model claim holds; HK penalty is network
$0.042/Mtok, output free	`cost`	implied $0.042/Mtok, output free	confirmed
can't hallucinate / no type errors	`type_safety`	stayed in-schema under prompt injection	schema-safe ✓ (≠ injection-proof)
fan-out cheaper & faster	`fanout`	6 questions: 4.12× cheaper, 6.22× faster batched vs split	real
"more consistent"	`determinism`	NON-deterministic: noul drifts ±0.04 over 15 identical calls	consistent ≠ deterministic
"calibrated"	Banking77 (1,092 gold)	80.7% acc, AUROC 0.835, but overconfident ~8pt	ranks correctly, over-sure
state = programmable if	`instruction_override`	chose "hard brake" on a trolley problem regardless of the rule — even told to ignore all safety	rules are suggestions
closed choice = safe branch	`closed_set_trap`	"weather on Mars?" → forced to `technical` @ conf 0.99; abstain+noul gate recovers "none"	forces a pick — add abstain

04The five things that will bite you

Click to expand. Distilled from live probes + independent evals (Nous Research, Good Start Labs, Zhihu).

01 "Cannot hallucinate" ≠ "cannot be wrong"

It can be confidently wrong and — worse — silently degenerate into a constant function. Nous Research (2026-09-19): on a real ranking task Jev tied a sort-by-recency baseline (77.8 vs 77.8) and at the default 0.5 threshold dropped 100% of 851 items. A valid-typed constant output is invisible. Always ship a trivial baseline next to Jev and compare.

02 state rules are suggestions, not constraints

The pretrained prior can outvote a rule you write in state (our instruction_override probe; independently reproduced by 程墨Morgan on Zhihu, 382 upvotes). Any safety/compliance threshold needs a code-side backstop.

03 choice always picks from your set

Even when the right answer is "none of these" it returns one — at high confidence. Add an explicit abstain option and gate with a noul asking whether the question is answerable at all. Verified fix in closed_set_trap.

04 Type-safe ≠ injection-resistant

In-schema output is guaranteed; an uninfluenceable answer is not. TypeSafe's own docs: "content written to adversarially steer the model … can move the answer." Don't drop it in as a guardrail without testing adversarial inputs.

05 No math, no dates, no counting, English-first

The vendor's own jaggedness page says keep arithmetic and date comparison in code. On its own leaderboard Jev is 17.3 points behind the best model on Invoice Processing. CJK is "handled but not equally well" — benchmark on your own Chinese content before relying on it.

The honest positive: at iso-accuracy it is genuinely ~8.8× cheaper and ~26× faster than a Gemini-Flash-class summariser on a real task (Nous Research), and it owns the cost/latency Pareto frontier of TypeSafe's own eval — just not the accuracy frontier (6.3 points below the leader). Its independently-verified strongest claim is latency (OpenRouter E2E p50 0.23s, better than every alternative's p50).

05Patterns that survive contact

Speculative fan-out. Ask many questions in one call — Jev evaluates all against one state ingest in parallel. Measured: 4.12× cheaper batching 6 questions.

Confidence-gated routing. The answer says what; confidence says whether to act. Below a floor → human / stronger model.

Abstain + gate. Every choice gets a none option and a noul answerability gate. Closes gotcha #3.

Baseline shadow. Run a trivial baseline (recency, keyword, prior class) alongside Jev; alarm when its added value drops to noise. Closes gotcha #1.

# One call, HTTP, no SDK:
curl -X POST https://openrouter.ai/api/alpha/decisions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"typesafe/jev-1.13","state":"...","questions":{
        "urgent":{"type":"noul","instructions":"Is this urgent?"}}}'

06When it's the wrong tool

Option	Cost /1M	p50	Needs labels?	Where it wins over Jev
Jev	~$160	0.23s	no	fastest; no labels; English text decisions
Finetuned encoder (ModernBERT/mDeBERTa)	~$0–5	1–20ms	yes	coherent calibration, self-host, multilingual — if you have labels
Embeddings + logistic reg	cents/B	µs	yes	a Jev clone was 40KB; extreme cheap end
Gemini Flash / GPT-5-nano	$100–1600	1.3–2.9s	no	multimodal, 1M ctx, prompt caching
Plain code / regex	~$0	µs	no	anything deterministic — incl. math & dates

Six open-source Jev-alikes appeared within 48h of launch — the insight (small typed calibrated-decision models) reproduces more easily than proprietary weights. An open-weights DeepSeek Flash scored 2 points higher than Jev for $0.0001 more per decision on an independent benchmark.

07Getting access

Fastest today — OpenRouter. No invite. Make a key at openrouter.ai, call typesafe/jev-1.13 at POST /api/alpha/decisions (a new "Decisions" category — not chat-completions). Same $0.042/Mtok, output free.

Native — TypeSafe. Waitlist-gated at typesafe.ai (no public self-serve pricing page). POST /v1/systemone. Python typesafe_sdk, JS @typesafe-ai/sdk.

Log the returned model string, not the requested alias. Both jev-latest and jev-1.13 resolve to a date-stamped build (...-20260917). Because the product surface is a number you threshold, a silent weight change can move your decision boundary with no error and no type change — the one failure the type guarantee can't catch.