Flow Reasoning Models: Turning Flows Into Efficient Recurrent Reasoners — part 2/4

Cleaned-text code points [14836, 30587). Bibliography omitted here; source.md includes it.

Conventional Self-Conditioning−→Fixed-Point Forcing
- pred = denoiser(
- x_t, t, cond=clues, carry=None
- )
t = uniform(0, 1)
x_t = (1 - t) * noise + t * target + # Construct a rollout-derived carry.
+ t_start = uniform(0, t)
+ x_start = (1 - t_start) * noise
+ + t_start * target
+ pred = self_conditioned_rollout(
+ x_start, t_start, t, cond=clues
+ )
carry = stopgrad(pred)
refined_pred = denoiser(
x_t, t, cond=clues, carry=carry
)
update(cross_entropy(refined_pred, target))
Figure 4:Conventional self-conditioning and Fixed-Point Forcing training.Both procedures
supervise the same canonical interpolant. Conventional self-conditioning obtains its carry from one
pass at that interpolant, whereas FPF obtains a detached carry from a recursive rollout whose start
time is sampled uniformly before the supervision time and whose endpoint is the supervision time
itself. The self_conditioned_rollout helper denotes the standard self-conditioned integration
loop used at inference and for constructing the FPF carry.
The conceptual difference is illustrated in Fig. 3, and the corresponding training-code change is shown
in Fig. 4. We construct the FPF conditioning state by sampling a supervision time t and a rollout
starttstart∼U(0,t) , then run the inference-time self-conditioned integrator fromtstart tot. Its final
predictionsFPF is detached and supplied to the loss-bearing predictionDt
θ(xt|c,stopgrad(s FPF));
gradients do not pass through the rollout.
Crucially, this construction preserves the canonical flow-matching path exactly. As in conventional
self-conditioning, the loss-bearing input remainsxt = (1−t)ε+ty , the target remainsy, and the
endpoint cross-entropy is unchanged; the rollout prediction enters only through the self-conditioning
channel. FPF therefore changes the distribution of what the denoiser conditions on, not the state at
which the flow objective is supervised. Training on rollout-derived carries reduces the carry-side
exposure bias and the resulting overconfidence and miscalibration, while deeper rollout states expose
the model to the smaller, subtler residual errors that remain near convergence and train the local
corrections needed around a fixed point.
4 Experiments
We evaluate Flow Reasoning Models (FRMs) on Sudoku-Extreme, Zebra, and Maze-Unique, three
structured-prediction benchmarks with different constraints and output structures. Our primary metric
is exact solve rate. We compare inference efficiency using total FLOPs per instance and report the
number of function evaluations (NFE) to describe how each method allocates iterative computation.
Full protocols, baseline provenance, compute accounting, sweeps, and dynamics diagnostics appear
in Appendices A.1–C.
4.1 Accuracy and Efficiency Across Structured Reasoning Tasks
Flow Reasoning Models achieve near-perfect exact solving across distinct reasoning domains.
FRMs reach peak solve rates of 99.5% on Sudoku-Extreme, 100.0% on Zebra, and 99.9% on Maze-
Unique (Table 1). These benchmarks require constraint satisfaction, relational deduction, and path
finding, respectively, and differ substantially in sequence length, vocabulary, and output structure.
Near-perfect performance across all three therefore shows that recurrent flow refinement is not tied to
a particular task representation or constraint structure.
FRMs establish a stronger accuracy–compute frontier than diffusion language models and
specialized recurrent reasoners.FRM leads the measured accuracy–compute frontier on all three
tasks (Fig. 5). On Sudoku-Extreme, it attains the highest solve rate and reaches EqR’s 98.7% peak
with an estimated 44× fewer inference FLOPs. FRM likewise dominates the measured Maze-Unique
frontier, although its 99.9% peak is slightly below the best observed 100.0%, and reaches 100.0%
on Zebra, exceeding both reported peaks and the measured baselines. Zebra contains fewer curves
5

