Lev lets a decision model loop more per question: one set of weights covers multiple depths
According to a Machine Heart report dated November 2, 2026, Lehigh and other institutions proposed Lev, a recurrent decision model: it reads option probabilities once per loop, the same weights can answer at different depths, and a stopper decides the loop count per question; on JevBench, Lev-2.6B rises from 63.2% at one loop to 76.2% at four loops.
What changed
According to a Machine Heart report dated November 2, 2026, researchers at Lehigh University, the University of British Columbia and the Vector Institute proposed Lev, a decision model that deepens thinking with recurrence rather than chain-of-thought. It follows the task format of decision models such as Jev and Kev: one request contains a state and several questions with candidate options, and the model directly outputs a probability for each option without generating text. The difference is the base: Lev switches to Ouro or Nanbeige4.2, which have recurrence built in during pretraining. The same set of decoder layers runs repeatedly; after each loop a shared pointer head reads option probabilities once. The pointer head and LoRA adapters are shared across loops, and the loss is averaged over all loops, so the same checkpoint is a usable decision model at every depth. A per-depth logistic-regression stopper decides how many loops each question gets. The authors call this compute pattern System 1.5: the interface still gives a decision directly, but hard questions can spend more compute. The paper presents three models: Lev-1.4B (Ouro-1.4B, up to 4 loops), Lev-2.6B (Ouro-2.6B, 4 loops) and Lev-3B (Nanbeige4.2-3B, 2 loops). Nanbeige was pretrained with loss only on the last loop, and it is used to test whether Lev depends on supervised intermediate loops. On the public 231-question JevBench, Lev-2.6B rises from 63.2% at one loop to 76.2% at four loops, a gain of 13.0 percentage points (95% confidence interval 7.4 to 19.0). The weights do not change; only the loop depth does. The stopper's prediction target is not "whether the answer is correct" but "whether the current answer already agrees with the deepest loop." The threshold is the smallest value that keeps at least 98% of final answers in agreement with the deepest answer, so calibration needs no human labels. The paper, code, three models and three datasets are all public. The report does not say what license the weights use and gives no commercial terms. The report also stresses that Lev is an independent implementation resembling OpenAI Decisions only in task form; it does not reproduce its weights, architecture or API, and was not benchmarked against that product.
What it means for developers
For developers, the change is not parameter count but moving "how deep to compute" from training time to serving time. A single forward pass of a decision model is cheap, but compute is fixed at training, so easy and hard questions cost the same. Chain-of-thought makes hard questions more accurate at the price of paying for reasoning text on every question. In the comparison cited by the report, turning on thinking on the same 26B base improves hard questions by 9 to 13 points, while median latency for hard questions becomes three to four times higher. Lev's approach lets the same weights offer different operating points at different loop counts: the report says on-demand depth used only 76% to 85% of the loop compute of the deepest loop on two held-out test sets, with an accuracy gap of 0.3 to 0.8 points. The boundary of the benefit is concrete too. In floating-point operations, the report says Lev is on par with or worse than dense approaches, because every loop runs the entire base. The advantage shows up in latency, not compute: in the 39 to 46 ms range, on-demand Lev-1.4B and Lev-3B are 7.0 to 8.8 points above cascades at the same latency and 5.4 to 7.5 points above the best dense approach. But Lev-2.6B at about 150 ms is not better than using Kev-4B directly. Depth does not only fix answers: on LevBench, the first extra loop fixes 20.4%, breaks 8.6%, and 12.6% of questions are correct at a shallow loop but wrong at the deepest loop. A stopper targeting agreement with the deepest loop cannot rescue those. Task type matters: language understanding gains 19.0 points, while taste judgments such as humor and color preference show no gain. The authors speculate that extra loops provide the serial computation needed to combine multiple facts, and that taste judgments do not use that computation. This mechanistic explanation has not been independently verified and should not be treated as a confirmed causal conclusion.
Integration and evaluation
The following are conditional recommendations, not reported facts. First, decide whether you need on-demand depth before deciding whether to change models. The reported change is this: relative to the deepest loop, on-demand depth can compute 15% to 24% less. But relative to mixing fixed depths at equal cost, the advantage is small: Lev-2.6B is only 0.2 points higher on held-out sets, and Lev-3B 1.0 point higher. Turning loop savings into online throughput also requires serving-side support for batching and scheduling requests at different depths, which the paper explicitly did not do. If your inference stack cannot yet bucket by depth or exit early, start with a fixed two loops; invest in the stopper only when you genuinely need to reserve tail budget for hard questions and are willing to rework scheduling. The precondition is that padding and scheduling overhead for different loop counts within the same batch is acceptable. A measurable criterion: on your own traffic sample, on-demand depth is no worse than the equal-cost frontier of fixed two loops while the p95 loop count falls by 15% or more; if p95 latency does not improve after the change, the bottleneck is scheduling, not loop count. Second, the stopper threshold must be re-set on your own traffic. The report shows that tuning the threshold on labeled data with correctness as the target makes both Ouro models fall below the fixed-depth frontier. With agreement with the deepest answer as the target and calibration on unlabeled target requests, a simple maximum-probability threshold comes within 0.2 points of the full stopper, with 500 questions per fold. Record outputs at each loop for your own business requests and use agreement with the full-depth answer as the label to choose the threshold; do not copy the paper's threshold. The precondition is that you can run full depth offline; unlabeled does not mean zero cost. The criterion is that on held-out traffic the agreement rate between early-exit answers and full-depth answers is at least 98%; if downstream actions are irreversible, raise that bar and retune the threshold by business loss. Third, before replacing generative reasoning with a decision interface, run a stratified comparison. The report notes that Lev outputs only candidate probabilities and no explanatory text, while turning on thinking adds 9 to 13 points on hard questions but takes several times longer. Tasks such as tool routing, classification and action ranking can first be compared on a small sample along both paths; scenarios that need reasons or auditable traces should keep the generative path. The precondition is that the task can be enumerated into a candidate set. The criterion is that on the same evaluation set accuracy does not fall, p50 latency stays within budget, and the rate of answers changed from right to wrong is tracked separately rather than looking only at the net gain. Fourth, do not bolt recurrence onto a dense base. The report mentions that connecting the middle 8 layers of Qwen3.5-0.8B into a gated recurrence and training with the Kev recipe changed accuracy by less than half a point, with the gates staying near zero. If you want a depth knob, start from a natively recurrent base; if you still want to try, first check whether gate values leave zero and whether the per-loop accuracy curve has a slope. A flat curve means the recurrence is not being used.
Limits and open questions
The paper's recurrent bases cover only 1.4B to 3B, the scale currently publicly available; whether the depth curve holds for larger models is unknown. The JevBench conclusion is based on only 231 public questions. The "less compute" of on-demand depth is an offline count of loop iterations, not online time. The latency numbers come from a single H200, bf16, one request at a time, without fused operators, graph capture or state caching, and without serving optimization, so readings will change in production. The 12.6% "correct at shallow, wrong at deep" shows that more depth is not monotonically better. On licensing, the report only says code, models and data are public; it does not say what license the weights use. Public weights are not the same as an open-source license, so check repository terms before commercial use. Lev-1.4B, Lev-2.6B and Lev-3B are not currently in KimiSeek's model catalog. Model availability in the report refers to the authors' public repositories and weights, not to a KimiSeek launch, and does not mean a vendor API exists. If a hosted service appears later, its availability is subject to that provider. These figures come from the Machine Heart report and the public description of the paper; no independent reproduction or testing was done.