A native architecture for typed decisions

JevaSystem One Models from First Principles

Qi Li, Xinchao Wang^*

National University of Singapore
* Corresponding author

The state changes. The alternatives often do not.
Encode independently. Decide collectively. Reuse what stays the same.

Run locally Model weights Paper Evaluation

01 / The decision problem

Four requirements.
One coherent design.

Order should not decide the answer.

Symmetric candidate aggregation makes option probabilities permutation-equivariant.

Permutation invariance

More options, not a new output layer.

A shared scoring rule handles variable candidate counts. Bounded encoding batches keep the complete set available to the decision head.

Option scalability

“None apply” is an answer.

Coverage estimates whether an acceptable option exists, separately from competition among the options.

Null awareness

Unchanged information should be reusable.

Option vectors and their layer-specific projections can be reused across new states and newly assembled sets.

Computational reuse

Above: joint-encoding System One architecture and Jeva. Below: null awareness, candidate-order symmetry, scalable options, and reusable option memory. — Four requirements, one decision architecture. Above: a representative joint-encoding model and Jeva. Below: four schematic views of null awareness, permutation invariance, option scalability, and computational reuse. Vector PDF ↗

Inside the architecture

Three distinctions that matter.

Replacing one candidate changes the refined state and reverses the preference between retained candidates. — Fixed options, set-dependent decisions. A changed alternative shifts the state and reverses the preference between A and B.

Competition and coverage respond differently to score shifts and new candidates. — Competition is not coverage. Relative preference and answer availability capture different properties of a candidate set.

Reuse individual option memories across new states and recombined candidate sets without whole-set cache hits. — New sets, reusable options. Individual memories survive recombination; every state and decision is computed afresh.

02 / Jeva in motion

Encode once.
Read, refine, decide.

Follow one request through independent encoding, candidate-conditioned state refinement, and the typed readout. This animation explains the computation; it is not a recorded model trace.

01 / 04

Encode each option independently. Store its semantic vector and the projected keys and values used by the decision block.

03 / Same semantics, new decisions

A new request is not
a cold start.

Choose a scenario to see what each cache reuses. Every scenario has a new request state; no previous answer is reused. Counts below are exact for this illustrative three-option example, not benchmark timings.

CHANGING REQUEST

“My payment was taken twice.”

CURRENT CANDIDATES

INDEPENDENT OPTION MEMORY

Already cached Needs encoding

Candidate encoding needed
Mode	Options
Cache-Off	3 / 3
Set	3 / 3
Hybrid	3 / 3

Exact-set hit No

Option reuse 0 / 3

Warm scenarios start from the cached tuple [A, B, C]. The implementation keys exact-set entries by the ordered tuple; Hybrid can gather individual memories in any requested order.

04 / Measured behavior

Useful decisions.
Predictable structure.

One decision block with a Qwen3.5-4B backbone. These are measured results from the manuscript—not outputs of the animations above.

78.30%

Typed Test accuracy
2,000 requests

98.66%

Null-detection AUROC
BANKING77 · K = 16

0 flips

Under tested permutations
600 Choice items

2,048

Options in one decision set
ToolRet diagnostic

Four experiments: null detection, candidate-aligned permutation stability, accuracy-latency trade-offs, and cache reuse. — Four structural properties, measured. Null detection on BANKING77 with 16 candidates; order stability on 600 Choice items; supported-request accuracy and latency as candidate counts increase; and cache reuse on Typed Decisions and MLDR. Novel-set priming is timed separately.

Selected comparisons from the paper · accuracy (%) with complete coverage
Model	Typed Test	BANKING77 K = 16	MASSIVE K = 16	Mind2Web Cross-task
Jev-1.13.0	74.10	82.50	81.61	66.26
JevK5 native	62.30	69.03	69.70	51.47
InternDecision-4B	78.70	75.03	75.79	48.02
Re·Flex-4B	58.85	74.38	71.39	52.08
KEV-4B (BF16)	66.00	82.47	73.54	40.32
CLM-8B	43.05	18.15	23.23	21.73
Jeva-4B	78.30	91.62	90.22	79.99

Accuracy includes null where applicable. Gold shades retain the top-three rankings from the paper's full comparison.

Measured typed-output fidelity, null-detection ROC, and candidate-order stability across models. — Typed-output fidelity, null detection, and candidate-order stability. Jeva has zero observed flips; Jev-1.13.0 flips on 17.00% of Choice items and achieves 66.67% all-order accuracy.

