System 1.5 decision models

Lev: Thinking fast
and deep.

with looped decision models

One checkpoint, multiple depth operating points.
More computation through loops in hidden space.

Real dataset inputEasy · Social IQa

What will happen to Robin?

Context Cameron picked Robin up from the airport.

A
got Robin seasick
B
got into Cameron's automobile
C
got lost looking for Cameron

Social IQa · validation #1407 · LevBench development · CC-BY-4.0

Correct: B — got into Cameron’s automobile. The stopper clears τ after one loop.

Autoplay · choose a case to keep it selected.

Source & recorded trace ↗

Inside a decision

An answer at every loop.

Easy · 01 / 04

Stopper g_k predicts whether this answer matches the deepest one.Stop if g_k ≥ τ · fitted τ = 92.25%

01
F_θ

0.8%A
97.1%B
2.1%C

Stopper g₁p¹ 95.64% ≥ 92.25%
Select B
Yes No
02
F_θ

—A
—B
—C

Stopper g₂p¹, p² —
Not needed
Yes No
03
F_θ

—A
—B
—C

Stopper g₃p², p³ —
Not needed
Yes No
04
F_θ

—A
—B
—C

Depth limitNo stopper —
Not needed
Exit

Easy · Loop 1 · Select B. Correct dataset answer; three loops skipped.

Recorded Lev-2.6B · LevBench development. Reconstructed stopper. Source & method ↗

Dingjie Song^1,*Zhiling Yan^1,*Yuxuan Zhang^2,3Lichao Sun^1,†

¹ Lehigh University² University of British Columbia³ Vector Institute

* Equal contribution † Corresponding author

01 / The ideaDepth is a choice.

A fast answer.
A deeper answer.
The same model.

TL;DR Lev turns a natively looped language model into a decision model that can answer at several depths from one checkpoint.

A shared pointer head scores the options after every loop step. Training all steps together makes each readout useful. Choose a fixed depth to match your compute budget, or let an agreement-based stopper choose per question using unlabelled requests.

Its output is a probability for each option. Extra computation happens in hidden states, without decoding a chain of reasoning.

Explore the measured depth curve

Same 2.6B weights.
Four operating points.

Choose a depth to see the reported JevBench result for Lev-2.6B.

63.2%JevBench accuracy

25%of the four-loop cost

Reported measurements, not live inference.
231 public items · accuracy measured in fp32.

One checkpoint · all depths trained jointly

Source: main results table and JevBench appendix.
Fixed depth k uses k/4 of the four-loop step cost.

02 / How it worksRead. Loop. Decide.

Think in loops.

A shared decoder stack and readout.
An answer available after every step.

Lev method: a packed state and questions pass through the same decoder stack at each loop. A shared pointer head reads option scores. A stopper predicts agreement with the deepest answer; a shared state runs to the deepest exit of its questions. — From the paper / Method Drawn for four loops. Each question can exit at its own depth; the shared state runs as deep as its deepest question. View original PDF

01
Train every depth.

Start with Ouro or Nanbeige4.2. Share the LoRA adapter and pointer head across loop steps, and average their training losses.
02
Read after each loop.

Return one probability per option. A further loop continues from the previous hidden state, using the same parameters.
03
Choose when to stop.

Use a fixed depth, or predict agreement with the deepest answer. Fit the stopper and its threshold on unlabelled requests.

03 / EvidenceWhat the experiments show

More depth.
More room to decide.

+13.0 accuracy points

Depth improves the same checkpoint.

Lev-2.6B rises from 63.2% at depth one to 76.2% at depth four on the 231 public JevBench items. Most of the gain comes from standard and hard questions.

Main results table; Analysis, RQ1.

15–24% less loop computation

On-demand depth saves compute.

On the pooled held-out development panels, the three models use 76–85% of the deepest-pass cost while losing 0.3–0.8 accuracy points.

Appendix, “On-demand depth,” pooled development rows. Cost is token-weighted across packed requests; this is not a measured serving speedup.

+5.4 / +7.5 accuracy points

