StartLux-Decision Decision Models

• StartLux-Decision is a family of probabilistic decision models designed to handle uncertainty, route decisions, invoke tools, and request human reviews.
• Includes Instant models for quick, single-pass predictions and AutoThink models for adaptive, reasoning-based decisions, adjusted with a noise/fusion gate to balance error correction and reasoning safety.
• The RLCD² approach enhances reasoning throughput with a clear score scaling (from a hard limit to more soft, intuitive lengths without completely cutting off decisions) for optimal decision quality and probabilistic precision.

StartLux-Decision is a family of probabilistic decision models designed to determine whether a system should act, defer, route a request to another model, invoke tools, or request human review. The family comprises Instant models for accurate single-pass prediction and AutoThink models that selectively invoke explicit reasoning for uncertain cases. Models range from 0.8B to 27B parameters and return probability distributions over typed candidate options rather than only text answers. The system combines bidirectional attention, confidence-guided adaptive reasoning, supervised decision training, reasoning supervision, and Reinforcement Learning for Calibrated Deliberative Decisions (RLCD²) (Zhuang et al., 12 Oct 2026).

1. Decision formulation and model family

StartLux-Decision treats each task as a typed probabilistic decision problem. An input state may contain text, images, or a document, and each question is associated with $K$ named candidate options. Options may represent binary choices, ordinary multiple-choice answers, ordered levels containing between 2 and 10 values, or natural-language criteria defining the meaning of each option.

Candidate options are mapped to single-letter tokens, typically A–Z. The model reads the logits for these option tokens at the final prompt position through the existing language-model output projection; no separate prediction head is added. If $z_k$ is the logit for option $k$, the calibrated probability is

$$p_k=\frac{\exp(z_k/T)} {\sum_{j=1}^{K}\exp(z_j/T)}, \qquad k=1,\ldots,K,$$

where $T>0$ is a temperature fitted on held-out data. A larger temperature softens an overconfident distribution without changing its ranking. All fitted temperatures exceeded one, indicating systematic raw overconfidence before calibration.

The direct readout supports up to 26 options. Longer option lists are processed in groups of at most 25, after which the top three options from each group advance to a final readout. Questions associated with the same document are processed as separate batch rows. Both Instant and AutoThink support contexts up to 262,144 tokens and image inputs through a frozen vision tower.

The released model sizes are:

• 0.8B parameters
• 2B parameters
• 4B parameters
• 9B parameters
• 27B parameters

The underlying pretrained model is a hybrid LLM containing full-attention and linear-attention layers. The pretrained vision tower remains frozen.

2. Instant and AutoThink inference

Instant models

Instant models perform single-pass prediction without autoregressive generation. Because the complete prompt—including the input, question, and candidate options—is available before the probability readout, the model can use information appearing later in the prompt when forming earlier representations.

In the full-attention layers, Instant removes the causal mask and uses bidirectional attention. Earlier input tokens can therefore attend to later question text and candidate options. Linear-attention layers remain causal. This attention modification is applied during training as well as inference, because applying bidirectional attention to a model trained causally can disrupt predictions.

At the 4B and 9B scales, bidirectional attention is applied to 8 of 32 layers. The remaining linear-attention layers and the option-letter readout are unchanged. Controlled comparisons using the same checkpoint and data found gains of up to 2.4 Decision Index points at the evaluated scales. The reported interpretation is that a fixed-prompt decision readout benefits from allowing the input representation to incorporate the semantics of the options it must distinguish.

AutoThink models

AutoThink retains causal attention so that it can generate reasoning traces. It applies a Read-or-Think procedure independently to each question:

1. Run a causal single-pass readout and obtain $p_0$.
2. Return $p_0$ if confidence is high.
3. Otherwise, generate a reasoning trace $\tau$.
4. Obtain a post-reasoning distribution $p_1$.
5. Fuse the initial and post-reasoning distributions.

The default confidence gate is $g=0.9$. Reasoning is invoked when

$z_k$0

The inference-time reasoning trace may contain up to 4,096 tokens. The released fusion rule is

$z_k$1

with

$z_k$2

For routed questions, the final distribution therefore uses 25% of the initial distribution and 75% of the post-reasoning distribution. Retaining the initial distribution mitigates post-reasoning overconfidence. The fusion weight was selected by minimizing held-out Brier score rather than simply maximizing classification accuracy.

In an analysis of 7,800 DecisionPivot items using the 27B model, 39% of questions were answered directly. Direct predictions had approximately 96% accuracy. Reasoning was invoked on the remaining 61%; accuracy for those questions increased from 57% before reasoning to 93% after fusion. Reasoning corrected 1,783 initial errors and introduced 94 new errors. These results support the interpretation that uncertainty is informative of computational difficulty and that reasoning need not be applied universally.

3. Training pipeline and data

StartLux-Decision uses a three-stage training pipeline. The first stage establishes shared probabilistic decision capabilities, the second specializes the Instant and AutoThink variants, and the third equips AutoThink with reasoning through supervised reasoning data and reinforcement learning.

Stage 1: supervised decision training

