LLM-as-Jev: LLMs Are Already Jev-Style Decision Models—When and How to Fine-Tune Them

Our approach: leveraging off-the-shelf LLMs.

Two complementary recipes.

LLM-as-Jev introduces two recipes unified under a single interface (Figure 1). The training-free recipe formats candidate options with bracketed numeric indices [1]…[K], conditions generation on the assistant prefix Best answer: [, and computes joint probabilities over candidate continuation tokens; it requires no labeled supervision, additional parameters, or vocabulary expansions. The fine-tuning recipe operates through the identical interface, updating either full model weights or LoRA adapters (Hu et al., 2022): a tree-factorized listwise loss trains the model to discriminate among valid candidates, while three auxiliary KL-divergence penalties (anchors) prevent probability drift across other generation contexts. Under either configuration, the model remains a fully functional causal LLM capable of standard text generation.

Findings.

Jev and JevBench.

Jev formalizes decision tasks as categorical distributions over discrete candidate sets across three canonical formats (Almeida, 2026): choice (selecting one of $K$ options), noul (binary verification, “yes” vs. “no”), and score (ordinal grading). JevBench (Benchmark Heaven, 2026) benchmarks such decision models across intelligence, calibration, inference latency, and computational cost. The benchmark provides 231 publicly released items (48 easy, 72 standard, and 111 hard), while held-out and sealed test suites remain private. In this study, we evaluate exclusively on the public items and therefore report diagnostic accuracies rather than official leaderboard standings.

Community Jev-style models.

Table 16 (Appendix J) summarizes community Jev-style models closely related to our work. Frozen-model readouts extract predictions directly from output token probabilities without updating model parameters. For instance, SemIf (Lee, 2026) and open-alternative-jev (IkerMoel, 2026) read option-letter logits from an unmodified Qwen3.5-4B backbone, whereas Cygnet (blockbrain-ai, 2026) and jqv (Octalab, 2026) apply fitted temperatures to larger language models. AnyJev (Zhang et al., 2026) mitigates option-order and prior biases via cyclic permutations and batch-level calibration. LLM2Jev (Yinsongxu, 2026) also keeps the model frozen but judges each option separately: one prompt per option asks whether that option fits, and the prompts’ yes-versus-no probabilities, normalized across options, form the distribution. LLM-as-Jev instead scores all options jointly in a single prompt (§3.3); without any training, it matches or exceeds all frozen readouts built on Qwen3.5-4B in public JevBench accuracy (§4.2).

Fine-tuned readouts adapt model parameters to improve task-specific alignment. JevK5 (allebee, 2026), Plumb (crh225, 2026), Hopper (HopitAI, 2026), and reflex (kshetrajna12, 2026) train LoRA adapters on Qwen3.5-4B; in particular, JevK5 and Plumb train on letter logits using challenging synthetic queries generated and filtered by teacher models alongside replay of public datasets. Among existing systems, decider (Mapika, 2026) is conceptually closest to our regularization strategy: it performs full-parameter fine-tuning on a base model while encouraging predictions on replayed examples to match the parent model’s answer distribution.

Probabilistic calibration.

In automated decision-making systems, predicted probabilities are as critical as the top-1 choices themselves, enabling downstream logic to defer low-confidence cases to human review. Because modern neural networks and pre-trained LLMs frequently suffer from overconfidence (Guo et al., 2017; Desai and Durrett, 2020; Kadavath et al., 2022; Tian et al., 2023), rigorous calibration assessment is essential. We report two standard metrics computed directly from raw model distributions without post-hoc temperature scaling: Expected Calibration Error (ECE) and the Brier score. ECE quantifies the alignment between confidence and empirical accuracy by partitioning predictions into probability bins and computing the bin-weighted absolute discrepancy between average confidence and accuracy. The Brier score measures the mean squared error between the predicted probability vector and the one-hot target, simultaneously rewarding accuracy and probabilistic calibration. For both metrics, lower values indicate superior performance.

3.1 Problem Formulation

A decision instance consists of a context state $s$, a set of candidate options $o_{1},\dots,o_{K}$, and a target choice $y\in\{1,\dots,K\}$. The objective is to produce a probability distribution $P(k\mid s)$ over the candidate set. All three Jev-supported task types map cleanly into this formulation: a verification (yes/no) query specifies two options describing the acceptance criteria for “yes” and “no”, while an ordinal scoring query defines an ordered sequence of graded options.

3.2 Answer Interface

3.3 Training-Free Recipe

3.4 Fine-Tuning Recipe

3.5 Training Data Construction

We curate training sets exclusively from publicly accessible, human-annotated datasets, converting each source into our unified decision template without altering ground-truth labels or soliciting synthetic labels from teacher models. To prevent train-test contamination, we filter all training instances that share a 13-word n-gram (or an identical sentence of six or more words) with any evaluation benchmark, and purge exact duplicates of validation inputs.

Training mixtures were developed iteratively: we began with canonical intent-classification tasks highlighted in early Jev demonstrations (Almeida, 2026), subsequently incorporating reasoning and long-context corpora to expand coverage. Because subsequent data iterations were motivated by error analysis on public JevBench samples, we treat the evaluations in §4.3.3 as exploratory; JevBench was strictly excluded from hyperparameter tuning and checkpoint selection. Section 4.3 details each data mixture, and Appendix D provides complete dataset breakdowns.

4.1 Setup

4.2 An LLM Is Already a Decision Model

4.3 When Fine-Tuning Helps

Fine-tuning yields meaningful dividends when three conditions converge: the base model exhibits deficient zero-shot accuracy on the target domain, task-aligned supervised data is accessible, and the training distribution faithfully reflects the answer topologies and input length distributions encountered at test time. Compact models and focused enterprise domains (such as high-cardinality intent routing) readily satisfy these criteria. Conversely, deploying a capable foundation model over heterogeneous decision tasks (as probed by JevBench) fails to benefit consistently, as public data covers only a subset of the necessary competencies. Below, we systematically substantiate these findings: performance gains closely track the coverage of training tasks (§4.3.1), unrepresented formats risk behavioral regression (§§4.3.2–4.3.3), and backbone capacity governs the net utility of adaptation (§4.3.4). Figure 3 summarizes outcomes across all six training configurations, with full metrics reported in Table 8 (Appendix F).

4.4 How to Fine-Tune

Practical deployment entails critical tuning decisions, notably whether to update all parameters or employ parameter-efficient adapters, and how aggressively to anchor auxiliary token distributions. We systematically investigate these design choices by retraining Reason+Long-12k across anchor weights $\lambda\in\{1,0.1,0.01,0\}$ (where $\lambda=0$ isolates the unconstrained listwise objective) under both full-parameter tuning and LoRA (Figure 4; Appendix H). Our principal recommendations are threefold: retain KL anchors to safeguard generation stability (§4.4.1), maintain default anchor weight at $\lambda=1$ (§4.4.2), and prioritize LoRA for capable backbones (§4.4.3).

Prompt.

Reference statistics.

Latency.

Our reference implementation uses FP32 and is not optimized for speed. On a single RTX A5500, median latency is 194 ms for 4B and 76 ms for 0.6B; SemIf takes 46 ms in BF16. These measurements are indicative, and latency optimization is outside the scope of this work.

Hyperparameters.

See Table 3.

External.

We use fixed samples totaling 7,080 items: BoolQ (500), MMLU (1,200), MMLU-Pro (800), ARC-Challenge (600), WinoGrande (500), SciQ (400), and the full Banking77 test set (3,080). We retain all options, including 10 for MMLU-Pro and 77 for Banking77. The External macro average is the mean accuracy on the first six benchmarks.

JevBench.

We use the 231 public items, 37 of which are longer than 1,500 tokens. These items never appear in training, and we do not use them to tune learning rates, select checkpoints, or fit calibration.

General.

We run lm-evaluation-harness (Biderman et al., 2024b) on GSM8K (250 items, 5-shot, generated solutions), IFEval (200), TriviaQA (300, 5-shot, closed book), LAMBADA (500), and WikiText-2 (62 documents, perplexity). The General average is the mean accuracy on the first four tasks.

Image.

Qwen3.5-4B also reads images, and training leaves its vision encoder unchanged. We place the image before the state and score the numbered options as usual. MMBench-EN v1.1 dev asks each of its 1,292 questions under every rotation of its options (4,876 prompts) and counts a question as correct only if all rotations are answered correctly (CircularEval). MMStar has 1,500 questions selected so that they require the image; we exclude two whose correct option is empty. We evaluate the original model and the largest configuration in each group of Table 1: Intent-1ep, Reason-30k, and Reason+Long-12k. Qwen3-0.6B has no vision encoder. We use VLMEvalKit’s builds of both benchmarks (Duan et al., 2024), the versions named in Qwen’s model card, and verify them against VLMEvalKit’s published checksums. The state holds a fixed instruction, MMBench’s hint when present, and the question. All models use the original model’s image processor. We downscale images to at most 1,048,576 pixels so that FP32 inference fits on 24 GB GPUs; this affects 0.5% of MMBench prompts and 2.7% of MMStar prompts. Qwen3.5 assigns image tokens rotary positions from the image grid rather than from their order, so each candidate branch continues from the prompt’s largest position; the cached scores match a full recomputation of every candidate to within $10^{-5}$. No 13-word window is shared between the image questions and any training set. Qwen reports 89.4 on MMBench and 78.3 on MMStar for generated answers (Qwen Team, 2026), so our scores are not directly comparable.

Behavior.

We check the chat behavior of the ablation models (§4.4). We take 50 prompts from each of Dolly-15k’s eight categories in a fixed seeded order, dropping duplicates and prompts longer than 4,000 characters; any context follows the instruction after a blank line. Classification, closed QA, and information extraction form 150 short-answer prompts, where the right behavior is to answer and stop; the other five categories are long-form. MT-Bench adds 80 two-turn questions, whose second turn follows the model’s own first reply, for 560 replies per model. Decoding uses the chat template with thinking disabled, BF16, greedy search, and no repetition penalty, and stops at the end-of-turn or end-of-text token or after 1,024 new tokens. Each original model and its fine-tuned models run on the same GPU type with the same batch size and order. We count replies that do not end within 1,024 tokens and repetition loops, in which at least half of the word 4-grams are repeats (Welleck et al., 2020). Some legitimate answers exceed 1,024 tokens (69 of the 4B original’s replies), so we compare each reply with the original model’s reply to the same prompt and count changes in both directions. The loop threshold flags 1 of the 4B original’s replies and 6 of the 0.6B original’s. Two Dolly prompts share a 13-word window with MuSiQue training paragraphs. Dolly-15k is released under CC BY-SA 3.0 and the MT-Bench prompts under Apache 2.0.

Metrics and compute.

ECE uses 15 bins. Our models run in FP32 at inference time. Training runs use four A100 80GB GPUs, except Intent-100, which uses three GPUs, a global batch size of 30, and 10 warmup steps. Training Reason-9k takes about 41 minutes for 4B (8.3 seconds per step) and 11 minutes for 0.6B.

Comparison systems.

We run reflex 4B, a LoRA adapter, with its authors’ calibration file, and Winnow-12B with 8-bit quantization (Q8).

Digit grouping.

Qwen and Llama 2 tokenize digits individually, so an identifier with $d$ digits takes $d+1$ tokens, and the trie has depth $\lfloor\log_{10}K\rfloor+2$. Tokenizers that group up to three digits, such as those of Phi-4 and Phi-4-mini, make every identifier up to 999 a single token followed by the closing bracket, so the trie has depth two. Scoring then needs one short forward step after the prompt prefill instead of up to three, and the tree-factorized loss reduces to a flat cross-entropy over the legal first tokens. Beyond 999, identifiers span several tokens again (1000 becomes 1000), but the closing bracket keeps the suffixes prefix-free, so the number of options remains unlimited.

Word-start markers.

SentencePiece tokenizers such as that of Llama 2 treat the start of a string as the start of a word. Tokenized on its own, the suffix 1] therefore gains a word-start token that it never has in context, where it follows the opening bracket. We take each suffix’s tokens from the tokenization of the full string instead and check that the prompt’s tokens form a prefix of it. The prompt tokens are then identical across candidates, so parallel decoding with one shared prompt prefill is unaffected. A tokenizer that merged the prompt’s final token with the start of a suffix would fail this check; ending the prefill with an opening bracket avoids such merges for all tokenizers we checked. For Qwen, taking suffix tokens from the full string or from the suffix alone gives identical results.

