Loopscape is the code release accompanying "Fractal basins trap latent reasoning" by Jeffrey Lai, Anthony Bao, John Quinn and William Gilpin of UT Austin, posted to arXiv on 4 September 2026. The paper treats looped, or recurrent-depth, reasoning models as dynamical systems. These models iterate a latent state until it settles on a fixed point, and that fixed point is the answer. The paper's central claim is that on hard problems, the basins of attraction in latent space become fractal. Trajectories then slow down because they get trapped near saddle points, and those saddle points correspond to nearly-correct wrong answers. The authors frame this transient chaos as the reason latent reasoning costs spike unpredictably on difficult inputs.
This matters to builders because looped and adaptive-compute models are a live alternative to scaling chain-of-thought tokens, and their inference cost depends on how many iterations the model needs before it settles. If iteration counts are chaotically sensitive to the initial latent, then compute budgets, early-exit rules and how reproducible a run is all become dynamical questions rather than fixed engineering constants. The newsroom held the item because it rested on a single repository. The question was whether a primary paper and independent evidence exist.
What we checked
- If the mechanism generalizes beyond the reported setting, comparable primary studies should show the same direction under different models or tasks. partly confirmed. Within the paper, fractal basins appear on hard problems across four looped architectures (EqR, FPRM, Parcae, TRM) and several tasks (Sudoku, mazes, Countdown, ARC-AGI-1). However, these are all small fixed-point/recurrent-depth models, and the authors say basin structure differs by model, with some showing resolution-dependent 'slim fractals'. No independent study yet extends the result to other model classes, such as token-level chain-of-thought LLMs. [1][2]
- Do independent reproductions confirm the paper's core fractal claim? partly confirmed. One reproduction matched the EqR Sudoku basin statistic (boundary dimension 1.873 vs. 1.872 upstream). A from-scratch reproduction of the linear-systems experiment found smooth, non-fractal 4×4 basins (D ≈ 1.04) and could not train the paper's 8×8 setting past chance. [3][4]
- Do the fractal basins mostly reflect variation in compute (settling time) rather than variation in correctness? partly confirmed. On one EqR Sudoku slice, 99.92% of 4.2M initial latents reached the correct solution, so the fractal structure was in how long the model ran. Across a 5,565-puzzle scan at native initialization, though, 115 puzzles were never solved and 664 were solved only 15–85% of the time. [3]
What we found
- The primary source exists and is specific. arXiv:2609.04963v1 tests EqR, FPRM, Parcae (140M parameters, fine-tuned on Countdown) and the Tiny Recursive Model on Sudoku-Extreme, 30×30 mazes, Countdown, ARC-AGI-1 and integer linear systems. It reports that basin entropy rises with task difficulty and 'strongly correlates' with iteration count. It also reports that a Fast Lyapunov Indicator 'strongly correlates' with the number of distinct candidate solutions a trajectory visits, but the text gives no correlation coefficients or uncertainty ranges. [1]
- Several models were modified before analysis. EqR's injected noise was switched off, and Parcae was fine-tuned with a smaller integration step (Δt=0.3 instead of 1.0). Basins are measured on randomly oriented 2D slices of the latent space, and slices where fewer than 90% of initial conditions reach the solution are excluded. These choices make the dynamics deterministic and easier to analyze, but they mean the measured systems are not exactly the models as deployed. [1][2]
- The Loopscape repo puts every solver behind one get_solver/solve_batch API, which takes a puzzle and a batch of initial latent states. It ships a notebook that plots basin and settling-time fields. Weights come from upstream projects (locuslab/EqR-model, sandyresearch/parcae) plus the lab's own checkpoints, GilpinLab/parcae-countdown-v1 and a 0.4M-parameter GilpinLab/linsys-gf3. The page lists no license, and a third-party project notes it therefore does not redistribute the upstream code. [2][3]
- In the training experiment, the authors report an abrupt rise in both solvability and basin entropy around 150k training steps on the linear-systems looped transformer. They read this as fractals emerging at the same moment generalization does. Their extracted text renders this number garbled ('150150k'), so the exact step count should be checked against the PDF. [1]
- An independent EqR Sudoku reproduction matched the upstream basin figure statistically: boundary-dimension statistic 1.873 vs. 1.872, with about 64% of pixels matching exactly. It found that 99.92% of about 4.2M initial latents still reached the true solution. Its caveats are that the result covers one puzzle, one checkpoint and one slice. Speckled regions depend on float32 rounding, with only about 26% agreement across implementations, and TF32/bfloat16 runs give visibly different pictures. [3]
- A from-scratch reproduction of the paper's linear-systems figure (Figure 5) disagreed on the central claim. At 4×4 over GF(3), it saw wrong attractors and basin entropy rising during training, but measured a boundary dimension of about 1.04 and concluded the basins are 'NOT a genuine fractal'. At the paper's 8×8 size, training stayed at chance for about 380k steps. The author attributes part of the gap to training details that the paper does not publish. [4]
What it means
If you build or serve looped, adaptive-depth or fixed-point reasoners, treat iteration count as a quantity that can be chaotically sensitive to the initial latent state, especially on hard inputs. In practice, measure the distribution of settling times across random latent initializations instead of relying on one seed. Validate early-exit and halting rules against that distribution. Fix numeric precision: the EqR reproduction shows that float32 vs. TF32/bfloat16 changes the picture. The paper's link between saddle points and nearly-correct answers also suggests a practical diagnostic. Long-running trajectories may be worth restarting from a different initial latent rather than iterating longer, though the paper does not report a tested restart policy.
Do not carry this over to chain-of-thought LLMs, or to 'reasoning models' in general. Every system studied is a small recurrent-depth model analyzed on 2D latent slices, often with noise disabled or the integration step changed. The difficulty-scaling result has not been independently re-measured. The one from-scratch replication of the training-emergence experiment did not find fractality, and the paper reports no effect sizes. Use Loopscape as a diagnostic toolkit, and wait for the 8×8 training details and quantified correlations before building cost models on these claims.
Still open
- What are the actual correlation coefficients and confidence intervals for basin entropy versus iteration count, and for the Fast Lyapunov Indicator versus candidate solutions visited?
- What training details are needed to reproduce the 8×8 GF(3) emergence result, given that an independent attempt stayed at chance?
- Do the fractal basins and difficulty scaling survive with EqR's native noise turned on and with Parcae's original integration step?
- Does any of this carry over to larger models or to token-level chain-of-thought LLMs?