0.1 1 10 1000
20
40
60
80
100Solve Rate (%)
FLM
MDLM
Adaptive MDLM
HRM
TRM
FPRM
EqRFRM
Sudoku Extreme
0.05 0.1 1 5 10
FLM
FRM
FMLM
Zebra
0.01 0.1 1 10 100
MDLM
FLM
TRM
EqRFRM
Adaptive
MDLM
FMLM
Maze Unique
TFLOPs / Puzzle
Figure 5:Accuracy–compute frontiers across structured-reasoning tasks.Solve rate is plotted
against total inference FLOPs per instance for Sudoku-Extreme, Zebra, and Maze-Unique. The shared
solve-rate axis and legend are shown on the left panel only. Each panel compares FRM operating
points with the applicable flow baselines under a common FLOP-counting convention. We show only
method–task pairs with a valid, configuration-matched operating curve; unavailable combinations are
omitted rather than extrapolated.
Sudoku-Extreme Zebra Maze-Unique
Method Acc. (%) Size Acc. (%) Size Acc. (%) Size
Diffusion language models and flows
FMLM (Lee et al., 2026)1.0 7M74.2 25M87.5 8.1M
MDLM (Sahoo et al., 2024)3.9 30M76.9 † 19M89.0 8M
ReMDM (Wang et al., 2025b)5.5 30M – –93.5 8M
FLM (Lee et al., 2026)13.9 7M67.9 25M93.3 8M
Adaptive MDLM (Kim et al., 2025)19.1 30M98.3 † 19M100.0 8M
Specialized recurrent reasoners
HRM (Wang et al., 2025a)64.1 27.3M – –0.3 27.3M
TRM (Jolicoeur-Martineau, 2025)84.1 17.6M – –77.9 0.264M
FPRM (Movahedi et al., 2026)94.2 7M – –100.0 7M
EqR (Huang et al., 2026)98.7 5.03M – –93.0 2.6M
Flow Reasoning Model (ours)99.5 7M100.0 25M99.9 8M
Table 1:Peak exact-solve accuracy and model size across structured reasoning tasks.Parameter
counts correspond to the evaluated configuration and are rounded to the nearest reported model-
size convention. Dashes indicate an unreported result or unavailable configuration-matched count.
†Published Zebra result not reproduced in our evaluation pipeline; see Appendix A.3.
because we could not reproduce several published MDM models reliably enough for FLOP profiling;
their daggered, table-only accuracies and full provenance appear in Table 1 and Appendix A.3.
4.2 Self-Conditioning Enables Recurrent Refinement
Vanilla discrete flows achieve limited peak performance and do not scale with inference compute.
Across all three tasks, the vanilla FLM baselines plateau well below the full FRM (Table 2), and
allocating more forward passes leaves their solve-rate curves essentially flat. Additional integration
more accurately traces the learned probability path, but provides no mechanism for repeatedly revising
the current solution.
Self-conditioning enables recurrent refinement.Adding self-conditioning improves solve rate
over a plain discrete flow on Sudoku-Extreme ( 13.1%→32.6% ) and Maze-Unique ( 77.6%→
96.2%; Table 2). On Zebra, however, self-conditioning lowers the three-seed mean from 62.3%
to 36.9%, and both the base and self-conditioned flows exhibit high seed variance. Feeding each
prediction back to the model creates a recurrent computation that can preserve correct assignments
and revise earlier mistakes, as illustrated by the decoded trajectory in Fig. 2. On an easier Sudoku
variant introduced by Shah et al. (2024) (Sudoku-Shah), self-conditioning alone is already sufficient
to raise solve rate from approximately 30% to 99%, showing that recurrent refinement can saturate
less demanding constraint problems without Fixed-Point Forcing.
6

