These days, more of what we ask language models to do is "make a decision" than "write something." Is this message spam? Does this case comply with policy? Of the four options, which one does the document point to? Typed decision models exist for exactly this kind of work. The caller fixes the choices (spam/legitimate, say), and the model returns nothing but a probability for each one — no prose. There's no answer to parse out of a wall of text, so it's fast and clean. And increasingly, those probabilities are what decide whether something gets auto-accepted, routed, or escalated to a human.
The catch is that this computation always gives every decision the same amount of "thought." That's plenty for catching spam, but not enough for judgments that chain several steps together. The paper offers a concrete example. "Omar is honest. Bert says Omar tells the truth. Ben says Bert is lying." Whether Ben tells the truth only falls out if you walk the sentences one at a time. On chains like this, a commercial decision API's accuracy slides from 100% at one step to 62.5% at three steps, and from six steps on it's no better than a coin flip (50%).
When one pass wasn't enough, there used to be two roads. Use a bigger model (which means more parameters — the number of values a model holds — and more memory), or have it spell its thinking out in words (which costs more tokens and time, and breaks the "returns only probabilities" promise). SanSi takes a third road: feeding the same neural-network layers their own output, over and over. It generates not a single token, adds no parameters, and rewrites only its internal state. Between the snap-answer intuition of System 1 and the write-it-out reasoning of System 2 sits a third way — "rewriting a thought" entirely in your head, with no words — and that's System 1.5. This piece follows how far that "think once more" pays off, and where it turns into a trap.
The headline first: pitted against a structure-matched non-looping baseline, the looping SanSi comes out 13.5 points ahead (72.0% vs. 58.4%, across 10,027 decisions). The design is simple. You bundle 24 core layers into one block and feed that block's output back as its input up to eight times. It's like writing a draft and then reworking it with the same pen, again and again. It's never shown the original problem a second time; it only takes the thought it just tidied up and refines it further. Eight passes through the layers means eight times the computation — but not one extra memorized value.
To tell whether that 13.5 points is really "thanks to the loop," you have to pick your comparison carefully. SanSi is built on a language model pretrained to loop, and the non-looping baseline is SmolLM2-1.7B, matched on layer count, hidden dimension, and fine-tuning setup. The two don't share a parameter count or a pretrained base, though — they're not "perfect twins differing only in whether they loop." So the authors check one more thing. A version of SanSi's backbone run through just once, no looping, scored 58.6% — effectively tied with the non-looping baseline (58.4%). Same backbone, loop switched off, and it drops to baseline level — which means the 13.5 points comes from the loop, not the backbone.
But this gain doesn't show up evenly everywhere. On classification problems you can settle at a glance, it's a mere +3.1 points. It grows on problems that require weaving several pieces of information together, and it's largest — +17.6 points — on knowledge questions the model never saw during training. The further from the training data, the bigger the gain. Which makes sense. A problem that System 1 intuition solves instantly has nothing to "think over" in the first place. It's only on the hard problems, where intuition stalls, that the 1.5 reconsideration finally earns its keep.
A task built with difficulty tightly controlled shows this most cleanly. On liar chains generated programmatically so each item requires an exact number of steps, training only showed up to eight steps. On the 9-to-16-step range, outside what it was trained on, SanSi got 72.6% right. A single-pass model with three times the parameters stalled at chance — 50.0% — on the same problems. The loop reached a depth that tripling the parameters couldn't.
The deeper it thinks, the better the score. But almost all of the climb is packed into the first two or three passes. The name SanSi seems to have known this all along. It comes from the Analects — 三思, "think three times" — yet Confucius, told that Ji Wenzi thought three times before acting, replied that "twice is enough." The data sided with Confucius. The second loop alone brings in 62% of the total gain, and through the third you've collected 88%.
After that, it's close to a losing trade. Measured against loop 1, loop 8 flipped 21.0% of all answerable questions from wrong to right — but it also flipped 7.3% of them the other way, from right to wrong. Past five passes, it breaks as much as it fixes — a stretch where it keeps changing answers without making them any better.
The cost is exactly where this splits. Eight passes costs 7.7 times the GPU time of one. Three passes costs 2.9 times. Once 2.9x has bought you 88%, there's plainly a stretch where you pay more than double again for the remaining 12%.
But thinking deeper doesn't make it any humbler. If anything, it only grows more certain. The more it loops, the more confident the model gets about its right answers and its wrong ones alike. Confidence on both rises in lockstep, so the gap between being right and being wrong barely moves. It gets more accurate and more self-assured, while its ability to "know when it's wrong" stays put. So the measure of how far its confidence drifts from its actual hit rate — the metric for over-assigning confidence (ECE) — was best at loop 3 (0.082), then crept back up to 0.093 by loop 8 as certainty kept climbing even after the answers were settled.
The loop has nothing like System 2's process of laying out each piece of evidence and checking the work. So the 1.5 reconsideration, after refining a judgment for a while, eventually falls into a trap where it just piles more confidence onto the same judgment. Look at accuracy alone and the later loops all hover around 72%, hard to single any one out as best — but if you're going to trust the probabilities to run something automatically, that's why loop 3, with the best calibration, is the sweet spot.
Here a sharp signal emerges. When an answer settles tells you how much to trust it. Answers that never changed once, start to finish, were right 82.2% of the time. Answers that only settled as late as loop 8 were right just 35.6% of the time. The later a decision settles, the less you can trust it.
One ability did improve: resisting a forced answer when there's no basis for one. On items where the key evidence had been deliberately removed, more looping cut the rate at which the model reached for an answer anyway from 27.1% to 17.5%. Even as confidence inflated across the board, it got better at spotting when the basis was missing entirely.
A good share of the judgments ONTLE's AI PM makes are exactly these typed decisions. Let's follow one scene all the way through. A client asks to "move the deadline up by two weeks." The AI PM has to decide: push it through as in-progress, escalate it to "awaiting decision" for a human to weigh in, or close it as a request that can't be met. Fixed choices, and what's needed is a judgment rather than prose — a typed decision through and through.
From there, the findings above turn into concrete operating rules for this scene.
First, match the budget to the request's difficulty. "Just change the logo color" and "does this deadline clash with the existing contract and production schedule" carry different weight. Finish the former in a loop or two; run the latter deeper. Spend the maximum loop count on every request alike and you just leak cost on the easy ones.
Second, when the basis is missing, escalate instead of inventing. Whether a deadline can move up is something you only know with the production schedule as a basis. If, lacking that basis, the model leans toward "I don't know" rather than manufacturing a forced go-ahead, then escalating to "awaiting decision" and asking the client back for the production schedule is the right move. On top of that, since it never spits out its internal reasoning as text, there's no way for internal terms like analysis or design to leak onto the customer's screen.
Third, set the probability threshold for auto-proceeding at loop 3, not loop 8 — because the later loops barely move accuracy while inflating confidence. And keep "did the answer settle late" as a secondary signal: a go-ahead decision that only settled at the last minute gets pulled from automatic execution and routed into the human-review lane. The trust gap between early-settled and late-settled answers from the previous section is what justifies this branch. In the end, the judgment ONTLE watches comes down to one thing — on which loop did this decision settle?
What the loop can't do is clear too. Even eight loops fall 1.8 points short of a model with three times the parameters. The remaining gap sits not in multi-step reasoning but in knowledge questions and ambiguous evidence. The reason is simple. The loop lifts "how well you use the knowledge you have," but it can't change "how much you've stored." So if knowledge volume is the bottleneck, look to a bigger model, not the loop.
Two more things worth flagging. One: this evaluation is all English public datasets. Whether properties like "the harder it is, the bigger the gain" or "calibration is best around loop 3" reproduce at the same magnitude on Korean or your own domain data isn't something this paper alone can settle. Measure it on your own data before adopting it. Two: even the nice "recognizes when there's no basis" property is a result on public items labeled "unanswerable." Whether it covers the real gray zone of practice — cases where the basis is ambiguously thin — is something you'll have to check separately.
Finally, the authors are explicit that they propose no stopping rule for when to halt the loop. How many passes to run is still for the user to decide. So this piece's heading, "three times is enough," isn't a conclusion — it's the starting point for a line you'll have to redraw on your own data.
SanSi emits an answer at the end of every loop. So if you run all eight passes through to the end, you get everything from "the answer after thinking once" to "the answer after thinking eight times" in one shot. One caveat, though: running all eight and then picking an earlier answer doesn't save you any computation — you already ran eight, so the cost is a full eight passes. To save compute budget, you have to actually stop execution at that loop. In other words, when budget is tight you cut off at an earlier loop and stop there; when you have room you run deeper — one model tuning its own budget, with no need for several.
No. The weights of the backbone, already pretrained to loop, are frozen wholesale, and you fine-tune only a small component on top. It's a lightweight technique (LoRA) that swaps in a small part without touching the backbone, adding just 61 million values. It's done in 1,000 steps of 16 items each. The training being this light is the approach's practical advantage.
On accuracy alone, no. A commercial decision API the authors couldn't fold into the comparison scored highest overall at 78.9%. But that API's size and training data aren't public, so it couldn't go into a controlled comparison measuring "what the loop adds under equal conditions." This paper's contribution isn't the top score — it's cleanly isolating exactly how much the loop adds.
Yes. When a generative model was trained without ground-truth labels, using this decision model as the sole grader (the reward), the generative model's performance score (F1, which weighs precision and recall together) rose from 39.5 to 47.3, up 7.7 points. A sign that a well-calibrated decision model makes a serviceable judge in its own right.