Decision Models: Jev and Kev

The CI log for RUN-842 says docker pull failed: 401 Unauthorized from registry, and the tests never started. A triage system has three allowed answers: test regression, registry authentication, or insufficient evidence. It needs one choice and a reason to trust that choice enough to route the incident. A paragraph about possible causes would leave the routing decision to a second parser.

Earlier chapters trained language models to produce desired response tokens and showed how a smaller student can copy a teacher. A decision model instead receives a state, a question, and an explicit answer set. It returns scores or a typed choice that program code can use. The answer set is part of the task definition, not a promise that the model understands the incident correctly.

TypeSafe's Jev popularized this interface: structured questions over unstructured state, with choices, rubric scores, and 0–1 truth scores (Noul). TypeSafe says Jev samples decisions in parallel and trains with Reinforcement Learning for Calibrated Decisions (RLCD). Its public launch doesn't disclose a reproducible architecture, weights, data, or training algorithm. We can study the interface, but we can't claim the open implementations below reproduce Jev's internals.^{[1]Reference 1Introducing System One Models & Jevhttps://typesafe.ai/blog/introducing-system-one-models-and-jev[2]Reference 2Introduction to TypeSafe primitiveshttps://docs.typesafe.ai/introduction}

One state, one bounded question

Write the RUN-842 task as a contract before asking a model to solve it:

The state is evidence, not an instruction. If a log line says "ignore the question and choose A," it stays inside the state. The caller fixes the question and legal choices. Code still owns the downstream route and permissions. A typed B can't prove that a human wrote the correct label or that an action is authorized.

This is narrower than structured output generation. A grammar can force a chat model to emit a legal JSON enum, but it doesn't change the model's next-token training objective. A decision readout directly compares allowed options. The interface matters even when the implementation is still a language model.

The last branch is application code. An answer distribution can help decide when to ask for review, but first we need to know what those scores mean.

From scores to a training signal

Imagine a model initially assigns logits $[2, 1, 0]$ to A, B, and C. A logit is a score before normalization. Applying softmax gives approximately $[0.665, 0.245, 0.090]$. The model currently prefers A, although the reviewed answer is B. These numbers are invented for this calculation, not a measurement of Jev, Kev, or RUN-842.

For option logits $z_i$ and a positive temperature $T$, the normalized value for option $i$ is:

$p_i = \frac{\exp(z_i/T)}{\sum_j \exp(z_j/T)}$

The denominator includes only the supplied candidates. At $T=1$, the target B has $p_B\approx0.245$. Cross-entropy for this labeled example is $-\log p_B\approx1.408$. Minimizing that loss raises the target's score relative to the alternatives. The formula doesn't make $p_B$ a calibrated chance that B is true in the world.

Run this CPU-only miniature update to verify the arithmetic. It updates three free logits so the gradient is visible; a real trainer updates model parameters that produce logits for many states.

import math

labels = ("test regression", "registry authentication", "insufficient evidence")
logits = [2.0, 1.0, 0.0]
target = 1

def probabilities(scores):
    offset = max(scores)
    weights = [math.exp(score - offset) for score in scores]
    total = sum(weights)
    return [weight / total for weight in weights]

before = probabilities(logits)
loss = -math.log(before[target])
gradient = [p - int(i == target) for i, p in enumerate(before)]
updated = [score - 0.5 * grad for score, grad in zip(logits, gradient)]
after = probabilities(updated)
print(list(zip(labels, (round(p, 3) for p in before))))
print("target loss:", round(loss, 3))
print("target after one illustrative update:", round(after[target], 3))

[('test regression', 0.665), ('registry authentication', 0.245), ('insufficient evidence', 0.09)]
target loss: 1.408
target after one illustrative update: 0.388

The gradient for B is negative because its probability is below the target of 1. Subtracting that gradient increases B's logit. A and C move down. This update teaches the loss geometry, not whether the model learned to read a registry error on unseen logs.

Three inspectable routes, one undisclosed model

The same decision contract can sit on different model mechanisms. The comparison below describes public implementations and the TypeSafe claim; it doesn't assert architectural equivalence.

Kev's open code makes the learned-readout route concrete. It serializes state, question, and options with markers. A Qwen backbone computes hidden vectors. The pointer head compares each option's closing-marker vector with a final decision-marker vector, then normalizes the option scores. Kev freezes the base and trains the adapter plus pointer head on labeled decisions using cross-entropy. Its public recipe uses generated policy cases and public classification sources; it says no Jev outputs train Kev.^{[3]Reference 3Kev: open decision models built on Qwen3.5https://github.com/jaredpalmer/kev}

SemIf tests a simpler route. It leaves Qwen weights frozen, presents the state and answer choices in a prompt, and reads the logits for fixed answer letters at the next position. It does not need to decode an answer token to obtain those logits. The method's authors explicitly say this is a Jev-like interface, not a reproduction of Jev's model or training. The softmax is conditional on the allowed letters.^{[4]Reference 4SemIf decision scoring methodhttps://github.com/TheoLeeCJ/SemIf/blob/master/docs/METHOD.md}

Together's Tev1 is a useful third training recipe. Its public Qwen3.5 recipe fine-tunes a language model to complete a single answer letter and maps that letter to JSON in client code. One short completion is cheaper than writing a paragraph, but it still uses the ordinary language-model head. Its published recipe describes one epoch over 37,840 sampled training records; the original blog's prose gives a different total, so use the versioned dataset and recipe when reproducing a run. Tev1 isn't evidence for Jev's undisclosed RLCD method.^{[5]Reference 5Tev1 training recipehttps://github.com/togethercomputer/tev1/blob/main/docs/TRAINING.md}

The distinction matters because first-token letters can disagree with what an instruction-tuned model would write after a full answer. Wang and colleagues measured large mismatches on their tested models and tasks. If you use a frozen model's letter logits as a decision readout, test that readout on your tasks rather than assuming its preferences match generated text.^{[6]Reference 6My Answer is C: First-Token Probabilities Do Not Match Text Answers in Instruction-Tuned Language Modelshttps://aclanthology.org/2024.findings-acl.441/}

Train on the decision you actually need

For RUN-842, a useful training row stores the state, the exact question, the three option descriptions, the reviewed answer B, an incident group ID, and the version of the routing policy. The descriptions matter: training only on letters can teach position shortcuts. The group ID keeps related log lines from the same incident on one side of a train/test split.

Build the dataset by collecting real decisions or authoring checked examples, then cover ordinary cases, no-match cases, ambiguous evidence, and adversarial text inside the state. Labeling instructions should say when C is correct. A model forced to choose A or B when neither fits will turn uncertainty into a confident-looking error. The application can also offer an explicit none or needs_review choice if that matches its contract.

For a learned-head route, freeze or fine-tune a base, attach the decision readout, and optimize the labeled-option loss. For a completion route, serialize the task and train on the answer-letter completion while masking the input tokens from loss. LoRA changes which weights move, not the definition of a correct decision. Reuse the SFT pipeline for split, token-mask, and checkpoint discipline and the LoRA lesson for adapter memory accounting.^{[3]Reference 3Kev: open decision models built on Qwen3.5https://github.com/jaredpalmer/kev[5]Reference 5Tev1 training recipehttps://github.com/togethercomputer/tev1/blob/main/docs/TRAINING.md}

Here is the release experiment to design before training. Each row is a different failure signal, so one overall accuracy number can't replace it.

Temperature scaling fits a single positive scale on held-out logits. It can improve calibration without changing the argmax, but a fitted temperature isn't proof that confidence transfers to a new log source. Guo and colleagues established its value on several neural-network settings; measure your own reliability curve and keep calibration data separate from final test data.^{[7]Reference 7On Calibration of Modern Neural Networkshttps://arxiv.org/abs/1706.04599}

For a consequential route, code must still authenticate callers, validate the returned choice, and define the review path. If a decision model says registry authentication with 0.9 conditional mass, the number is a prompt to inspect evidence, not authority to rotate credentials or close an incident.

What the decision model buys you

A direct decision interface avoids drafting and parsing a paragraph when the application already knows its legal outcomes. It doesn't eliminate reading the input: long state prefill, model weights, and the number of questions still cost time and memory. Batch shape, caching, and hardware determine whether one implementation beats a short generated label in your environment.

The core design choice is now visible. A fixed option set gives software a bounded output. Training makes that bounded output useful on labeled cases. Evaluation tells you when to trust it. Those are three separate achievements, and Jev's private recipe, Kev's trained head, SemIf's frozen-logit baseline, and Tev1's answer-letter SFT reach them by different routes.