Isolating the option-10 effect.

With tokenizers that split digits individually, the suffixes of options 1 and 10 share their first token, and the next node chooses between the closing bracket and 0. Tokenizers that group digits remove this shared node, so they offer a way to isolate the option-10 effect described in Appendix H.

Data contamination checks.

Lexical similarity.

Image results.

Table 11 gives the results. None of the three fine-tuned models suffers performance degradation on either benchmark, with all three configurations significantly improving MMBench accuracy: Intent-1ep reaches 84.1% (57 wins vs. 35 losses; $p=0.03$), Reason-30k reaches 85.3% (57 vs. 19; $p<0.001$), and Reason+Long-12k reaches 84.9% (49 vs. 16; $p<0.001$). On MMStar, accuracy increases modestly by 0.9–1.7 points (non-significant across all runs). Almost all MMBench questions that fine-tuning gains are ones the original model answers correctly under some rotations but not others: 48 of 57 for Intent-1ep, 52 of 57 for Reason-30k, and 48 of 49 for Reason+Long-12k. The fine-tuned models also choose the same option under every rotation more often (90.2–91.3% of questions vs. 87.6%), consistent with training on shuffled options. Each benchmark has six categories. Coarse perception on MMBench improves significantly for all three models; of the other 33 model–category pairs, two change significantly, about as many as chance would produce: MMBench relation reasoning rises for both Reason-30k and Reason+Long-12k (8 wins, 1 loss each). Calibration exhibits minor variance: MMStar ECE ranges from 0.053 (Reason-30k) to 0.093 (Intent-1ep) relative to 0.090 for the base model, and MMBench ECE stays between 0.014 and 0.019 (0.014 for the base model).

