A decisions-only model has published a result in its own documentation that most vendors would bury. Ask Jev whether a customer who writes “I was charged twice for the same order” wants a refund. Then ask whether they do not want one. The two probabilities come back as 0.72 and 0.47 (72% and 47%), which sum to 1.19. That is a 19% overshoot on a pair that logic says should total 100%. TypeSafe, the team that ships Jev, documented this itself. The learnjev.com tutorial on the three primitives, last reviewed on 18 September 2026, calls it “the most important thing on the page”. I would go further: it is the most useful thing a Bauleitung team can learn about AI before its next defect walk.

One year into the LLM-in-CAD wave, offices show a consistent pattern. The chat window that promised to draw walls got demoed. The narrow question that returns a number got deployed. Every Bauleitung already runs a probabilistic model; it’s called Friday afternoon.

Three shapes of answer

MarkTechPost published a coding guide on 23 September 2026. It frames Jev as a “System One” model built for typed decisions and calibrated confidence: fast judgements, not essays. Jev answers in exactly three shapes:

• Noul answers “Is this true?” It returns one probability between 0 and 1 and has no confidence field. TypeSafe has never said what the word stands for, so treat it as a coined name.
• Choice answers “Which of these options?” It returns the winning option, the full probability distribution and a confidence value, across up to 255 options.
• Score answers “Which level?” It takes 2 to 10 ordered levels, low end first, and returns a probability-weighted position plus a legend. Three levels give a range of 0 to 2, so a score of 1.6 sits between the second and third level.

Machine learning has a name for the gap between a stated probability and how often it comes true: calibration. A Cornell University paper by Chuan Guo, Geoff Pleiss, Yu Sun and Kilian Weinberger, “On Calibration of Modern Neural Networks” (ICML 2017, arXiv:1706.04599), showed that modern neural networks tend to be over-confident. It also showed that a simple post-hoc step, temperature scaling, closes much of that gap. Jev gives you the whole distribution, not just the winner, so you can run that check yourself. The trade-off is plain: the three primitives do not agree with each other, so choosing one is a policy decision, not a formatting detail. Take the ticket “I’m not happy with the fit. What are my options here?” A Noul put the refund probability at 0.22 (22%). A yes/no Choice on the same question gave “yes” only 0.01 (1%) and “no” 0.99, with a confidence of 0.97.

TypeSafe reads this generously, and correctly: the two primitives are asking different questions. Its skill-suggestion cookbook uses a Choice to pick which skill to suggest and Nouls to decide whether to suggest one at all. The same split works on site. “Which trade owns this defect?” is a Choice. “Should anyone be called about it tonight?” is a Noul.

←TODAY: A 2026 decisions model publishes, in its own docs, that two opposite questions can score 72% and 47%.
→3012: Every Mängel record in Zurich-3012 carries its full distribution, readable as plain JSON decades later.
Fulcrum: A typed answer with its probabilities can be audited later. An answer in prose is an opinion that disappears with the chat window.

The Tool: Jev is TypeSafe’s decisions-only model. You call it through its HTTP API or the TypeSafe Python SDK. It is worth an afternoon because it turns a messy site note into three machine-readable answers your script can branch on. That is the part of AI that fits between an Archicad issue list and the Bauleitung’s phone. The model is only days old and still changing. The learnjev page marks, sentence by sentence, which claims are TypeSafe’s own and which were independently checked. The people who wrote it are the quiet heroes here, and a good site report needs the same habit.

Setup: This uses Python 3.11 and the plain HTTP route, so nothing hides between you and the response. Copy the endpoint, auth header and request envelope from TypeSafe’s HTTP API reference. The key names below follow learnjev’s walkthrough, so check them against the reference before you trust the first answer.

# Python 3.11+ (Linux, macOS, WSL; Git Bash works too)
python -m venv .venv && . .venv/bin/activate   # Git Bash: .venv/Scripts/activate
pip install requests
export JEV_URL="<endpoint from TypeSafe's HTTP API reference>"
export JEV_KEY="<your key>"
cat > triage.py <<'EOF'
import os, sys, json, requests
# envelope keys follow learnjev's walkthrough; confirm them in the API reference
body = {"state": sys.argv[1],
        "questions": {"fire": {"type": "noul",
            "instructions": "Does this note concern a fire-protection element?"}}}