(a) Distance to Ground Truth
21 23 25 27 29
Recurrent Depth (NFE)
0
2
4
6Cross-Entropy Loss
Fixed-Point Forcing
Self-Conditioning
Base Flow (b) Solve Rate
21 23 25 27 29
Inference NFE
0
25
50
75
100Solve Rate (%)
(c)
Recipe
Residual
AUROC
Base Flow0.74
Self-Cond.0.50
FPF 1.00
Figure 6:Fixed-Point Forcing aligns recurrent convergence with correctness on Sudoku-
Extreme.(a) Under conventional self-conditioning, gold-target loss increases with depth as pre-
dictions stabilize at incorrect fixed points; FPF instead drives loss toward zero by making correct
solutions attracting and spurious states unstable. (b) Consequently, FPF continues to improve solve
rate with additional NFE, whereas self-conditioning saturates. (c) The residual between adjacent
recurrent states becomes strongly predictive of correctness under FPF, indicating that the model
converges primarily on correct solutions. Under conventional self-conditioning, convergence can
instead occur at incorrect states.
Conventional self-conditioning remains unreliable at depth.Despite these gains, its Sudoku-
Extreme solve rate plateaus near one-third of puzzles as recurrent depth increases (Fig. 6b), motivating
a training procedure that makes the recurrent computation reliable over long rollouts.
4.3 Fixed-Point Forcing Creates Healthy Reasoning Dynamics
Exposure bias produces confidently incorrect fixed points.With conventional self-conditioning,
solve rate plateaus as recurrent depth increases while gold-target cross-entropy grows even as
the adjacent-state symmetric-KL residual shrinks (Fig. 6a,b). The model is therefore not simply
failing to converge: it is becoming increasingly confident in self-consistent but incorrect predictions.
Correspondingly, residual magnitude is uninformative about correctness (AUROC0.50; Fig. 6c).
Fixed-Point Forcing mitigates exposure bias, enabling recurrent test-time scaling.Replacing
the one-pass training carry with a rollout-derived carry raises the three-seed mean solve rate from
32.6% to 99.2% on Sudoku-Extreme and from 96.2% to 98.0% on Maze-Unique. On Zebra, the
three FPF seeds average 99.9% (Table 2); the best evaluated operating points reach99.5% on Sudoku-
Extreme and 99.9% on Maze-Unique (Table 1). More importantly, conventional self-conditioning
plateaus with recurrent depth, whereas FPF continues converting additional model evaluations into
corrected solutions (Fig. 6b). Because FPF changes the training distribution of recurrent carries while
preserving the architecture, canonical flow path, and endpoint objective, the comparison isolates
exposure to inference-induced states as the intervention that unlocks recurrent test-time scaling.
Fixed-Point Forcing aligns convergence with correctness.Under FPF, additional recurrent up-
dates reduce gold-target cross-entropy as solve rate increases, directing convergent trajectories toward
the correct solution rather than merely toward a self-consistent prediction (Fig. 6a,b). We mea-
sure convergence by the token-averaged symmetric KL between adjacent predictive distributions,
rk =D SKL(pk,pk−1). This residual changes from a chance-level correctness signal under conven-
tional self-conditioning to a nearly perfect one under FPF (AUROC 1.00; Fig. 6c). Convergence thus
becomes an observable signature of successful reasoning, although not a formal certificate of correct-
ness. Together, these findings support the attractor picture in Fig. 1: conventional self-conditioning
admits stable incorrect fixed points, whereas FPF reshapes the closed-loop dynamics so that correct
solutions behave as stable, error-correcting attractors. The depicted basins summarize this empirical
dynamical behavior rather than asserting a literal low-dimensional geometry.
5 Related Work
Diffusion and Flow Language Models.A substantial body of work has developed diffusion-based
alternatives to autoregressive modeling for discrete data and language (Austin et al., 2021; Gat et al.,
2024; Stark et al., 2024). Masked Diffusion Language Models generate sequences through iterative
7