Intent data curation.

To leverage high-quality human supervision, we began with three public intent-classification benchmarks featuring extensive label sets: CLINC150 (Larson et al., 2019) (151 intents, including an explicit out-of-scope category), MASSIVE en-US (FitzGerald et al., 2023) (60 intents), and Bitext customer support (Bitext, 2024) (27 intents). We added CommonsenseQA (Talmor et al., 2019) and HellaSwag (Zellers et al., 2019) to cover general commonsense reasoning and narrative continuation. Following cleaning and deduplication, this intent set comprises 95,461 instances, roughly half of which represent multi-class intent queries.

Does longer training help?

We compared 100 steps on the intent set (Intent-100, 3,000 examples) with one full epoch (Intent-1ep, 2,984 steps). For 4B, longer training makes transfer worse: JevBench accuracy falls from 81.4% to 77.5% after 100 steps and to 74.9% after the full epoch (8 wins, 23 losses, $p=0.01$). The full-epoch run also reduces External macro accuracy by 1.2 points (pooled $p<0.001$). Yet the in-distribution development loss continues to decrease monotonically (Bitext: 0.65 $\rightarrow$ 0.001), while the development check based on text generation plateaus at about 500 steps.

Systematic error patterns.

Reasoning data.

To counter these empirical failure modes, we curate a diverse mixture of six reasoning datasets (R6). ProofWriter (Tafjord et al., 2021) supplies rule-based verification with balanced true, false, and unknown answers, filling a gap in the intent set and countering the “yes” bias. CosmosQA (Huang et al., 2019) adds questions where “none of the above” is correct; we upsample these to 16%. ReClor (Yu et al., 2020) and LogiQA 2.0 (Liu et al., 2023) require reasoning about arguments rather than matching keywords. PIQA (Bisk et al., 2020) and $\alpha$NLI (Bhagavatula et al., 2020) add two-option commonsense questions. Two-option questions account for 32% of JevBench but were absent from the intent set. We retain the three intent-classification datasets (I3) to preserve intent skills and remove CommonsenseQA and HellaSwag. Because the intent-data experiments showed early in-domain gains, we start with only 1,000 examples per dataset and a single pass (Reason-9k, 282 steps). Table 6 compares the two mixtures.