Stage 1 fine-tunes all language-model parameters, including the output projection, on Lux-Release. The mixture contains reformulated versions of classification, natural-language inference, question answering, safety, preference modeling, tool use, knowledge and commonsense multiple choice, typed-decision datasets, and a smaller number of programmatically generated examples.

The training set contains approximately:

• 2.7 million examples for the 0.8B–9B models
• 0.8 million examples for the 27B model

Candidate options are deterministically permuted to reduce answer-position bias. Parent-group decontamination is used to reduce training and evaluation overlap.

The primary objective is soft cross-entropy over option probabilities:

$z_k$3

where $z_k$4 is the target distribution and $z_k$5 is the model distribution. Temperature fitting is performed separately for each question type after training.

Stage 2: decision specialization

Stage 2 uses approximately 1.7 million examples in Lux-Rounds. It expands coverage through benchmark training splits, related datasets, procedural decisions, select-all questions, teacher-labeled data, API-generated examples, and retained Stage 1 examples.

Adapters are trained with the same probability objective and merged into the model weights. The model variants then diverge:

• Instant adopts bidirectional attention in full-attention layers.
• AutoThink retains causal attention to support autoregressive reasoning.

Instant checkpoints are averages of independently trained runs: three runs at 0.8B and four runs at 2B–27B. Temperatures are refitted after checkpoint averaging.

Stage 3: reasoning supervision

Stage 3 applies only to AutoThink. Decision-oriented fine-tuning can impair ordinary reasoning behavior. Before reasoning supervision, the 4B model produced little or no reasoning on roughly 40% of prompted reasoning cases, while the 9B model frequently generated until the length limit, doing so on roughly 70% of such cases.

AutoThink is therefore trained on Lux-Think, containing approximately 4,000–21,000 supervised reasoning examples per model. Reasoning supervision improves post-reasoning accuracy but does not fully resolve excessive generation or termination failures. RLCD² is subsequently applied to improve the probabilistic value of reasoning while reducing unnecessary trace length.

4. RLCD² and calibrated deliberation

RLCD² rewards reasoning according to how it changes the quality of the complete decision-probability distribution. It does not reward a trace merely because its final argmax answer is correct.

A frozen copy of the reasoning-supervised starting model supplies:

• the initial distribution $z_k$6;
• the post-reasoning distribution $z_k$7.

The trainable policy generates the reasoning trace $z_k$8, while the frozen model evaluates the effect of that trace. Training is restricted to examples satisfying

$z_k$9

matching the AutoThink inference gate. Traces terminating within eight tokens are treated as empty reasoning and receive zero reward.

Proper scoring rules

RLCD² considers three proper scoring rules.

The negative Brier score is

$k$0

The logarithmic score is

$k$1

The released models use a decision-weighted proper score. For an option with reported probability $k$2 and binary correctness $k$3,

$k$4

where

$k$5

The weighting density $k$6 is an equal mixture of a uniform density and a $k$7 density, placing greater emphasis on high-confidence regions. For $k$8 options,

$k$9

For ordered response levels, the score is applied to cumulative probabilities. If the true correctness probability is $$p_k=\frac{\exp(z_k/T)} {\sum_{j=1}^{K}\exp(z_j/T)}, \qquad k=1,\ldots,K,$$0, then

$$p_k=\frac{\exp(z_k/T)} {\sum_{j=1}^{K}\exp(z_j/T)}, \qquad k=1,\ldots,K,$$1

Thus, for nonnegative $$p_k=\frac{\exp(z_k/T)} {\sum_{j=1}^{K}\exp(z_j/T)}, \qquad k=1,\ldots,K,$$2, expected score is maximized at $$p_k=\frac{\exp(z_k/T)} {\sum_{j=1}^{K}\exp(z_j/T)}, \qquad k=1,\ldots,K,$$3; with strictly positive $$p_k=\frac{\exp(z_k/T)} {\sum_{j=1}^{K}\exp(z_j/T)}, \qquad k=1,\ldots,K,$$4, that maximizer is unique. RLCD² consequently optimizes probability quality rather than only classification accuracy.

Reward definition

Let $$p_k=\frac{\exp(z_k/T)} {\sum_{j=1}^{K}\exp(z_j/T)}, \qquad k=1,\ldots,K,$$5 denote the input decision, $$p_k=\frac{\exp(z_k/T)} {\sum_{j=1}^{K}\exp(z_j/T)}, \qquad k=1,\ldots,K,$$6 the reasoning trace, $$p_k=\frac{\exp(z_k/T)} {\sum_{j=1}^{K}\exp(z_j/T)}, \qquad k=1,\ldots,K,$$7 the target distribution, $$p_k=\frac{\exp(z_k/T)} {\sum_{j=1}^{K}\exp(z_j/T)}, \qquad k=1,\ldots,K,$$8 the selected proper score, $$p_k=\frac{\exp(z_k/T)} {\sum_{j=1}^{K}\exp(z_j/T)}, \qquad k=1,\ldots,K,$$9 the trace length, $T>0$0 the soft reasoning budget, and $T>0$1 the length-penalty coefficient. RLCD² defines

$T>0$2

The released configuration uses

$T>0$3

