acceptodds
Under review as a conference paper at ICLR 2027

Flow Reasoning Models: Turning Flows Into Efficient Recurrent Reasoners

Abstract

Structured reasoning requires making and revising interdependent decisions to reach a globally consistent solution. Existing architectures struggle with this: autoregressive models cannot revise emitted tokens, while masked diffusion models require careful decoding schemes to coordinate interdependent predictions. We introduce Flow Reasoning Models (FRMs), a novel framework for structured reasoning that adapts continuous flows over discrete structured outputs with a simple recurrent refinement mechanism. By self-conditioning a flow model on its own past outputs, we turn one-shot denoising into iterative solution refinement. This lets FRMs make and revise decisions in parallel, so interdependent decisions are updated jointly. Yet conventional self-conditioning becomes unreliable at greater recurrent depth due to exposure bias between one-step training predictions and recursively generated inference states. We address this mismatch with Fixed-Point Forcing (FPF), which trains FRMs on states produced by their own inference dynamics while preserving the standard flow-matching objective. FRMs achieve solve rates of , , and on Sudoku-Extreme, Zebra, and Maze-Unique, respectively. On Sudoku-Extreme, FRMs achieve higher solve rates than the evaluated masked-diffusion and specialized reasoning baselines while remaining highly compute-efficient, matching EqR's full-test solve rate with approximately fewer inference FLOPs.