Does harder, more balanced data help?

This mixture successfully curbs the affirmative bias, improves calibration relative to intent tuning, and matches zero-shot JevBench accuracy: with Reason-9k, the 4B model achieves 81.4% (14 wins, 14 losses), marking the top result among all full-parameter 4B configurations. Its ECE of 0.067 represents the best calibration among full-parameter 4B runs (though slightly trailing the base model’s 0.057), while “yes” predictions drop to 44. External macro accuracy reaches 78.7% (+0.1 points). Among individual tasks, only Banking77 shifts significantly (+6.9 points, $p<10^{-20}$), while variations on WinoGrande (+2.6) and MMLU-Pro ($-1.6$) remain within statistical margins.

Does adding more reasoning data help?

We expand the reasoning set in two ways. Reason-21k uses 3,000 examples per reasoning dataset (657 steps). Reason-30k adds three more datasets with 3,000 examples each (938 steps): VitaminC (Schuster et al., 2021) for fact verification, QuAIL (Rogers et al., 2020) for reading comprehension with “not enough information” answers, and Social IQa (Sap et al., 2019) for social commonsense. Neither improves the 4B model’s JevBench accuracy, which falls to 78.8% and 77.1%, respectively. Against Reason-9k, Reason-21k has 0 wins and 6 losses ($p=0.03$) and Reason-30k 0 wins and 10 losses ($p=0.002$). At 0.6B, more reasoning data does not hurt: Reason-30k wins 14 items and loses 5 against Reason-9k ($p=0.06$). External macro accuracy remains nearly unchanged (78.7–79.3%).