Sudoku-Extreme Zebra Maze-Unique
Model variant Accuracy (%) Accuracy (%) Accuracy (%)
Base Flow13.1±0.7 62.3±29.1 77.6±16.7
+ Self-conditioning32.6±3.7 36.9±18.0 96.2±3.0
+ Fixed-Point Forcing99.2±0.3 99.9±0.2 98.0±1.8
Table 2:Training-recipe ablation across three reasoning tasks.Entries report the mean ± sample
standard deviation over three training seeds. For each seed, we select the checkpoint and inference
configuration with the highest validation solve rate.
denoising (Sahoo et al., 2024). Shi et al. (2025) derive a simplified continuous-time objective as a
weighted integral of cross-entropy losses and generalize the framework to state-dependent masking
schedules. Within this family, Kim et al. (2025) use adaptive token ordering to allocate computation,
whereas Wang et al. (2025b) introduce remasking so earlier commitments can be revised; Duo instead
uses uniform categorical corruption, keeping every token revisable throughout sampling (Sahoo et al.,
2025). More recently, continuous flow language models have emerged as competitive alternatives.
FLM learns Gaussian-to-one-hot probability paths and FMLM distills them into few-step maps (Lee
et al., 2026), while LangFlow and ELF define flows in learned and contextual embedding spaces,
respectively (Chen et al., 2026; Hu et al., 2026). FRMs are inspired by this diffusion-and-flow
tradition, but use the clean denoiser prediction as a directly decodable recurrent state and train the
resulting closed loop for iterative solution refinement rather than treating repeated evaluations only as
steps of a generative sampler.
Recurrent and Fixed-Point Reasoning.Recent structured reasoners scale test-time computa-
tion through weight-tied recurrence. HRM uses hierarchical recurrent states (Wang et al., 2025a).
TRM (Jolicoeur-Martineau, 2025) and PTRM (Sghaier et al., 2026) repeatedly update compact
answer and latent states. EqR explicitly trains solution-aligned attractor dynamics (Huang et al.,
2026). FPRM similarly observes that convergence becomes predictive of correctness and uses this
signal for adaptive halting (Movahedi et al., 2026). FRMs share the emphasis on recurrent test-time
scaling, attractor dynamics, and meaningful convergence, but realize them within a self-conditioned
flow language model: the flow denoiser’s clean prediction is both the recurrent input and an explicit
solution candidate. Rather than introducing a bespoke latent-state architecture, FRM retains the stan-
dard non-causal Transformer and flow objective already demonstrated at language-model scale (Lee
et al., 2026; Hu et al., 2026), providing a natural path toward larger models and less specialized
domains. FPF further avoids backpropagation through the rollout: model-generated states enter only
through the conditioning channel, while every loss-bearing flow state remains on the target-derived
canonical path.
Learning from Model-Induced States.Conventional self-conditioning feeds a detached estimate
of the clean sample into later denoising steps, but trains that channel with a one-pass prediction rather
than the recursively generated predictions encountered during inference, as introduced for continuous
encodings of discrete data by Analog Bits (Chen et al., 2023). This is an instance of exposure bias:
the model is evaluated on its own induced context without being trained on that context (Ross et al.,
2011; Bengio et al., 2015). Concurrent work likewise frames self-conditioned flow language models
as fixed-point iterations for few-step generation (Yoo et al., 2026); we study structured reasoning
and training on model-induced recurrent states. Self Forcing closes the analogous context mismatch
in autoregressive video diffusion by training on self-generated rollout context (Huang et al., 2025).
FPF can be understood as a self-forcing variant specialized to the recurrent conditioning channel
of conditional discrete flows: it treats the carry, rather than previous frames, as model-generated
context. Unlike Self Forcing, FPF requires neither a sequence-level distribution-matching objective
nor differentiation through the rollout; it changes only the carry distribution while preserving the
canonical flow path and endpoint objective.
6 Discussion
Flow Reasoning Models indicate that discrete flows can be a powerful and efficient model class for
structured reasoning. Across constraint satisfaction, relational deduction, and path finding, FRMs
achieve strong performance while retaining a favorable accuracy–compute tradeoff. Conditioning
8