TypeSafe Jev: System One decision model for software, not chat

TypeSafe Jev is TypeSafe AI’s first public System One model: you send state plus typed questions, and you get Choice, Score, or Noul answers with calibrated probabilities. It does not generate free text. If you need a decision your code can branch on in tens to hundreds of milliseconds, that is the product. If you need chat, code, or prose, you still need a language model.

This hub opens a seven-day feature series on oguzhan.co. I will cover the primitives, confidence and RLCD, speed and price, agent guardrails, context compaction, the Doom and Wikiracing demos, and the community map at cobanov/awesome-jev. For the wider AI desk on this site, keep the AI notes hub open, and see today’s model-routing note Claude vs GPT vs Gemini: which job for which model.

⚡ What the TypeSafe Jev model is (and is not)

TypeSafe AI came out of stealth around 15 Sep 2026 with Jev. The launch post by founder Diogo Almeida frames Jev as a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out. The three primitives are Choice (pick from a closed list), Score (rate against ordered rubric levels), and Noul (probability that a yes/no statement is true). Choice and Score also return a confidence number derived from the probability distribution. Noul returns a single probability in [0, 1] and has no separate confidence field.

Jev is not a chatbot. It is not a coding agent. It will not draft your email. TypeSafe’s own jaggedness notes put generation out of scope. The company’s “can’t hallucinate” line means the model cannot emit out-of-schema strings. It does not mean every Choice is factually correct. Schema-valid is not the same as right. That distinction is the spine of this series.

🧠 Why System One vs chat LLMs

The name nods to Daniel Kahneman’s System 1 / System 2 framing in Thinking, Fast and Slow. TypeSafe’s FAQ is explicit: System One models target fast, structured judgments that software can consume, not slow deliberative writeups. Chat LLMs were optimized for human preference (RLHF) and, more recently, verifiable rewards. They speak in strings. Strings are flexible. They are also expensive to sample, awkward to parse, and easy to take off-rails inside an agent loop.

The software-interface argument is the part I care about as a builder. An if-statement does not want a paragraph. A router wants a label and a probability. A guardrail wants a risk score you can threshold. You can coerce GPT-class models into JSON with schemas, but you still pay for sequential token generation, and you still get overconfident text when you ask for a confidence number. TypeSafe’s claim is that if the product is a decision, you should train and sample for decisions. Almeida (ex-OpenAI, publicly linked to the RLHF / ChatGPT research line) put it bluntly: if AI is going to change how work gets done, people cannot be the only consumers of intelligence.

🧩 How it works: Choice, Score, Noul

Docs describe the call shape cleanly. You send a state (string, JSON object, or array of text) and a map of named questions. Questions of different types can share one call. The model evaluates them in parallel against the same state. Adding more questions barely moves latency, because sampling is parallel rather than autoregressive.

• Choice: selected option, full probability distribution over options, confidence.
• Score: rubric level, probabilities over levels, confidence.
• Noul: noul in [0, 1] for “is this statement true?”

Confidence is not a second mystery model. TypeSafe documents it as a statistic collapsed from the probability distribution you already receive. Flat distribution, low confidence. Peak on one option, high confidence. Your code owns the thresholds. High confidence can auto-act. Medium can ask a human. Low can refuse. The jaggedness guide also shows that a Noul and a yes/no Choice on related wording are not guaranteed to obey neat arithmetic identities. Do not port a threshold from one primitive to another and call it science.

Training uses a method TypeSafe calls RLCD (Reinforcement Learning for Calibrated Decisions). Public materials describe the goal as epistemically honest probabilities on System One tasks, not preferred prose. I have not seen an independent reproduction of the full RLCD stack. Treat the name as the company’s training story, not as a peer-reviewed recipe you can copy tonight.

📏 Evidence, workflow evals, and jaggedness