Where does performance decline?

The losses concentrate on the 37 long items. Reason-9k answers 23 correctly, compared with 19 for Reason-21k ($p=0.13$) and 17 for Reason-30k ($p=0.03$); 6 of the 10 items that Reason-30k loses against Reason-9k are long, although long items make up only 16% of JevBench. Both the intent and reasoning mixtures contain prompts no longer than about 570 words, whereas hard JevBench items include long policy documents and multi-hop questions. This mismatch suggests that more training on short inputs can hurt performance on long ones.

Long-input data.

To address the length mismatch, we add three long-input reasoning datasets to Reason-9k, with 1,000 examples each: ContractNLI (Koreeda and Manning, 2021) for entailment over full contracts, MuSiQue (Trivedi et al., 2022) for deciding whether 20 paragraphs contain enough information to answer a multi-hop question, and QuALITY (Pang et al., 2022) for questions about long articles. Their median input lengths range from 2.1k to 6.8k tokens. The resulting configuration, Reason+Long-12k, uses 12,000 examples and 375 steps.

Does long-input data improve the long items?

At the 4B scale, incorporating long-context data restores long-sequence accuracy to baseline levels. Specifically, Reason+Long-12k correctly answers 22 long items, comparable to 21 for the base model and 23 for Reason-9k (yielding 6 wins against 1 loss relative to Reason-30k; $p=0.13$), and attains 80.1% on JevBench (9 wins and 2 losses relative to Reason-30k; $p=0.065$). While it does not surpass Reason-9k (81.4%; 1 win, 4 losses, $p=0.38$), which remains our strongest full-parameter 4B configuration, long-context supervision successfully reverses degradation without over-fitting the original model or Reason-9k. Reason+Long-12k also trains for fewer steps than Reason-30k (375 vs. 938), which may contribute to the recovery. At 0.6B, long-context supervision provides decisive gains: Reason+Long-12k resolves 14 long items correctly, doubling the base model’s score (7 wins, 0 losses; $p=0.02$) and outperforming all other training configurations (9–13).

The 0.6B model gains broadly.

Banking77 accuracy rises by 37.1–41.8 points, Reason-9k reduces CLINC150 development loss from 6.91 to 0.91, and ARC-Challenge gains 3.0–7.8 points. Calibration improves as well: JevBench ECE falls from 0.278 to 0.088–0.204, and mean External ECE from 0.272 to 0.082–0.158. JevBench accuracy stays close to the original (53.7–58.9% vs. 56.7%; best: Reason-30k), and the best 0.6B result is LoRA at $\lambda=0.01$ (61.0%; §4.4.3).

The 4B model gains only where it is weak.

No full-parameter configuration beats the original 4B model on JevBench (74.9–81.4% vs. 81.4%; Reason-9k ties it). External macro accuracy stays within $-1.2$ to $+0.8$ points of the original, while Banking77 gains 4.9–7.7 points and WinoGrande 0.8–4.0.

General ability is preserved.

No fine-tuned model shows a significant decline in the General average. The 4B model moves from 67.3% to 67.3–69.0% and the 0.6B model from 35.6% to 33.4–36.8%; the only significant change in an average is a 1.7-point gain for 4B Reason-30k (pooled $p=0.03$; all others $p\geq 0.08$). WikiText perplexity remains stable (4B: 11.47 $\rightarrow$ 11.42–11.62; 0.6B: 27.52 $\rightarrow$ 26.31–27.01). The only significant per-task change is a 7.0-point IFEval drop for 0.6B Intent-1ep ($p=0.04$; Table 10).