Small models cover a useful latency range.

On locked LevBench test, on-demand Lev-1.4B and Lev-3B exceed the best dense model or cascade at the same estimated mean latency: 46 ms and 39 ms, respectively.

Analysis, RQ4; cascade appendix. Single H200, bf16, one request at a time. Request latencies are priced by fits to measured development timings, without fused kernels or graph capture.

Figure 1: on-demand Lev-2.6B spends more loop steps on harder JevBench tiers. Small Lev models improve the locked LevBench test latency frontier. Depth raises standard and hard JevBench accuracy. — From the paper / Figure 1 Top: steps by JevBench difficulty. Bottom left: locked LevBench test accuracy versus latency. Bottom right: standard and hard JevBench accuracy. View original PDF

See all three checkpoints on public JevBench

Accuracy (%) on 231 public items. Each row uses one checkpoint.
Model	Backbone	Depth 1	Depth 2	Depth 3	Depth 4
Lev-1.4B	Ouro-1.4B	58.0	65.4	68.0	68.0
Lev-2.6B	Ouro-2.6B	63.2	71.0	75.3	76.2
Lev-3B	Nanbeige4.2-3B	69.3	72.7	—	—

Source: paper main results table. The main Lev-3B checkpoint uses two loops.

Scope & limitations

Where the gains
do—and don’t—hold.

Extra depth helps most on harder questions. Easy JevBench questions are nearly solved already. More steps can also change a correct answer into an incorrect one; agreement with the deepest answer is not a guarantee of correctness.

Adaptive depth is a second, conditional benefit. On locked test, Lev-1.4B and Lev-3B beat their fixed-depth frontiers. Lev-2.6B does not establish a statistically significant gain over its frontier.

Latency depends on the implementation. The low-latency advantage partly reflects gaps in the dense models tested. At matched floating-point operations on development data, Lev is at or below the dense alternatives. Optimised adaptive batching and end-to-end serving remain future work.

The study covers three backbones from 1.4B to 3B and 231 public JevBench items. See the paper’s Analysis and Limitations for the full scope.

04 / ResourcesPaper · code · models · data

Follow the research.

Read the paper, browse the code, and download the models and data. Every resource below is public.

Paper status

Lev: Thinking Fast and Deep with Looped Decision Models

Read and discuss the paper on alphaXiv, or download the PDF. The arXiv link will be added once the listing is announced.

Read on alphaXiv ↗ · Download PDF ↗ · Cite ↓

Paper

The manuscript and full experimental results.On alphaXiv · PDF hosted on this page · arXiv listing to follow.

PaperalphaXiv ↗

Code

Training, depth readouts, analysis, and reproduction.OpenLAIR/lev · Apache-2.0.

CodeOpen ↗

Models

Lev-1.4B, Lev-2.6B, and Lev-3B.Seed-0 checkpoints in the Lev Hugging Face collection.

ModelsOpen ↗

Benchmark

LevBench subset filtered by source redistribution terms, with reconstruction recipes.This is not the full original benchmark. Obtain excluded sources lawfully under their own terms.

LevBenchOpen ↗

Training

Lev-train-v2 subset filtered by source redistribution terms, plus training-data recipes.The full original training mixture is not downloadable here; remaining sources require lawful local acquisition.

Lev-train-v2Open ↗

Results

Results and reproduction materials without source question or training-example text.Lev-results contains no original benchmark questions or training examples.

Lev-resultsOpen ↗

Build on this work

Citation

@misc{song2026lev,
  title        = {Lev: Thinking Fast and Deep with Looped Decision Models},
  author       = {Song, Dingjie and Yan, Zhiling and Zhang, Yuxuan and Sun, Lichao},
  year         = {2026},
  howpublished = {alphaXiv},
  url          = {https://www.alphaxiv.org/abs/2610.lev-looped-decision-models}
}

The arXiv identifier will be added once the listing is announced.

Lev: Thinking fast and deep.

What will happen to Robin?

An answer at every loop.

A fast answer.A deeper answer.The same model.

Same 2.6B weights.Four operating points.