TypeSafe published workflow evaluations that keep the compute graph fixed and score models against reference probabilities from large external systems (the launch post names an average of GPT-6 Astra and Fable 5.1). On those company workflows, TypeSafe says Jev owns much of the Pareto frontier, with homepage peak figures around 193.6x faster and 444.6x cheaper than the LLM baselines in that harness. The launch post itself adds nuance: workflows were built by their capabilities team (bias possible), references lean toward OpenAI and Anthropic models, and LLMs were wrapped into a System One-compatible interface that is slower and costlier than free-form generation.

Independent skepticism is healthy here. Benchmarks that use other models as the reference answer measure agreement with those models, not ground truth. Schema validity is guaranteed by construction for Jev’s typed outputs. Correctness is not. TypeSafe’s own jev-1.13 jaggedness page is unusually honest: literal reading of instructions, weak counting and arithmetic, fragile date comparison, distractors in large state, adversarial content, and broken structural invariants across related questions. If your task is math, keep the calculator in code. If your state is huge, filter first.

The Register’s Thomas Claburn put the same caution in plain English on 16 Sep 2026: calling the model hallucination-free is not a fair comparison to chat models, because the output is not natural language. Structured wrong answers are still wrong.

💸 Cost and latency claims (with subsidy caution)

Public pricing from TypeSafe’s models page and the launch table: $0.042 per million input tokens, output tokens free (“too cheap to meter” in their wording), end-to-end latency roughly 70-500 ms on their service. OpenRouter lists typesafe/jev-1.13 at the same $0.042 / $0 with a 32K context card (listing date 18 Sep 2026). TypeSafe’s own models page currently documents a 64k total request budget and a 32k budget for state plus the longest question. Pin the version (jev-1.13.0) when you compare numbers; aliases like jev-latest move.

TypeSafe says it cannot prove the price is not subsidized, and that long-term sustainability still needs time. Fair. Compare apples to apples: a frontier chat model generating long tool traces is a different bill than a parallel decision head returning a few typed fields. The headline multipliers in Almeida’s launch thread (about 20-200x faster, 40-400x cheaper) and the higher peaks on workflow evals are company figures on company tasks. Re-measure on your traffic.

🎮 Doom and Wikiracing: what the demos prove

The Doom demo is the marketing magnet. TypeSafe is clear in the nuance section: the bot reads structured game state as text, not pixels. A classical Doom bot could play better. The point is reactive decisions over changing state representations, at roughly ten queries per second in their writeup (about $7/hour at that rate, per the company). The Register and secondary coverage repeated the structured-state caveat. Do not cite this as vision-based game playing.

Wikiracing stresses high-cardinality Choice: hundreds to thousands of links, with Jev’s Choice cardinality capped at 255 and a two-stage score-then-choose path for larger sets. The demo argues that avoiding free-text link invention compounds over a multi-hop path. It does not prove general intelligence. It proves that constrained selection plus speed can look sharp on a link-traversal toy.

🌐 Ecosystem tour via awesome-jev

cobanov/awesome-jev is the best public map I have found. The September 19 research notes put community projects past 100, plus official SDKs and provider listings. A few concrete examples across the series themes:

• Guardrails / agents: leepokai/jev-guard scores tool-call risk into allow / ask / deny; luantak/is-malicious screens source and CI files before execution; qkal/Canny challenges unsupported “done” claims from coding agents.
• Context compaction: projects such as tamaratran/fast-jev-compaction and related winnow-style tools use Jev to decide what to keep. The model proposes; your code must still enforce retention rules.
• Browser / computer use: community repos under the browser section feed extracted text or DOM summaries into Jev. Hosted Jev is text-only; perception is separate.
• Open reproductions: zhengxuyu/litjev (LitJev), zhihz/openjev, jaredpalmer/kev, and TianyuCodings/NanoJev explore Jev-like parallel decision heads on open models. awesome-jev labels them independent, not verified clones of TypeSafe’s proprietary RLCD stack.

Provider surface area already matters for real shipping: OpenRouter (typesafe/jev-1.13), Vercel AI Gateway (typesafe-ai/jev via AI SDK’s experimental evaluate API, changelog dated 16 Sep 2026), and Cloudflare Workers AI (typesafe/jev). Vercel’s Boolean primitive maps to TypeSafe’s Noul. Read each provider’s ID carefully; they are not identical strings.