r = requests.post(os.environ["JEV_URL"], json=body,
    headers={"Authorization": "Bearer " + os.environ["JEV_KEY"]})
print(json.dumps(r.json(), indent=2))
EOF
python triage.py "Fire door EG-03: closer missing, frame gap 8 mm"

First steps:

1. Run the Noul above on a real note from your last defect walk. Read the noul value as a probability, not a verdict. 0.55 is a coin with an opinion, not a yes.
2. Add a Choice called trade with this criteria map: {"Rohbau": null, "Fassade": null, "HLKS": "heating, ventilation, air-con, sanitary", "Elektro": null, "Innenausbau": null}. A description can be null when the name speaks for itself. Give the full trade list rather than a shortlist, because each option costs only a few tokens.
3. Add a Score called severity with three levels, low end first: ["cosmetic, log on the Mängelliste", "functional, fix before Abnahme", "safety or fire protection, stop and escalate"]. The result will land between 0 and 2.
4. Keep all three questions in one request. Each one sees the same note, runs independently and in parallel, and returns under its own key.

TypeSafe’s rule of thumb belongs above the monitor: prefer the type whose answer your code can act on directly. A Choice maps onto branches, a Score onto a threshold, a Noul onto an if. Learnjev also names a trap: using a Noul as a spectrum, for example asking “how serious is this?” as a yes/no probability. Severity is ordered, so it needs a Score.

Atelier: Picture an office heading into an SIA 118:2013 Abnahme with a few hundred open Mängel. The win is not an AI that writes the defect list. It is a script that sorts the list, shows its probabilities and flags when it is unsure; the step-by-step guide at jev-tutorial.org builds exactly that kind of human-review threshold. Monday move: run 20 closed defects from your last project through the trade Choice and the severity Score. Then write down the threshold (for example, severity above 1.5) at which a human always reads the note.

Hack: Recompute the severity position yourself from the returned probabilities, so the team can see why a note landed at 1.6 instead of taking one number on faith. A Score is a probability-weighted average of the level indices, so you can check it in Rhino 8’s Script component (Python 3) next to the model, without calling the API again. The same few lines also measure how far TypeSafe’s published pair of opposite Nouls drifts from summing to 1.

p = [0.10, 0.20, 0.70]                        # example Score probabilities, low end first
pos = sum(i * pi for i, pi in enumerate(p))   # 0*0.10 + 1*0.20 + 2*0.70 = 1.6
drift = (0.72 + 0.47) - 1.0                   # TypeSafe's published Noul pair: 0.19
review = pos > 1.5 or abs(drift) > 0.1       # send to a human if either trips

From where I sit in the late 2070s, the defect records that survived were the plain-text ones. Jev returns JSON, so store the whole distribution with each defect, not only the winning label. Put it in the BCF topic or in a CSV next to the IFC. Models change fast; the learnjev page already cites TypeSafe’s jev-1.13 jaggedness notes. When the version changes, whoever inherits the project should still see what the model decided and how sure it was. If your defect list lives in Archicad, the PAZ Grasshopper↔Archicad Library is the natural bridge for writing the Score back onto the element as a property. That way the severity stays attached to the door instead of living in a spreadsheet.

The questions are only half of a request. Learnjev’s next chapter argues that the state you send has more effect on accuracy than almost anything else: the note, the room, the element ID. Site notes are usually thinnest exactly there. Pull 20 closed defects, ask each one a Noul, a Choice and a Score, and keep every probability. The notes where the three disagree are the ones a person needs to read.

Learn-it:

• learnjev.com — The three primitives: the page this tutorial follows, with every claim marked as TypeSafe’s own or independently checked.
• Jev Tutorial — step by step: SDK install, a first call, confidence thresholds and human review.
• MarkTechPost — A Coding Guide to TypeSafe AI Jev: typed decisions, calibrated confidence and speculative fan-out.
• PAZ note: PAZ Academy teaches Rhino 8 scripting and has taught Grasshopper 2 since its alpha. The Hack above runs as-is in a Rhino 8 Script component. PAZ is also a Rhino reseller if your office needs a seat.