Summary

• Jeva is a novel "decision-native" architecture for system one models that separates reusable semantic encoding from set-dependent judgment, addressing four structural requirements: null-awareness, permutation-invariance, option-scalability, and cacheability.
• The architecture uses a shared language encoder to independently represent the request and each option, followed by a compact decision module that refines only the request state against immutable option memory.
• Key theoretical contributions: Propositions establishing set-dependent preference with a single block (Proposition 1), coverage without a cardinality denominator (Proposition 2), and candidate symmetry with exact reuse (Proposition 3).
• Empirical results: Jeva-4B achieves 78.30% on Typed Decisions, exceeds 90% accuracy on BANKING77 and MASSIVE, achieves near-perfect null detection (98.66% AUROC), zero decision flips under permutation, and scales to 2,048 candidates with over 2× speedup over baselines.
• Efficiency gains: Cross-request reuse delivers median-latency speedups of over 20× for newly assembled long-document candidate sets without changing decisions.

Introduction and Theoretical Foundation

The paper addresses a fundamental limitation in current system one models: predicting answers from serialized text does not respect the structure of decision problems. The authors argue that four structural requirements are underemphasized in current designs:

1. Null-aware: Models should distinguish answer absence from uncertainty among candidates
2. Permutation-invariant: Reordering alternatives should not change the decision
3. Option-scalable: Growing candidate sets should not require redefining the output space
4. Cacheable: Request-independent computation over recurring alternatives should be reusable

The theoretical foundation builds on several key insights:

• Independent scoring limitation: For independent scores $g(x, \iota, o_i)$ normalized by softmax with temperature $\tau > 0$, the log odds satisfy:

$$\log \frac{q_i(\mathcal{O})}{q_j(\mathcal{O})} = \frac{g(x, \iota, o_i) - g(x, \iota, o_j)}{\tau}$$

The shared denominator cancels in the ratio, meaning adding or removing candidates cannot reverse the preference between two retained options.

• Competition vs. coverage: A common score shift leaves conditional probabilities $q$ unchanged, but relative preference alone cannot establish whether any candidate is acceptable. This motivates a separate coverage estimate.

• Set functions and latent attention: Building on Deep Sets (Zaheer et al., 2017), Set Transformer (Lee et al., 2019), and Perceiver (Jaegle et al., 2021), Jeva refines a request-conditioned state against immutable option memory.

Methodology

Architecture Design

Independent Encoding: A request comprises state $x$, question $\iota$, decision type $t$, and candidates $\mathcal{O} := (o_1, \ldots, o_K)$. Two text templates are used: $T_x(t, \iota, x)$ for the request and $T_o(t, o_i)$ for each candidate. The encoding uses:

$$z_0 = P_x E_\theta(T_x(t, \iota, x)), \quad u_i = \mathrm{nrm}(P_o E_\theta(T_o(t, o_i)))$$

where nrm is stabilized $\ell_2$ normalization and $z_0, u_i \in \mathbb{R}^d$.

Candidate-Conditioned State Refinement: Each of $L$ blocks reads the option memory $U$ through $H$ heads. The candidate-weighted message uses attention-like aggregation:

$$a_{\ell i}^h = \frac{\exp((q_\ell^h)^\top k_{\ell i}^h / \tau_\ell)}{\sum_j \exp((q_\ell^h)^\top k_{\ell j}^h / \tau_\ell)}$$

The state undergoes two residual updates:

$$\tilde{z}_\ell = z_\ell + \alpha_\ell m_\ell, \quad z_{\ell+1} = \tilde{z}_\ell + L^{-1/2} F_\ell(\mathrm{RMSNorm}(\tilde{z}_\ell))$$

Coverage and Typed Outputs: Jeva computes final scores $s_i = z_L^\top u_i$ and conditional candidate probabilities $q = \mathrm{softmax}(s/\tau_{dec})$. The coverage estimate is:

$$\rho = \sigma\left(\frac{\max_i s_i - b_{cov}}{\tau_{cov}}\right), \quad p_\perp = 1 - \rho, \quad p_i = \rho q_i$$

This implements $P(Y = i) = P(Y \neq \bot)P(Y = i \mid Y \neq \bot)$, distinguishing answer absence from candidate competition.

Memory and Caching: An atomic option memory stores both semantic vectors and projected views:

$$\mathcal{M}_t(o_i) = (u_i, \{k_{\ell i}^h, v_{\ell i}^h\}_{\ell,h})$$

Training

Jeva-4B uses Qwen3.5-4B with pooled width 2560, decision width $d = 768$, $L = 1$, $H = 8$, and $f = 3072$. Training uses rank-64 LoRA with both projections and the decision head (13.37M parameters). The primary loss is joint cross-entropy on $p$:

$$\ell = \text{BCEWithLogits}(g, c_y) - \sum_i y_i \log q_i$$

Empirical Validation / Results

Decision Quality (Table 1)

Null Detection and Order Stability (Table 2)

Key Results

• Null detection: 98.66% AUROC on BANKING77 with 16 candidates (588 answer-absent), detecting 93.88% of absent answers at 5.02% FPR
• Permutation invariance: Zero flips, mean TV of $3.17 \times 10^{-8}$, identical original and all-order accuracy of 76.67%
• Candidate scaling: At K=2048, Jeva achieves 69.88% accuracy vs. JevK5's 67.47%, with 7.85× latency improvement from length-aware batching
• Reuse efficiency: Full reuse gives 27.86× median paired speedup; hybrid cache avoids 99.2% of candidate-row encodings

Theoretical and Practical Implications

Theoretical contributions:

1. Set-dependent expressivity (Proposition 1): A single Jeva block can reverse preferences between two retained options when the surrounding set changes, which no independent scorer can achieve. This proves that reusable features do not imply independent decisions.

2. Coverage without cardinality denominator (Proposition 2): Adding options below the existing maximum leaves $\rho$ unchanged, whereas flat softmax assigns null probability that depends on candidate count K:

$$p_\perp^{flat} = \sigma((b_0 - s)/\tau - \log K)$$

3. Symmetry and exact reuse (Proposition 3): Permuting candidates permutes candidate probabilities but leaves state, null probability, and typed outputs unchanged. Cached entries produce identical outputs.

Practical implications:

• Architecture design: The separation of semantic representation, candidate interaction, and answer availability provides a blueprint for decision-native architectures
• Efficiency: The cacheable option representations enable substantial latency reductions for tool registries, document collections, and label vocabularies that persist across requests
• Scalability: Linear complexity in candidate count with prepared memory supports thousands of candidates in a single forward pass

Conclusion

Jeva introduces a native architecture specifically designed for system one decision making, modeling decisions as an evolving state that reads reusable option memory. The architecture unifies permutation symmetry, variable candidate counts, explicit null probability, and caching through its design.

The trained Jeva-4B combines broad decision capability with strong null detection, stable predictions under reordering, and savings from hybrid cache. Large-set results demonstrate the practical value of candidate-indexed readout, achieving both higher accuracy and significant speedups over recursive-selection baselines.

Future directions could include extending the architecture to more complex decision structures, exploring larger backbone models, and investigating additional types of reusable computation across requests.