Agents: read the raw Markdown of this page, or start at llms.txt.
Blog: Don't Call It a Decision Model (2026-11-03)
TL;DR TypeSafe's 2026-11-03 post, by Allie Laabs (DevRel), explains why TypeSafe keeps calling Jev a System One model rather than a "decision model": Jev makes judgments, code makes decisions. It argues against one big Choice whose
criteriacarry the business rules. Instead, split the decision into small Jev questions plus code-computed facts, and let code rules pick the outcome. TypeSafe gives three reasons: clearer design, traces you can read, and easier extension.
Facts
| Field | Value |
|---|---|
| Title | "Don't Call It a Decision Model" |
| Subtitle | "Jev makes judgments, code makes decisions." (also the closing line) |
| URL | https://typesafe.ai/blog/dont-call-it-a-decision-model |
| Date | 2026-11-03 (page shows "Nov 3, 2026") |
| Author | Allie Laabs, DevRel, TypeSafe |
| Figures | Three: "the decision chip with its cap on", "with its cap off", "with a new exit added" (HTML alt text) |
| Example | A simplified version of the Customer Service workflow from the evals site (Workflow evals: how TypeSafe measures Jev) |
| Links out | "How to build with TypeSafe", the patterns section, Discord |
| Captured | 2026-11-07 (text and HTML) |
What it argues
The name. TypeSafe says the "decision models" label has caught on, and admits its own teaching material has used the word "decision". It keeps "System One" because of Daniel Kahneman's Thinking, Fast and Slow: System 1 is fast and intuitive, and Jev is meant for quick, focused judgments.
The wrong layer. The post calls this the naive design: pass in all the state and ask one Choice, with every business rule and caveat written into criteria. It says this can work, but leads to "prompt gymnastics": you keep rewriting long condition text for each edge case, and the next unexpected input breaks it again. Much of the decision is plain logic the system already knows. Only some of it needs judgment.
The decomposed version. The worked example is support triage with six exits. The post gives both versions:
| Exit | Rule in the decomposed version |
|---|---|
| Fraud team: freeze & dispute | reports an unauthorized charge |
| Hand to a person | asks for a person, or threatens legal action |
| Refund now | wants money back, claim eligible, ≤ $25 |
| Refunds team reviews | wants money back, claim eligible, over $25 |
| Offer to stay | wants to cancel, subscription active, open to an offer |
| Answer & continue | otherwise |
Questions like "does the user want money back?" go to Jev. Checks like claim eligibility or the amount are code. The single-Choice version it argues against is a request to jev-latest with one choice question action and six criteria entries (fraud_team, handoff_person, instant_refund, refunds_team, retention_offer, answer), each a long rule written as text.
The three reasons it gives
- Clarity of design. Splitting a decision into single judgments and logic paths shows what flows through the system and which edge cases need handling.
- Observability. With one Choice, a misrouted case leaves only one probability, with nothing to show which judgment or rule caused it. The decomposed trace in the post lists each Jev judgment with its probability:
wants_money_back.99,reports_unauthorized.94,requests_human.02,threat_legal.01,wants_to_cancel.02,open_to_offer.22. It also lists each code fact (refund_eligible,small_refundandsubscription_active, all false) and the rule that fired: the fraud rule on p > 0.6 →fraud_team. You can then tell whether the judgment or the rule was wrong. - Extendability. Adding exits means writing their logic and any new judgments, and existing judgments stay as they are. Its "Waive the fee" example adds one judgment and one code-computed fact. The post says Jev evaluates each judgment in isolation, so a new question does not affect the ones already validated.
The post closes by asking readers to sketch the inside of one decision in their own app: mark the lookups and arithmetic, and write a question at each spot that needs judgment. It suggests pointing a coding agent at the article to find those spots.
Relationship to Jev
The post is a design guide, not a release: it announces no model, API or price change. It makes the same point as the docs' build guide (How to build software with System One) and the patterns overview (as captured 2026-11-07), which says every pattern "leaves the decision to your code" (raw/docs/patterns.md). The claim that judgments are evaluated in isolation matches the build guide: "Questions are evaluated independently and in parallel" (raw/docs/concepts__how-to-build-with-system-one.md; see also Speculative fan-out). The trace format is the post's illustration. Neither the API nor the SDKs return such a trace; your code builds it (inferred).
Related
- System One Models — what TypeSafe means by a System One model
- How to build software with System One — decomposing questions and combining answers in code
- Patterns overview — the patterns the post points to
- Composite scoring — combining several answers in code
- Workflow evals: how TypeSafe measures Jev — the Customer Service workflow the example simplifies
- Writing instructions and criteria that Jev reads correctly — what belongs in
criteriaand what does not - Versions and timeline (models, SDKs, API, company) — dated record of TypeSafe posts
Sources
- raw/site/blog-dont-call-it-a-decision-model.txt (https://typesafe.ai/blog/dont-call-it-a-decision-model), captured 2026-11-07
- raw/docs/patterns.md (https://docs.typesafe.ai/patterns), raw/docs/concepts__how-to-build-with-system-one.md (https://docs.typesafe.ai/concepts/how-to-build-with-system-one): the docs statements compared above
- raw/site/blog-dont-call-it-a-decision-model.html: figure alt text and the trace values the text extract drops (
wants_to_cancel.02, the three code facts)