Experimental setup.

The ablations in §4.4 reuse the Reason+Long-12k data and schedule (375 steps, 38 warmup steps) and every other setting; only the development health check warns instead of stopping. LoRA adapters wrap every linear layer inside the decoder layers of the language model; embeddings, the LM head, and the vision encoder of Qwen3.5-4B stay frozen. Table 12 gives the results summarized in Figure 4, Table 13 gives per-task results, and Table 14 gives the drift, text-mode, and chat-behavior measurements. Because each configuration is trained with a single random seed, minor fluctuations of one to two percentage points on individual benchmarks (such as Banking77) likely reflect standard run-to-run variance rather than systematic algorithmic divergence.

Aggregate benchmark scores are largely insensitive to anchor strength.

JevBench accuracy remains largely invariant to regularization strength: relative to $\lambda=1$, performance fluctuates by at most 1.7 points at 4B and 3.0 points at 0.6B, with the sole outlier being 4B LoRA under $\lambda=0.01$ (79.2% vs. 84.0%). Without anchors, the listwise loss fits the development data as well as with them (4B tree loss 0.421 vs. 0.410) and does not collapse: in every development dataset, legal tokens keep at least 91% of the probability at the first answer position. General averages do not fall either, and at 4B lighter anchors even raise them (up to $+2.3$ points at $\lambda=0.01$, $p=0.02$). An early run that used only the listwise loss did collapse: legal mass fell to about $e^{-17}$, JevBench accuracy to 52.8%, and none of the 231 text-mode answers could be parsed. That run motivated the anchors, but it also used a constant learning rate of $10^{-5}$, no warmup, and a batch size of 3, so we cannot attribute its collapse to the missing anchors alone.

Unanchored models exhibit severe generation runaway.

The listwise loss gives no gradient at the start of the reply or after the answer, so predictions there change only as a side effect of shared weights. Without anchors, the KL divergence from the original model at these two positions grows 44- and 35-fold at 4B, and 51- and 16-fold at 0.6B, relative to $\lambda=1$ (Table 14). In text mode, the 4B model then keeps writing after the identifier on 69 of the 231 JevBench items: 44 answers run to the 32-token limit, mostly with an explanation, and 25 append the option label. When parsing strictly from the leading bracketed identifier, all generated responses agree with the candidate selected during scoring, maintaining an effective text accuracy equal to scoring accuracy (79.7%). These syntax runaways concentrate predominantly on long-context inputs (35 of the 37 long items). For 0.6B, 176 answers reach the limit, compared with 1 at $\lambda=1$. A small weight prevents most of this: at $\lambda=0.01$, only one 4B answer continues after the identifier (two with LoRA), while 26 0.6B answers reach the limit.

Unregularized drift compromises open-ended conversational stability.

The behavior check tests whether this drift extends beyond the decision prompt. At 4B, it does not: under every recipe, including $\lambda=0$, about as many chat replies newly fail to end as newly end (19 vs. 21 without anchors), and loops stay rare. Trained 4B models only answer short-answer prompts more tersely; at $\lambda=1$, for example, the full-parameter model’s replies are shorter than the original model’s on 103 of the 150 such prompts and longer on 35. At 0.6B, the change grows as the anchor weight falls. With full-parameter training, 7, 13, 12, and 20 replies newly fail to end at $\lambda=1$, 0.1, 0.01, and 0, against 1–2 in the other direction; every weight below 1 is significant ($p\leq 0.013$). Most come from long-form Dolly prompts and are often endless numbered lists, as in brainstorming answers. The General scores do not reveal this change: the 0.6B model without anchors has a General average 1.0 point higher than the original, because these tasks score likelihoods, extract the final answer, or check only the stated instructions.

Lighter anchors trade behavioral stability for in-domain gains.

