Jeva Rebuilds System One Models Around the Structure of Decisions

Introduction

System One models are meant to make fast, direct decisions. Given a request and a set of alternatives, they should select an option with low latency rather than spend computation generating a long explanation. In practice, however, many systems turn the task into serialized text prediction: the request and all candidates are placed into a sequence, and the model predicts an answer token or text span.

The paper Jeva: System One Models from First Principles argues that this interface can obscure the structure of the underlying decision problem. It introduces Jeva, a decision-native architecture designed around four requirements that should hold even when the candidate set changes.

Four structural requirements

• Null awareness: A model must distinguish “none of the options is correct” from uncertainty among the available options. Jeva uses a separate coverage estimate to support an explicit null outcome.
• Permutation invariance: Reordering candidates should not change the decision. Symmetric aggregation is used so that the output probabilities behave consistently under candidate permutations.
• Option scalability: The output space should not have to be redefined whenever candidates are added or removed. Shared scoring allows the same model to work with variable-size sets.
• Cacheability: Candidate representations that do not depend on the current request should be reusable. This is particularly relevant when the same documents or alternatives appear across many requests.

How Jeva is organized

Jeva uses a shared encoder to represent the request and each option independently. A compact decision stack then updates only the request state while attending to an immutable memory of option representations. This separation is important: it avoids treating the entire candidate list as one arbitrary text sequence and makes the role of each candidate explicit.

The architecture also unifies several output formats, including Choice, Noul, and Score. The supplied paper material reports a 4B model that supports up to 2,048 candidates. Across the tested permutations, it reportedly produced zero decision flips. For long-document candidates that can be fully pre-cached, the authors report more than 20× median-latency speedups.

Why it matters

Jeva’s main contribution is architectural rather than a single new decoding trick. Null handling, order robustness, variable candidate counts, and cache reuse are treated as first-class properties instead of being left to prompts, fixed output heads, or post-processing. That makes the approach potentially relevant to retrieval, routing, ranking, recommendation, and other systems where the request changes frequently but the candidate pool is partly reusable.

There are also limits to what can be concluded from the available material. The summary does not provide the full benchmark breakdown, baseline settings, or detailed real-world evaluations. It therefore cannot establish how Jeva behaves when candidate quality is noisy, semantic reasoning is difficult, or candidate sets become much larger. Those questions require inspection of the complete paper, released code, and independent testing.

Still, Jeva offers a useful reframing: fast decision models need not be treated as small language generators with a list of options appended to the prompt. They can instead be designed around the invariants and computational reuse patterns of decision systems.

Source: Hugging Face Daily Papers