📣 The X launch moment

I did not pull live X HTML in this research pass (fetch surfaces were blocked or thin). Secondary trackers and thread mirrors are consistent enough to summarize carefully. Diogo Almeida posted the launch from @CompleteSkeptic around 15 Sep 2026. Thread mirrors quote the core claims: RLCD, no text generation, roughly 20-200x faster and 40-400x cheaper with free output tokens, plus Doom and Wikiracing clips. Doomers’ launch tracker reports on the order of 30.4 million views for that post (about 30,443,909 in their case study page), ranking it near the top of the launches they track, from an account that started the day with a small following. Treat view counts as tracker-reported, not as an audited Nielsen number. Reception mixed the usual launch pattern: engineers excited about typed decisions and price, skeptics asking whether workflow evals overfit and whether “no hallucination” is category gamesmanship. The Register’s coverage and Forkast’s product read landed in that second camp without denying the interface idea.

Funding: The Register reports TypeSafe AI with $40 million in funding at debut. Forkast describes a $40 million seed led by DCVC at a reported ~$200 million valuation. Those are press figures. I am not repeating unverified cap-table detail.

✅ When to use Jev / when not to

Use it when the decision is narrow, the option set is known, latency budgets are tight, and your code can own thresholds: intent routing, triage, rubric scoring, moderation gates, citation checks, tool selection inside an agent loop, map-reduce style labeling over large corpora. Confidence-gated routing is the architectural win: auto-act on high confidence, escalate on low.

Do not use it when you need prose, open-ended planning narration, creative writing, or multi-hop reasoning stuffed into one question. Do not use it as a calculator. Do not dump an entire unfiltered corpus into state and hope. Do not treat a valid Choice as an audit. And do not ship high-impact actions on model judgment alone. awesome-jev’s start-here section says the same: validate on your data, calibrate thresholds, keep deterministic checks in front of irreversible tools.

🗓️ Seven-day Jev feature series on oguzhan.co

This post is day 0, the cluster hub. Daily extras (about 900-1400 words EN, with original Turkish rewrites) land 20-26 Sep 2026 at 11:00 Europe/Istanbul:

1. 20 Sep – Primitives: Choice, Score, Noul, state + questions API.
2. 21 Sep – Confidence & RLCD: calibrated probs vs chat overconfidence; jaggedness.
3. 22 Sep – Speed & cost: 70-500 ms, $0.042/MTok, parallel sampler, Pareto nuance.
4. 23 Sep – Agents & guardrails: jev-guard, Canny, is-malicious and peers; schema-valid ≠ correct.
5. 24 Sep – Context compaction: what Jev selects vs what code must keep.
6. 25 Sep – Real-time demos: Doom, Wikiracing, browser hybrids; text state, not pixels.
7. 26 Sep – Ecosystem & limits: OpenRouter, Vercel, Cloudflare; LitJev / openjev / kev / NanoJev; when not to use Jev.

If you only bookmark one page for the week, make it this hub, then bounce through the day posts as they publish. For Turkish readers, the sibling article sits under the Yapay zeka hub. For English browsing of the wider AI cluster, keep /ai/ handy.

📚 Sources

• TypeSafe: Introducing System One Models & Jev (15 Sep 2026)
• TypeSafe docs (primitives, confidence, models, jaggedness)
• TypeSafe: jev-1.13 jaggedness
• cobanov/awesome-jev (+ Sep 19 research notes)
• The Register: TypeSafe AI debuts model for machines that plays Doom (16 Sep 2026)
• Vercel changelog: Jev on AI Gateway (16 Sep 2026)
• OpenRouter: typesafe/jev-1.13
• Cloudflare Workers AI: typesafe/jev
• Doomers launch tracker: TypeSafe AI / Jev (X view counts)
• Thread mirrors / secondary: Thread Navigator @CompleteSkeptic; Forkast product read (17 Sep 2026)