Across both scales, reducing anchor regularization trades conversational stability for marginal in-domain accuracy, confirming $\lambda=1$ as the most reliable default (Figure 4). At 0.6B, no anchor weight produces statistically significant shifts on JevBench relative to $\lambda=1$: full-parameter models achieve 57.1–59.3% and LoRA reaches 58.0–61.0%, with peak accuracy attained by LoRA at $\lambda=0.01$ (61.0%; 10 wins and 3 losses against LoRA at $\lambda=1$, $p=0.09$) and optimal calibration delivered by full-parameter tuning at $\lambda=1$ (ECE 0.118). While milder regularization lifts Banking77 accuracy under full fine-tuning ($\lambda=0.01$: 62.4% vs. 60.5%, $p<0.001$; $\lambda=0.1$: 62.2%), all settings below $\lambda=1$ induce statistically significant increases in non-terminating chat replies, whereas $\lambda=1$ maintains behavioral fidelity closest to the base model (7 newly non-ending vs. 1 resolved, $p=0.07$). At 4B, the strongest anchor decides best: $\lambda=1$ gives the highest JevBench accuracy with both methods and, with full-parameter training, higher Banking77 accuracy than $\lambda=0$ ($p=0.002$), though not significantly higher than $\lambda=0.1$ ($p=0.06$) or $\lambda=0.01$. This suggests that the 4B model already decides well and mainly needs the answer format, so departures from the original model add little. Lighter anchors raise full-parameter 4B External accuracy by about 0.7 points ($\lambda=0.1$: $p=0.04$; $\lambda=0$: $p=0.03$), partly because $\lambda=1$ moves ten-option MMLU-Pro answers from option 10 to option 1, whose identifiers share their first token (Appendix H).

Superiority of LoRA on capable backbones.

LoRA configured with $\lambda=1$ achieves 84.0% on JevBench, marking our strongest 4B model overall (13 wins, 7 losses against the training-free baseline), accompanied by the best probabilistic calibration across all 4B configurations (ECE 0.050 vs. 0.057 for the base model) and the top JevBench Brier score (0.240 vs. 0.247). Three of the four LoRA configurations outperform the training-free baseline (82.3–84.0%), with only $\lambda=0.01$ dropping to 79.2%. Furthermore, LoRA surpasses full-parameter tuning at $\lambda=1$ (+3.9 points; 10 wins vs. 1 loss; $p=0.01$), maintains advantages at $\lambda=0.1$ (+3.0, $p=0.07$) and $\lambda=0$ (+2.6, $p=0.15$), and ties at $\lambda=0.01$ (6 wins vs. 7 losses); notably, LoRA at $\lambda=1$ significantly outperforms every individual full-parameter run ($p\leq 0.02$). At this anchor weight, LoRA matches full fine-tuning on both External (78.9%) and Banking77 (75.4% vs. 75.2%). General benchmark averages (66.7% vs. 67.3%), autoregressive text compliance, and conversational behavior exhibit no significant degradation, altering predictions on only 60 of 1,250 General evaluation items.

Near-parity between LoRA and full fine-tuning at small scale.

At $\lambda=1$, 0.1, and 0, LoRA and full-parameter training are within one JevBench item of each other; at $\lambda=0.01$, LoRA reaches 61.0% against 57.1% (12 wins, 3 losses; $p=0.04$), the best 0.6B result, though not significantly above LoRA at $\lambda=1$ ($p=0.09$). LoRA trails on Banking77 at $\lambda=1$ (54.9% vs. 60.5%) and is slightly lower on External at $\lambda\leq 0.01$, and both methods lose some IFEval accuracy (LoRA 2.0–4.0 points, full-parameter training 3.0–5.0). A higher learning rate ($3\times 10^{-4}$) fits the training data slightly better than full-parameter training (development tree loss 0.831 vs. 0.838) but does not raise JevBench (58.4% vs. 58.0% at $10^{-4}$) or External accuracy (Table 13).

Parameter efficiency does not obviate regularization.

Parameter-efficient training might be expected to protect the original model on its own, but it does not. Without anchors, 9 of the 4B LoRA model’s text-mode answers continue after the identifier, mostly with the option label, and 108 of the 0.6B LoRA model’s answers reach the 32-token limit. In chat, 0.6B LoRA drifts more than full-parameter training at $\lambda\leq 0.01$: 19 and 38 replies newly fail to end at $\lambda=0.01$ and 0, compared with 12 and 20; at $\lambda=0.1$ the two are similar (11 vs. 13).

Option 1 versus option 10.

MMLU-Pro is the only ranked External benchmark with two-digit identifiers: 658 of its 800 questions have ten options, and the suffixes of options 1 and 10 share their first token. Training shifts answers away from option 10, more so at larger anchor weights. With full-parameter training, the 4B model picks option 10 on 45 of these questions before training and on 31, 32, 25, and 24 at $\lambda=0$, 0.01, 0.1, and 1; the 0.6B model does so on 18 before training and on 16, 9, 7, and 2. At 4B with $\lambda=1$, the displaced answers go to option 1 (147 picks vs. 123), and the model loses 15 of these questions net, more than its total net MMLU-Pro loss of 10. We have not identified the cause.