Primary area:
generative models
Keywords:
Flows, reasoning, looped models, recurrent networks

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_5vBQOpenReview ↗
Rating
2(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper uses a recurrent self conditioning technique in order to improve performance in reasoning tasks such as sudoku, zebra or maze. In their sampling algorithm, using a fixed time point with only iteration noising and denoising improve performance drastically. They also use a stopping criterion which uses the differences of the probabilities between updates. They claim that their algorithm promotes a fixed point iteration and show empirically, that when the change of probabilities is low, the chance of predicting the correct token is high.

Critical strengths

The idea is interesting, addresses an important problem, and improves performance compared to the vanilla algorithm strongly. There are many informative experiments presented which illustrate their claims.

Critical weaknesses
  • There is a bit of theory missing, which would motivate further, why the algorithm should be "fixed point forcing".
  • Their performance gains are mainly only existent, when they use fixed time sampling with stochastic renoising. Although this is mentioned in the main text, the reasons for that are underexplored.
  • some of their contribution claims are a bit too strong for the given evidence.
Questions for authors
  • Figure 6c already gives a hint on that correct predictions may be critical points. Did you do/can you do experiments using your trained models, that really show empirically, that correct predictions are attractive critical points and that incorrect predictions are instable? Currently Figure 1A is a strong claim, which should be backed by either more precise experiments or theory.
  • The best performing sampling method is for fixed time τ\tau and with stochastic renoising. How much does this contribute to escaping unstable predictions?
  • Is there some reason why the fixed time τ\tau is so important for the sampling performance?
  • The sampling procedures should be specified more explicitely in the appendix, especially given that no code was provided.
  • In the appendix A2, how long was the pure self conditioning model trained? only 100k, or did it match the 275k of the FRM?
  • It is reported, that there was additional training just for the time point τ=0.4\tau=0.4 which was also used for fixed time sampling. How good is the performance for fixed point sampling without this additional training?
  • In section 3.1 the training/samping mismatch for xt,sx_t,s are discussed. It should be made more clear that only the ss mismatch is addressed later, since for the training update, still xtx_t is used if i understand correctly.
  • Where in the paper is the claim "We discover that exposure bias can cause these models to converge to spurious fixed points." addressed exactly?
  • it should be made clear that the claim "FPF mitigates this mismatch by training on rollout-derived conditioning states, making additional recurrent depth productive and convergence predictive of correctness." is backed empirically, not theoretically.
  • in general the name "Fixed-Point Forcing" is a bit strong without further evidence.
  • it should be noted more clearly in the main text, that the performance depends a lot on the chosen fixed time τ\tau, and that the model had substantially extra training for that time. The best would be to report also performance without extra training for that time point. In general I find the paper interesting, and I'm of course willing to raise my score if my questions are sufficiently addressed.
7 comments

We thank the reviewers for their thoughtful feedback, and are glad they recognize that FRMs deliver:

  1. Large, carefully accounted gains in accuracy and inference efficiency (wkK8, 1Psy, 5vBQ), matching purpose-built recurrent reasoners with roughly two orders of magnitude less inference compute (wkK8).
  2. A simple, well-diagnosed fix with a large and consistent effect (wkK8, 1Psy) that is likely to be useful beyond these puzzles (wkK8).
  3. An interesting idea addressing an important problem (5vBQ), supported by many informative experiments (5vBQ, 1Psy).

In response to your specific suggestions, we made these core clarifications:

  • (A) Tested the fixed-point attractor picture directly. At perturbation strength 0.3, self-conditioning returned to its original wrong Sudoku grid 96.5% of the time. From the same starting grids, FPF recovered the correct solution about 95% of the time (Fig. 6a).
  • (B) Tested the role of rollout-derived carries. With one supervised prediction per rollout, increasing training rollout depth from one to eight steps raises solve rate from 7.2% to 98.0% (Fig. 9).
  • (C) Evaluated every method under multiple samplers, finding that FPF outperforms both baselines on all three tasks, and added a held-time sensitivity analysis for each task.
  • (D) Added comparisons at matched optimizer steps, which show that uniform-time FPF alone achieves the reported accuracy, and clarify that additional training at the held time improves inference efficiency.

We hope that if our clarifications resolve the reviewers primary concerns that they would consider raising their score.


A. Testing the fixed-point attractor picture

Currently Figure 1A is a strong claim, which should be backed by either more precise experiments or theory.

We agree that this perspective should be backed directly, and we now test it empirically from two directions: whether wrong and correct states attract the model back after perturbation (Fig. 6a), and whether the model converges on them (Fig. 6b, c).

Did you do/can you do experiments using your trained models, that really show empirically, that correct predictions are attractive critical points and that incorrect predictions are instable?

Yes. On the same perturbed starting grids, self-conditioning usually recovers its original wrong answer, while FPF usually recovers the correct answer.

To test the behavior depicted in Fig. 1A, we perturbed wrong Sudoku grids on which self-conditioning had converged, then asked both models to re-solve the same puzzles (Sec. 4.3, Fig. 6a). At perturbation strength 0.3, self-conditioning returned to its original wrong grid 96.5% of the time. FPF returned to that grid at most 0.1% of the time and recovered the correct solution about 95% of the time. Starting from correct solutions, FPF returns to them 95% of the time even at strength 0.9, compared with 28% for self-conditioning.

Where in the paper is the claim "We discover that exposure bias can cause these models to converge to spurious fixed points." addressed exactly?

We revised the manuscript to highlight this result: Sec. 4.3 and the new Fig. 6b,c document the spurious convergence, and the introduction's claim now points there. We measure convergence by thresholding the mean change between consecutive predictions over the final 64 steps. On 1,024 Sudoku-Extreme puzzles, 81% of the solutions meeting this criterion under conventional self-conditioning were wrong. Under FPF, every solution meeting it was correct.

Our evidence for the role of exposure bias comes from changing which carries the model sees during training. With supervision held at one state per rollout, increasing training rollout length from one to eight steps raises solve rate from 7.2% to 98.0% (App. Fig. 9). This supports our interpretation that training on one-pass carries leaves the model poorly prepared to correct errors along its recurrent trajectories.

B. The role of rollout-derived carries, and the name

There is a bit of theory missing, which would motivate further, why the algorithm should be "fixed point forcing". [...] in general the name "Fixed-Point Forcing" is a bit strong without further evidence.

The name describes the behavior the objective encourages. For each sampled rollout carry, the supervised target is the same puzzle solution x1x_1. This trains the model to correct erroneous predictions and preserve correct ones on the sampled input–carry pairs. Figure 6 tests whether that behavior persists under repeated denoising and re-noising.

In section 3.1 the training/samping mismatch for xt,sx_t, s are discussed. It should be made more clear that only the ss mismatch is addressed later, since for the training update, still xtx_t is used if i understand correctly.

Yes. FPF targets the carry-side mismatch. At each supervised step, the noisy input xtx_t still comes from the ground-truth interpolant, while the carry comes from a detached model rollout. Training therefore exposes the denoiser to errors that develop over multiple recurrent steps.

it should be made clear that the claim "FPF mitigates this mismatch by training on rollout-derived conditioning states, making additional recurrent depth productive and convergence predictive of correctness." is backed empirically, not theoretically.

We revised the introduction and Sec. 4.3 to describe this as an empirical interpretation.

C. Samplers and held time

Their performance gains are mainly only existent, when they use fixed time sampling with stochastic renoising. [...]

We realize the original submission did not make this clear. FPF's gains hold under Euler, annealed SDE and fixed-time sampling with fresh noise, on every task: FPF reaches 49.5% with Euler and 90.1% with annealed SDE, compared with 40.7% for the strongest baseline at its best sampler, and fixed-time sampling saturates Sudoku-Extreme (App. Table 5).

[...] How much does this contribute to escaping unstable predictions?

Adding fresh noise at each step is essential. At held t=0.4t = 0.4 and the same 8,192 model evaluations, FPF solves 7.6% of Sudoku puzzles when it reuses one noise draw and 99.7% when it draws fresh noise at each step (Table 5).

Is there some reason why the fixed time τ\tau is so important for the sampling performance?

Holding the noise level at an intermediate value, instead of annealing it to zero, lets every update still revise the prediction. The intermediate Sudoku optimum is consistent with retaining enough of the current grid to refine it while injecting enough noise to revise errors. Additional updates therefore keep helping as long as the correct solution is the attracting state, which is what FPF provides (A above).

it should be noted more clearly in the main text, that the performance depends a lot on the chosen fixed time τ\tau, and that the model had substantially extra training for that time. [...]

The extra training is not needed for accuracy (D below). Performance does depend on the held time for Sudoku-Extreme, which works best in a band around t=0.4t = 0.4, while Zebra and Maze-Unique are robust over a broad range (App. B.2, Fig. 8).

The sampling procedures should be specified more explicitely in the appendix, especially given that no code was provided.

We now give the update as Eq. 4 in the main text, with an algorithm block and per-task hyperparameters in App. B.

D. Comparisons at matched optimizer steps

In the appendix A2, how long was the pure self conditioning model trained? only 100k, or did it match the 275k of the FRM?

Originally 100K steps. We now train every method from scratch for 275K steps and report final checkpoints: FPF still reaches 99.7%, versus 40.7% for the base flow and 33.7% for self-conditioning (App. Table 5). This matches optimizer steps across recipes. FPF uses additional rollout evaluations and, by default, additional supervised predictions.

[...] How good is the performance for fixed point sampling without this additional training?

Without Stage C, fixed-time sampling solves 99.7% of Sudoku-Extreme puzzles in the single-trajectory evaluation, compared with 99.5% with Stage C at matched optimizer steps. On Sudoku-Lite with restarts, both recipes reach 99.89%, while Stage C reduces mean inference compute from 2.52 to 0.83 TFLOPs per puzzle (App. A.2).

I thank the author for their answers and think that the paper improved, especially Figure 6 is helpful. I have some additional questions:

  • In table 6, for the fixed time t training, do you still sample tk∈(0,t)t_k\in(0,t) uniformely? so the network technically sees also earlier time steps?
  • Using only a fixed time point for sampling does only work, if for every clue there is a unique solution, is that right? If yes that should be made clear.
  • Are the converging to a fixed point arguments also true for multiple possible solutions?
Reviewer_wkK8OpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper applies continuous flows over one-hot solution encodings to structured reasoning tasks (Sudoku-Extreme, Zebra puzzles, Maze-Unique). Its starting point is a Flow-Language-Model-style denoiser trained with a clean-target cross-entropy on a Gaussian-to-one-hot linear interpolant. Self-conditioning serves as an explicit recurrent state: the denoiser’s clean prediction (the “carry”) is fed back at the next evaluation, so every intermediate state decodes to a candidate solution (Flow Reasoning Models, FRMs). The authors argue that conventional self-conditioning, whose carry comes from a single preliminary pass during training, suffers from exposure bias at large recurrent depth and converges to confident but wrong fixed points. Fixed-Point Forcing (FPF) instead runs a short gradient-free self-conditioned rollout (K=16K=16 Euler steps) and conditions loss-bearing predictions at canonical interpolants on the resulting detached carries; the flow-matching path and loss are unchanged. At inference the denoiser is iterated at a fixed noise level (t=0.4t=0.4 on Sudoku). The distance between successive predictions is used to stop converged trajectories and to restart unconverged ones from fresh noise. The paper reports 99.91% on the full 422,786-puzzle Sudoku-Extreme test set with a 7M-parameter model trained on 1,000 puzzles, 99.98% on Zebra, and 100% on Maze-Unique. It also reports a three-seed training ablation (base flow / self-conditioning / FPF: 13.1 / 32.6 / 99.7% on Sudoku), diagnostics as a function of depth, and accuracy–compute frontiers under a common FLOP count, including matching EqR’s 99.79% with about 51×51\times fewer inference FLOPs.

Critical strengths
  1. Large, carefully accounted gains in accuracy and inference efficiency. The model is a 7M-parameter non-causal DiT trained on 1,000 Sudoku puzzles (App. A.1, Table 3). The full system solves 422,392 of the 422,786 Sudoku-Extreme test puzzles (99.91%, App. B.1), 99,984 of 100,000 Zebra puzzles, and all 1,000 Maze-Unique mazes (Sec. 4.1, Table 1). FLOPs are charged for every learned-model call, including restarts (App. A.4, B.1). The efficiency advantage does not depend on the headline 51×51\times figure: on the same 2,048 Sudoku-Lite puzzles and under the same FLOP counter, FRM reaches 99.9% at 1.02 TFLOPs per puzzle, while EqR reaches 99.2% at 210.0 TFLOPs (Table 4). This is consequential because it shows that a standard flow model, given the right training signal and sampler, can match or beat purpose-built recurrent reasoners with roughly two orders of magnitude less inference compute, on the benchmark where those models are strongest.

  2. A simple, well-diagnosed fix with a large and consistent effect. The paper identifies a concrete failure of conventional self-conditioning under deep recurrence. As depth grows, the gold-target cross-entropy increases, the solve rate saturates near one third, and the residual stops predicting correctness (Fig. 6). The fix is a few-line change to training (Fig. 4). It raises the three-seed solve rate from 32.6±3.732.6\pm3.7% to 99.7±0.199.7\pm0.1% on Sudoku-Extreme, from 36.9±18.036.9\pm18.0% to 99.9±0.299.9\pm0.2% on Zebra, and from 96.2±3.096.2\pm3.0% to 99.2±0.699.2\pm0.6% on Maze-Unique (Table 2b). Self-conditioning is widely used in diffusion and flow language models, so the finding that its one-pass training breaks down at depth, and that training on rollout-derived carries repairs it, is likely to be useful beyond these puzzles.

Critical weaknesses
  1. The causal account of FPF is not isolated, and the headline model is not the recipe that is ablated. The paper attributes the gains to exposure bias. It states that “because FPF changes only the recurrent conditioning distribution, these results isolate exposure to model-generated states as the key ingredient” (Sec. 4.3, ll. 351–352), and the introduction says that FPF “closes the training–inference gap” (ll. 85–86). The experiments do not support this degree of attribution.

    • Training budget and supervision differ. The FPF models continue the final Stage-A self-conditioning weights for another 100K/200K/100K steps with a fresh optimizer and EMA (App. A.2, Table 3). Each FPF example also sums N=4N=4 cross-entropy terms after a K=16K=16-step rollout (App. A.2, ll. 671–676). The paper reports neither a self-conditioning control trained for the same additional steps nor FPF with a single supervised state.

    • The mismatch is narrowed rather than closed, and it is never measured. FPF rollouts start from the ground-truth interpolant at tstartt_{\mathrm{start}} and run 16 Euler steps (App. A.2). Evaluation instead runs thousands of fixed-time denoise–renoise steps from noise (App. B.2), e.g., 8,192 NFE for the Sudoku FPF row of Table 2b. The loss-bearing input xtjx_{t_j} is always the ground-truth interpolant (Sec. 3.2, ll. 238–239), so the input-side part of the mismatch in Eq. (7) is not addressed. The claimed reduction of “overconfidence and miscalibration” (ll. 242–243) is not supported by any calibration measurement.

    • The headline Sudoku model adds an unablated Stage C. Stage C continues training at the single inference time t=0.4t=0.4 with “re-noised FPF rollouts on every batch row”, up to 275K steps in total; Stages A and B together account for 200K (App. A.2, ll. 646–649; Table 3). Stage C is mentioned only in the appendix, yet the 275K model produces the 99.91% result, the 51×51\times comparison, and the Sudoku-Lite inference-policy results (Tables 2a and 5, Fig. 10, App. C.2). Because Stage C matches training to the inference sampler, it is plausibly a major ingredient, but its contribution is not reported.

    This matters because FPF is the paper’s main conceptual contribution. Without these controls, one cannot tell how much of the gain comes from correcting exposure bias, how much from extra or denser supervision, and how much from specializing training to the sampler, and that determines whether the insight transfers. The issue looks fixable with matched-budget controls and a Stage-C ablation. Relatedly, inference holds tt fixed and Stage C trains at a single tt, so the role of the flow itself is also open, as the paper acknowledges (ll. 370–372).

  2. Test data are used for selection, and several baseline comparisons are not like-for-like.

    • Selection on test data. Checkpoints are selected on subsets of the official test partitions: 256 Sudoku, 256 Zebra, and 128 Maze-Unique instances (App. A.2, ll. 650–651). The held time t=0.4t=0.4, which Stage C then trains for, is the value marked “Chosen” in a sweep over the 1,024 difficulty-balanced puzzles (App. B.2, Fig. 8). App. A.1 describes these as test puzzles (ll. 627–628), and no sweep on separate validation data is described. Sec. 4.4 says the stopping threshold is calibrated on “held-out validation puzzles” (ll. 376–377). App. B.3, however, states that the Zebra and Maze thresholds come from the training split and are not held-out validation data (ll. 849–852). On Sudoku and Zebra the selection subsets are tiny relative to the test sets, so I do not expect the headline numbers to move much. On Maze-Unique, however, 12.8% of the test set is used for checkpoint selection, and in general the protocol should rely only on data disjoint from the test sets.

    • Provenance and parity of baseline numbers. The Table 1 caption says “best measured” and marks unreproduced published values with †\dagger. Yet the un-daggered HRM (55.0) and TRM (87.4) entries equal the values reported in the HRM and TRM papers. Moreover, the Sudoku-Lite numbers for the same methods in Table 4 differ in both directions: HRM 64.0 and TRM 93.9 are higher, while FPRM 88.6 (vs. 94.2) and SE-RRM 93.7 (vs. 98.84) are lower. EqR’s App. C.1 defines Sudoku-Lite as a uniformly random 2,048-puzzle subset on which models score slightly lower than on the full test set (EqR, Table 15). Gaps of 5–9 points are therefore far outside sampling error, which suggests that Table 1 mixes published and re-measured values or different configurations. Similar issues affect the other columns:

      • The Zebra column of Table 1 combines FLM/FMLM results on fixed 5×55\times5 puzzles (App. A.3, l. 688), published mixed-size results for MDLM and Adaptive MDLM (ll. 692–693), and FRM on the full mixed-size test split. The Zebra panel of Fig. 5 likewise appears to plot FRM on mixed-size examples (Sec. 4.1; Table 5 caption) against FLM/FMLM, whose Zebra entries use fixed 5×55\times5 puzzles, although the caption states that “only configuration-matched curves are shown.”

      • On Maze-Unique, SE-RRM is a transfer from Maze-Hard (App. A.3), and TRM is evaluated at 0.264M parameters against FRM’s 8M (Table 1).

      • The 51×51\times ratio compares FRM with sequential, residual-gated restarts against EqR’s fixed D=64D{=}64, B=128B{=}128 configuration, which already uses convergence-based selection (EqR, Table 4 and App. D.4). Part of the ratio therefore reflects the inference policy, which could in principle also be applied to EqR.

    These points matter because the headline claims are comparative: “higher solve rates than the evaluated … baselines”, “51×51\times fewer FLOPs”, and “dominates the measured Maze-Unique tradeoff”. Given the size of the Sudoku-Lite gap, I expect the qualitative efficiency conclusion to survive. The exact numbers and the Zebra and Maze comparisons, however, need a clean protocol.

Minor points.

  1. Positioning. Training a refinement step on its own detached outputs is also the basis of deep supervision in HRM/TRM, both baselines here; TRM, for example, runs gradient-free recursions before a loss-bearing one on a decodable answer state. The same principle underlies recycling in AlphaFold2. Likewise, convergence-based restart selection and the depth–breadth analysis closely follow EqR (Top-1-converged selection, depth$\times$breadth heatmaps) and FPRM (fixed-point halting). Contribution 3 and the “no backpropagation through the rollout” distinction (p. 9) should be stated relative to these works.

  2. Consistency of the presentation. Fig. 4 shows a single supervised state that reuses the rollout noise, whereas App. A.2 uses N=4N=4 freshly noised states. DθD_\theta is a categorical distribution in Eqs. (2)–(3) but logits in Sec. 3.3 and App. A.2. Eqs. (4) and (6) hold xx fixed, unlike either sampler.

Questions for authors
  1. [Clarification] Matched-budget controls for FPF. Is the “+ Self-cond.” row in Table 2b the final Stage-A checkpoint? Please add (a) conventional self-conditioning continued for the same number of Stage-B steps with a fresh optimizer and EMA, and (b) FPF with N=1N=1 and, ideally, a few values of KK. If self-conditioning stays far below FPF under matched budgets, my main concern about attribution is resolved, and I would raise my soundness assessment.

  2. [Clarification] Stage C and the exact inference sampler. Please report the seed-0 Stage-B checkpoint (without Stage C) under the same full-test restart protocol and on Sudoku-Lite. Please also write out the fixed-time update and the Stage-C “re-noised” rollout as equations: what is re-noised (probabilities, the one-hot argmax, or logits), which time parameterization t=0.4t=0.4 refers to (“physical corruption level” in App. B.2 vs. FLM’s reparameterized time in App. A.2), and how the carry is updated. If most of the gain over the Table 2b recipe comes from Stage C, the method in Sec. 3.2 should be described accordingly.

  3. [Clarification] Test numbers free of selection. Please re-select checkpoints, held times, and thresholds on data disjoint from the test sets (e.g., held-out training puzzles) and report the resulting test numbers, at least for Maze-Unique and the Table 2b ablation. Please also state how t=0.2t=0.2 (Zebra) and t=0.15t=0.15 (Maze) were chosen, and where the “separate 1,024-puzzle development set” used for the Sudoku threshold (App. B.3) comes from. If the numbers are unchanged, this concern disappears.

  4. [Clarification] Baseline provenance. For each entry of Tables 1 and 4, please state whether you measured it yourselves (split, checkpoint, compute setting) or took it from a publication, and explain the Table 1 vs. Table 4 discrepancies noted above. Are the FLM/FMLM Zebra curves in Fig. 5 evaluated on the same 1,024 mixed-size examples as FRM? Were the diffusion baselines trained on the same 1,000-puzzle Sudoku subset, with the same augmentation and a comparable training budget? The EqR paper reports 99.8% (its Table 4); what is the source of the two-decimal 99.79% used to choose the matched operating point? The answers determine how much weight the comparative claims can bear.

  5. [Clarification] The residual as a stopping signal. Table 6 reports state-level AUROC (App. B.3, ll. 855–856). Are states from all depths pooled? Early, unconverged states are trivially incorrect. On Zebra, moreover, every puzzle is accepted and solved on its first trajectory (Table 5), so there appear to be no converged-but-wrong states at all. Please report puzzle-level false-acceptance rates at the deployed thresholds, and split the 394 full-test Sudoku failures into accepted-but-wrong cases and cases that reached the attempt cap. This would directly test the claim that convergence is “predictive of correctness”.

  6. [Suggestion / future work] Isolating the role of the flow and of the inference policy. (a) Train the same DiT with FPF-style detached carries but without the noisy interpolant input (carry-only recurrence, as in TRM), or with single-tt training from scratch. This would test whether the flow formulation itself matters, as opposed to recurrence on detached self-generated carries. (b) Apply the same sequential residual-gated restart policy to EqR, to separate the model’s contribution to the 51×51\times ratio from the policy’s. It would also help to report tail or wall-clock costs alongside mean FLOPs, since a single puzzle can use up to 1,024×4,0961{,}024\times4{,}096 sequential evaluations (App. B.1).

2 comments

We thank the reviewers for their thoughtful feedback, and are glad they recognize that FRMs deliver:

  1. Large, carefully accounted gains in accuracy and inference efficiency (wkK8, 1Psy, 5vBQ), matching purpose-built recurrent reasoners with roughly two orders of magnitude less inference compute (wkK8).
  2. A simple, well-diagnosed fix with a large and consistent effect (wkK8, 1Psy) that is likely to be useful beyond these puzzles (wkK8).
  3. An interesting idea addressing an important problem (5vBQ), supported by many informative experiments (5vBQ, 1Psy).

In response to your specific suggestions, we made these core clarifications:

  1. Added controls at matched optimizer steps, including for Stage C: FPF stays far ahead of both baselines, deeper training rollouts drive most of the gain, and Stage C is optional: uniform-time FPF alone reaches the headline accuracy, while Stage C reduces inference compute 3.2×.
  2. Removed test-data selection from the controlled comparisons and wrote out the sampler and stopping rule (Eq. 4, Algorithm 1, per-task settings and threshold calibration in App. B), with unified notation.
  3. Scoped our claims and positioning: FPF addresses the carry-side mismatch, and we credit HRM/TRM, EqR and FPRM for shared ingredients.

Thank you for your time and thoughtful review. Below we go into more detail, and hope to address the reviewer's specific questions.


  1. Is the “+ Self-cond.” row in Table 2b the final Stage-A checkpoint? Please add (a) conventional self-conditioning continued for the same number of Stage-B steps with a fresh optimizer and EMA, [...]

Yes. We now give conventional self-conditioning the same number of optimizer steps as FPF, including its Stage-B steps: both are trained for 275K steps in total, and we report the final checkpoint of each, at its best of three samplers. FPF reaches 99.7% on Sudoku-Extreme against 40.7% (base flow) and 33.7% (self-conditioning), and is best under each of Euler, annealed SDE and fixed-time sampling (App. Table 5).

Please add [...] (b) FPF with N=1N = 1 and, ideally, a few values of KK.

Yes. Starting from the same self-conditioning checkpoint, we trained FPF for 100K steps with rollouts of 1 to 16 steps, supervising either one or four rollout states (App. B.2, Fig. 9). Longer rollouts drive the gain: with a single supervised state, solve rate rises from 7% with one-step rollouts to 98% with eight-step rollouts. Supervising four states further improves accuracy once rollouts are at least four steps long (to 99.4% with eight steps), and makes inference converge faster. We therefore revised Sec. 4.3 from "isolate" to "provide strong evidence".

  1. Please report the seed-0 Stage-B checkpoint (without Stage C) under the same full-test restart protocol and on Sudoku-Lite. [...]

Good suggestion. We ran this experiment and found that Stage B alone performs similarly to Stage C, and that the main benefit of Stage C is improved inference efficiency. On the full test set, seed-0 replicates show Stage B solving 99.94% at 6.21 mean TFLOPs per puzzle versus 99.84% at 1.94 for Stage C, and on Sudoku-Lite both reach 99.89% (three seeds) at 2.52 vs. 0.83 TFLOPs. We now describe Stage C as an optional stage that reduces inference compute ~3× (App. A.2).

Please also write out the fixed-time update and the Stage-C “re-noised” rollout as equations: what is re-noised (probabilities, the one-hot argmax, or logits), which time parameterization t=0.4t = 0.4 refers to [...], and how the carry is updated.

The fixed-time update is now Eq. 4: the probabilities softmax(s(k))\mathrm{softmax}(s^{(k)}), not logits or the argmax, are re-noised to the held time with fresh Gaussian noise, and the logits become the next carry. Stage C uses the same update for its rollouts. All times, including t=0.4t = 0.4, are physical interpolation levels (App. A.2).

  1. Please re-select checkpoints, held times, and thresholds on data disjoint from the test sets [...] If the numbers are unchanged, this concern disappears.

We now report the final checkpoint of every run in the controlled comparisons (Tables 2b, 5 and 6), with no checkpoint selection. The results remain as strong, so we believe this concern is resolved: FPF reaches 99.7%, 100.0% and 99.7% on Sudoku-Extreme, Zebra and Maze-Unique, still far above both baselines. The adaptive-inference results still use the original checkpoints, selected on fixed test subsets; on the 872 Maze-Unique mazes never used for selection, FPF still solves 100% (App. A.2). At these final checkpoints, Sudoku-Extreme works best near t=0.4t = 0.4 while Zebra and Maze-Unique are robust over a broad range (App. Fig. 8), and a separate sweep on training-split Sudoku puzzles gives the same optimum. All stopping thresholds are calibrated on training-split puzzles (App. B.3, Table 8).

  1. For each entry of Tables 1 and 4, please state whether you measured it yourselves [...] or took it from a publication [...]

We now mark every published value with † in Tables 1 and 4; all other entries are our own measurements of released or retrained checkpoints. This also explains the differences between the two tables: Table 1 reports each specialized reasoner's published full-test result, while Table 4 reports our own Sudoku-Lite measurements.

  1. Please report puzzle-level false-acceptance rates at the deployed thresholds, and split the 394 full-test Sudoku failures into accepted-but-wrong cases and cases that reached the attempt cap.

Puzzle-level false acceptance is rare at the deployed thresholds. Of the headline model's 394 full-test Sudoku failures, 256 are accepted-but-wrong (0.06% of puzzles) and 138 reach the attempt cap; on Zebra, every puzzle is accepted and correct (App. B.3). The original Table 6 pooled states across depths; per depth, the FPF residual reaches AUROC ≥ 0.99 from NFE 16, versus ≈ 0.53 for self-conditioning (Fig. 5b).

  1. [Suggestion / future work] (a) carry-only recurrence or single-tt training from scratch; (b) the restart policy on EqR, and tail or wall-clock costs.

(a) Training FPF at a single time from scratch is less accurate than uniform-time training (at most 98.5% vs. 99.7% on Sudoku-Extreme), requires choosing the time in advance, and needs ~10× more inference compute with restarts (App. B.2, Table 6); carry-only recurrence is left to future work. (b) The cost tail is small: on the full test set, the median puzzle needs one attempt, 99% need at most two, and fewer than 0.1% reach the attempt cap. Applying our restart policy to EqR is left to future work.

The mismatch is narrowed rather than closed [...]

We agree and revised this claim in the main manuscript: the introduction now says FPF narrows the training–inference gap, and Sec. 3.2 states that FPF addresses only the carry-side mismatch.

Positioning [...] Consistency of the presentation [...]

We now credit deep supervision in HRM/TRM for training on detached self-generated states, and EqR and FPRM for convergence-based halting and selection; our contribution there is that FPF makes the residual a reliable stopping signal. We unified the notation (logits ℓθ\ell_\theta, Dθ=softmax(ℓθ)D_\theta = \mathrm{softmax}(\ell_\theta), Eqs. 4 and 6 now include re-noising) and note that Fig. 4 shows one supervised state for readability. Following your mismatch point, we now state that FPF addresses the carry-side mismatch only, and removed the unsupported calibration claim.

Reviewer_1PsyOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper turns continuous flow models into recurrent puzzle solvers by feeding predictions back into the denoiser. Fixed-Point Forcing (FPF) trains on rollout-generated conditioning states, while convergence residuals guide stopping and restarts. The reported accuracy and inference efficiency are impressive, though the training comparisons and evaluation protocol need tightening. Conceptually, this builds on self-conditioning as fixed-point iteration and EqR’s convergence-based reasoning. The main contribution is the particular rollout-conditioned training recipe and its strong empirical performance.

Critical strengths
  • The method has strong empirical performance. FPF improves mean Sudoku accuracy from 32.6% to 99.7% across three seeds, with similarly strong improvements on Zebra. Evaluating the headline Sudoku model on over 422,000 puzzles is also valuable.
  • The design is simple and practically useful. Predictions serve as readable recurrent states, training avoids backpropagating through long rollouts, and residual-based stopping substantially reduces inference cost. The matched-accuracy FLOP comparison with EqR is more informative than comparing accuracy alone.
Critical weaknesses
  • The authors explicitly select checkpoints on subsets of the official test partitions, then reports results on those same partitions (Appendix A.2). This is particularly concerning for Maze, where 128 of the 1,000 test instances guide selection. It probably does not explain the large gains, but the final evaluation should exclude selection examples and use a separate validation split.
  • The recipe adds a substantial second training stage, 16-step rollouts, and four supervised predictions per FPF example. The headline Sudoku model also receives further fixed-time training. Equal-budget continued-training controls are not established, so the statement that these results isolate the conditioning distribution as the key ingredient is too strong. Matching training compute and supervision would make that attribution much more convincing.
  • The equations describe carry refinement at fixed input, whereas the actual solver repeatedly denoises and re-noises its input. The exact update, noise handling, and numerical stopping thresholds are missing. These are central details: the same checkpoint reaches 30.3% with Euler versus 94.6% with fixed-time sampling. A complete inference algorithm and Stage-C training specification are needed for reproducibility.
  • A very relevant method [1] also trains recurrent reasoning through local denoising objectives. A comparison would help distinguish the benefits of FPF and an explicit prediction carry from recurrent flow training more generally. This paper was released an arXiv not too long before the ICLR deadline, so this is not a requirement but a suggestion to make the paper stronger for future readers.

[1] Suleymanzade, A., Lee, C., Eijkelboom, F., Boffi, N.M., Ceylan, I.I. and Kim, J., 2026. Thinking with looped flows. arXiv preprint arXiv:2609.11801.

Questions for authors
  • Were the puzzles used for checkpoint selection excluded from the final evaluation? If not, can you report results on the untouched portion, particularly for Maze-Unique?
  • Were the base-flow and conventional self-conditioning models given comparable training compute and numbers of supervised predictions? How much of FPF’s improvement remains under matched budgets?
  • What exactly is the fixed-time denoise–renoise update? Is fresh noise sampled at every step, and what stopping thresholds and prediction-stability checks are used?
  • How well would the same model perform if trained from scratch at a single noise level with rollout-conditioned supervision? Does training over the full flow path provide benefits beyond learning a recurrent denoiser?
4 comments

We thank the reviewers for their thoughtful feedback, and are glad they recognize that FRMs deliver:

  1. Large, carefully accounted gains in accuracy and inference efficiency (wkK8, 1Psy, 5vBQ), matching purpose-built recurrent reasoners with roughly two orders of magnitude less inference compute (wkK8).
  2. A simple, well-diagnosed fix with a large and consistent effect (wkK8, 1Psy) that is likely to be useful beyond these puzzles (wkK8).
  3. An interesting idea addressing an important problem (5vBQ), supported by many informative experiments (5vBQ, 1Psy).

In response to reviewer 1PsY's specific suggestions, we made these core clarifications:

  1. Removed checkpoint selection from all controlled comparisons and matched optimizer steps: we report the final checkpoint of three fixed seeds for every method, without any seed or checkpoint selection, and evaluate each method under three samplers.
  2. Clarified the deployed algorithm, writing out the fixed-time denoise–renoise update (Eq. 4), with the general algorithm and per-task hyperparameters in the appendix, and positioned FRMs relative to recent related work, including Thinking with Looped Flows.
  3. Clarified the role of training at the held time: additional training there is optional and improves inference efficiency (~3×), and training over uniform times is more robust and accurate than a fixed-time denoiser.

Thank you for your time and thoughtful review. Below we go into more detail, and hope to address the reviewer's specific questions.

The authors explicitly select checkpoints on subsets of the official test partitions [...]. Were the puzzles used for checkpoint selection excluded from the final evaluation?

We agree. All controlled comparisons now use the final checkpoint of every run, with no selection. The same trends hold: FPF still drastically outperforms the base flow and self-conditioning (App. Table 5).

If not, can you report results on the untouched portion, particularly for Maze-Unique?

Without seed or checkpoint selection, FPF solves 99.7 ± 0.5% of all 1,000 Maze-Unique test mazes. The headline adaptive-inference model, whose checkpoint was selected on 128 test mazes, solves all 872 mazes never used for selection (App. A.2).

Were the base-flow and conventional self-conditioning models given comparable training compute [...]? How much of FPF’s improvement remains under matched budgets?

Good suggestion. At matched optimizer steps, FPF continues to drastically outperform both baselines on Sudoku-Extreme: 99.7 ± 0.1%, versus 40.7 ± 4.5% for the base flow and 33.7 ± 2.3% for self-conditioning. We now train every method from scratch for 275K steps and evaluate every method under three samplers, reporting each at its best (App. Table 5).

[...] and numbers of supervised predictions?

To separate the effect of supervision from that of rollout conditioning, we also varied the number of supervised states NN and the rollout length KK (App. B.2, Fig. 9): with a single supervised state, solve rate still rises from 7.2% at K=1K = 1 to 98.0% at K=8K = 8, and supervising N=4N = 4 states further improves it.

The headline Sudoku model also receives further fixed-time training. Equal-budget continued-training controls are not established, so the statement that these results isolate the conditioning distribution as the key ingredient is too strong.

At matched optimizer steps, uniform-time FPF alone reaches the headline accuracy (99.89% on Sudoku-Lite with restarts, as with the additional training). What we do find is that the optional additional training at the held time reduces inference compute by about 3× (0.83 vs. 2.52 TFLOPs per puzzle).

The accuracy gain is therefore attributable to FPF rather than to this stage, and we clarified in the manuscript that its role is mainly to improve inference efficiency. We also clarified Sec. 4.3 to state that these results provide strong evidence that training on model-generated carries is the key ingredient.

The equations describe carry refinement at fixed input, whereas the actual solver repeatedly denoises and re-noises its input.

We clarified the notation in the method section to address this: the recurrence (Eq. 4) now explicitly includes re-noising the input along the flow interpolant at every step, and the fixed point is defined with respect to this update (Eq. 6).

What exactly is the fixed-time denoise–renoise update? Is fresh noise sampled at every step, and what stopping thresholds and prediction-stability checks are used?

At each step, the predicted probabilities are re-noised to the held time with freshly sampled Gaussian noise, given cells are clamped, and the logits are fed back as the carry (Eq. 4). App. B now lists the stopping thresholds, residual metric, check interval and stability window for each task.

A complete inference algorithm and Stage-C training specification are needed for reproducibility.

We added these details to the appendix, with the general algorithm and the specific hyperparameters necessary to reproduce our results.

A very relevant method [1] also trains recurrent reasoning through local denoising objectives.

We now discuss Thinking with Looped Flows as concurrent work in the related work. Both train recurrence with local denoising objectives without backpropagation through time. FRM differs in carrying its decodable prediction through the self-conditioning channel, keeping every loss-bearing input on the canonical interpolant, and iterating at a fixed time with convergence-based stopping, whereas Looped Flows carries a hidden latent state across decreasing noise levels.

How well would the same model perform if trained from scratch at a single noise level with rollout-conditioned supervision?

It performs worse than training over the full flow path. We trained FPF from scratch at several single fixed times for the same 275K steps, and added this experiment to the appendix (App. B.2, Table 6). Single-time FPF works only when trained at the held time used for inference (t=0.4t = 0.4), and even then it is less accurate than uniform-time FPF and degrades later in training; trained at any other time, it largely fails.

Does training over the full flow path provide benefits beyond learning a recurrent denoiser?

Yes. Training over the full flow path is more accurate, does not require choosing the held time in advance, and is about 10× more compute-efficient with residual-guided restarts on Sudoku-Lite (App. B.2, Table 6).

I thank the authors for providing the clarifications and updating the paper. This resolves most of my concerns, with a few suggestions about softening or refining the claims:

  • Table 5 in the appendix shows that without checkpoint selection, FPF still maintains a lead. I would revise the statements throughout the paper that report numbers and performance, since the main table in the paper still uses checkpoints selected on the test set.
  • The claim about FPF removing spurious fixed points should be softened, since Equation 6 gives us a result about the mean update and not individual trajectories. The results in the paper do seem to indicate that FPF rarely returns to wrong states discovered by self-conditioning, so there is some empirical evidence for this.

Overall, the updates to the paper increase my confidence in the positive assessment and I lean towards acceptance.

We thank the reviewer for their thoughtful follow-up and are glad that the revisions resolved most of their concerns and strengthened their positive assessment. We agree with both suggestions.

I would revise the statements throughout the paper that report numbers and performance, since the main table in the paper still uses checkpoints selected on the test set.

We will add full-test evaluations of the final, unselected checkpoints under the same inference protocol and update the main table and corresponding performance claims for consistency throughout the manuscript.

The claim about FPF removing spurious fixed points should be softened, since Equation 6 gives us a result about the mean update and not individual trajectories.

We agree and have revised the manuscript accordingly. Equation 6 now states a fixed-point condition for the mean update, without asserting convergence of individual stochastic trajectories. We also softened the corresponding text and figure claims: our experiments show that FPF rarely returns to the tested wrong states discovered by self-conditioning, rather than establishing that it eliminates all spurious fixed points.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.