ToolRet accuracy, median latency and support across six distinct-query candidate-count cohorts. — Six distinct-query ToolRet cohorts. Full-support accuracy and valid coverage are reported separately; unsupported requests are excluded from accuracy comparisons.

MLDR and Typed Decisions cache ablation: paired speedups, shared-bank latency, and candidate rows avoided. — MLDR: 50 matched queries at each reuse level, with separately timed priming excluded. Typed: 2,000 requests including cold starts. No decisions change.

Correctness for the same 83 queries across nested candidate sets of 32 to 2,048 options: Jeva remains correct at every size on 58 queries, JevK5 on 48, and CLM on 7. — The same queries, larger candidate sets. All-size accuracy requires a correct decision at every tested size: Jeva 69.88%, JevK5 57.83%, CLM 8.43%.

Scalable candidate evaluation. At 2,048 options, Jeva achieves 69.88% accuracy and 12.04 s p50 latency on the ToolRet diagnostic. Encoder batches are bounded; the decision head still sees the entire candidate set.

Reuse across requests. On 2,000 Typed Test requests in 16 shared-bank episodes, p50 latency falls from 93.1 ms (Off) to 46.6 ms (Set) and 46.7 ms (Hybrid), approximately 2× faster. Both cached modes avoid 99.2% of candidate-row encodings. On newly assembled MLDR sets, Hybrid reduces p50 from 2,096.1 to 1,073.6 ms at approximately 50% reuse and from 2,102.0 to 75.1 ms at full reuse (27.98×). These MLDR request timings exclude separately measured priming. All tested decisions are unchanged; no previous answer is cached.

05 / Use Jeva

Your GPU.
A few lines of Python.

Download the checkpoint once. Run directly in your Python process, with LoRA merged in memory and Hybrid option caching. No inference server required.

Install · Linux / NVIDIA / Python 3.12

conda create -n jeva -c nvidia/label/cuda-12.8.1 \
  python=3.12 cuda-nvcc=12.8.93 -y
conda activate jeva
pip install -r requirements.txt
jeva-doctor --check-kernels --strict

Run from the downloaded repository. Model access may require hf auth login. The environment check reports missing GPU kernels explicitly.

One interface · three output types

from jeva import Jeva, Choice, Noul, Score

model = Jeva.from_pretrained("LIQIIIII/Jeva-4B", device="cuda")

r = model.system_one(
    state=(
        "The production login page returns HTTP 503. "
        "All customers are unable to sign in or complete purchases."
    ),
    questions={
        "outage": Noul(
            instructions="Does this report an ongoing service outage?"
        ),
        "team": Choice(
            instructions="Which team should handle this support ticket?",
            criteria={
                "billing": "Payment disputes, invoices, and refunds.",
                "engineering": "Service outages, software errors, and broken features.",
                "general": "All other customer support requests.",
            },
            allow_null=False,
        ),
        "impact": Score(
            instructions="Rate the reported customer impact.",
            criteria=[
                "No customers are affected.",
                "Some customers are affected, but the service remains usable.",
                "All customers are blocked from using a core service.",
            ],
            values=[0, 1, 2],
        ),
    },
)

print("Outage probability:", r.answers["outage"].noul)
print("Assigned team:", r.answers["team"].choice)
print("Team probabilities:", r.answers["team"].probabilities)
print("Impact score (0–2):", r.answers["impact"].score)

Adapt to your own decisions.

A separate fine-tuning entry point accepts your labeled JSONL. Freeze the encoder and adapt the decision module, or continue with LoRA. Explicit validation data and portable checkpoints keep the workflow reproducible.

Fine-tuning guide ↗

06 / Evaluate locally

Your data.
The same decision interface.

Run typed quality, null detection, permutation, and retrieval evaluations on local JSONL records. Candidate order, soft targets, and explicit null outcomes are preserved. Our prepared evaluation datasets will be released separately on Hugging Face.

General decisionsTyped · intent classification · web actions
Structural propertiesNull detection · permutations · cache reuse
Large & long candidatesMany-option selection · long-document decisions

Evaluation guide ↗

Reference

Cite Jeva.

BibTeX · manuscript

@misc{li2026jeva,
  title  = {Jeva: System One Models from First Principles},
  author = {Li, Qi and Wang, Xinchao},
  year   = {2026},
  note   = {Manuscript}
}