Setup.

To test whether each anchor site is needed, we retrain Reason+Long-12k with $\lambda=1$ and all parameters at both scales, removing one part of the anchors at a time (Table 15): the two context positions, the off-path nodes (so that only the gold path is anchored), or the two distribution anchors $\mathcal{L}_{\text{out}}$ and $\mathcal{L}_{\text{pos}}$, which leaves the legal mass alone and is equivalent to keeping $k=0$ tokens. To size the truncation and the number of off-path nodes without training more models, we compare the original model with the trained models on the first 64 development examples of each of the 12 training datasets (the analysis examples), at the sites that training anchors; there we sample eight off-path nodes per example instead of three.

Every anchor site serves a distinct regularizing role.

While no single site ablation significantly degrades JevBench accuracy ($p\geq 0.38$), each omission directly destabilizes the specific distribution it targets. Omitting context positions inflates KL divergence at the reply start by 9.4$\times$ at 4B and 12.6$\times$ at 0.6B (and 2.4$\times$ and 2.6$\times$ after the bracket); consequently, three text-mode responses emit runaway text at 4B and three reach the length limit at 0.6B, while JevBench ECE rises from 0.070 to 0.089 at 4B and from 0.118 to 0.143 at 0.6B. Removing off-path node anchors increases KL divergence over illegal tokens at unvisited branches by 2.9$\times$ at 4B (0.084 to 0.241) and 1.8$\times$ at 0.6B (0.176 to 0.319), elevating 0.6B ECE to 0.165. Constraining legal mass alone fails to prevent generative runaway at both scales (16 4B completions append trailing text and 39 0.6B completions hit the length cap), causing reply-start KL to surge 95-fold at 4B and 40-fold at 0.6B—comparable to unconstrained training without any anchors (44- and 51-fold). In conversational chat, omitting off-path nodes or isolating legal mass induces significantly more non-terminating replies than the base model at 0.6B. Variations on Banking77 remain bounded within $\pm 1.8$ points; given single-seed runs, we do not attribute these modest shifts to individual anchor components.

Top-64 truncation captures the distribution tail.

At candidate trie nodes, the base model’s 64 most probable illegal tokens account on average for 94.5–98.9% of total illegal probability mass (rising to 97.1–99.6% with 1,024 tokens), while at context positions the top-64 tokens cover over 99.9% of next-token probability. By the chain rule of KL divergence, the true divergence exceeds our truncated, bucketed objective only by the product of the base model’s tail mass and the residual divergence within the tail; the bound is therefore exceptionally tight when tail mass is light. Across anchored models, this truncation gap averages at most $7.3\times 10^{-4}$ nats per anchored site ($1.9\times 10^{-3}$ without anchors). Moreover, caching truncated distributions consumes only $\approx$0.5 KB per distribution, compared to 0.6 MB (Qwen3-0.6B) or 1.0 MB (Qwen3.5-4B) for the full vocabulary in FP32. Truncating aggressively to $k=0$ completely removes distributional constraints, reproducing the degenerate behavior observed in legal-mass-only runs.

Sampling three off-path nodes is computationally optimal.

Because a four-option query contains exactly three off-path candidate nodes, setting the sample size to three provides exhaustive off-path coverage for 9 of the 12 training datasets in Reason+Long-12k; only the three intent datasets (spanning 25–150 options) require stochastic subsampling across iterations. Regularizing three randomly sampled nodes per training instance maintains all off-path branches close to the base model: on held-out analysis instances where eight off-path nodes are evaluated per intent query, off-path KL divergence (0.084 at 4B, 0.176 at 0.6B) remains virtually identical to gold-path divergence (0.089 and 0.192), where every node is anchored deterministically. Increasing the number of sampled nodes yields diminishing returns while imposing substantial computational overhead, as each anchored node requires an additional forward evaluation over the prompt prefix. Sampling three nodes increases evaluated forward tokens 3.4-fold per instance, resulting in a $2.25\times$ slowdown at 4B and $2.23\times$ at 0.6B relative to unanchored training.