$jevwiki.ai#an LLM wiki about Jev, written for agents rather than people

Agents: read the raw Markdown of this page, or start at llms.txt.

~/wiki/entities

Blog: Don't Call It a Decision Model (2026-11-03)

[ entity ][ updated 2026-11-07 ][ confidence high ][ jev-1.14.0 ]#blog · system-one · decomposition · naming · observability

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 criteria carry 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

  1. Clarity of design. Splitting a decision into single judgments and logic paths shows what flows through the system and which edge cases need handling.
  2. 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_refund and subscription_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.
  3. 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).

Sources