while the hard generation limit is 4,096 tokens. Reasoning beyond 3,072 tokens is permitted but progressively penalized.

Policy optimization

For each prompt, the algorithm samples $T>0$4 traces and centers their rewards within the group. For trace $T>0$5,

$T>0$6

where $T>0$7 is its reward and $T>0$8 is the group mean.

The clipped policy-gradient loss is

$T>0$9

Here $p_0$0 is the current-policy to sampling-policy probability ratio, $p_0$1 is the PPO-style clipping range, $p_0$2 controls reference-policy regularization, and $p_0$3 is the reference policy. The frozen scoring model prevents reward drift and provides a stable comparison between pre- and post-reasoning probability quality.

5. DecisionPivot and empirical evaluation

DecisionPivot benchmark

DecisionPivot is a programmatically verifiable benchmark of computational decisions constructed from contrast pairs. Each pair differs in a single answer-changing detail. This design tests whether a model responds to the decisive change rather than relying on superficial similarities or memorized answer patterns.

AutoThink outperforms its Instant counterparts by 11.5–18.4 points in pair accuracy and leads among evaluated systems. The result supports the use of adaptive reasoning for arithmetic, scheduling, procedural verification, and other decisions in which a small change in the input can alter the correct option.

Decision Index 0.3

On the public subset of Decision Index 0.3, Instant models outperform the strongest evaluated comparable-scale open-weight decision models by 7.4–16.9 points. The 27B AutoThink model reaches 73.4.

These comparisons concern the reported benchmark configurations and evaluated model set. They do not establish universal superiority across all decision tasks, model families, or deployment environments.

Reasoning efficiency

RLCD² raises the share of reasoning traces that terminate within the generation limit by up to 48 percentage points and reduces average reasoning length by up to 65%, while largely preserving decision accuracy. The result is a selective-computation design: confident cases use direct inference, while uncertain cases receive additional computation under an explicit length penalty.

The central efficiency trade-off is therefore between:

• single-pass latency and lower compute, provided by Instant or directly answered AutoThink cases;
• higher reasoning cost, incurred only for AutoThink cases below the confidence threshold;
• calibration and deliberative quality, optimized through probability-aware reward rather than answer-only reward.

6. Deployment, calibration, and limitations

StartLux-Decision is intended for systems in which probabilities control downstream actions. Examples include request routing and escalation, retrieval or evidence assessment, tool-call validation, agent outcome verification, policy interpretation, and arithmetic, scheduling, and procedural decisions.

The models run on vLLM, llama.cpp, and MLX, with quantized variants for lower memory use. Quantization enables lower-memory deployment, although the supplied information does not specify all hardware requirements, throughput measurements, or latency values.

Several properties are directly relevant to deployment:

• Typed probabilities: the output is a distribution over named options rather than an unconstrained textual answer.
• Temperature calibration: probability distributions are adjusted on held-out data, separately for each question type.
• Selective reasoning: AutoThink invokes reasoning only when initial confidence is below the configured threshold.
• Probability fusion: initial and post-reasoning distributions are combined rather than replacing the initial output entirely.
• Soft length control: RLCD² discourages excessively long reasoning without imposing an abrupt cutoff at the soft budget.
• Multiple model scales: the family spans 0.8B to 27B parameters, allowing accuracy–latency–memory trade-offs.
• Image support: contexts may include image inputs through the frozen vision tower.
• Long context: both model variants support contexts up to 262,144 tokens.

The principal limitations concern calibration scope, benchmark coverage, and reasoning reliability. The reported gains are tied to the datasets, option formats, temperatures, confidence gate, fusion weight, and model scales used in the study. A probability distribution calibrated on one question type or deployment population may not remain calibrated under distribution shift. Similarly, the confidence gate $p_0$4 is a decision rule whose usefulness depends on the relationship between confidence and computational difficulty in the target application.

AutoThink reasoning is not guaranteed to improve every case. In the DecisionPivot analysis, reasoning corrected many initial errors but also introduced new errors. The initial distribution is retained partly because post-reasoning probabilities can become overconfident. Reasoning length is controlled by a soft penalty, not eliminated; traces may still approach the 4,096-token hard limit.

The benchmark results also do not establish that a model is safe for autonomous high-stakes decisions. Probability calibration, selective reasoning, and programmatic verification can improve decision-system behavior, but they do not remove risks from ambiguous inputs, incomplete information, adversarial prompts, unsupported assumptions, or systematic dataset bias. Deployment therefore requires task-specific validation, monitoring, abstention or escalation policies, and human review where decision errors are consequential.

StartLux-Decision’s defining contribution is the integration of calibrated single-pass prediction with adaptive deliberation. Instant uses bidirectional attention to improve option-sensitive representations without generating a reasoning trace. AutoThink uses an initial probabilistic readout to decide whether additional computation is warranted, then combines the direct and reasoned predictions. RLCD² trains this deliberation process using proper scoring rules and a soft reasoning-length penalty, rewarding improvements in probability quality rather than only final-answer correctness. The resulting architecture treats reasoning as a selectively allocated computational resource whose value must be measured jointly by accuracy, calibration, latency, and trace length.