Flow Reasoning Models: Turning Flows Into Efficient Recurrent Reasoners — part 1/4
Cleaned-text code points [0, 14836). Bibliography omitted here; source.md includes it.
# 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: au-
toregressive models commit sequentially and cannot revise earlier decisions, while
masked diffusion models often 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 struc-
tured 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, effi-
ciently coordinating interdependent choices across solutions. 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 99.5%, 100.0%, and 99.9%
on Sudoku-Extreme, Zebra, and Maze-Unique, respectively. On Sudoku-Extreme,
FRMs achieve higher peak accuracy than the evaluated masked-diffusion and spe-
cialized reasoning baselines while remaining highly compute-efficient, matching
the next-best method’s98.7%peak solve rate with44×fewer inference FLOPs.
1 Introduction
A central challenge in structured reasoning is coordinating many mutually constraining decisions
into a single consistent solution. Autoregressive models often struggle with such tasks because they
commit to tokens in a fixed order, without the ability to later revise them as their global consequences
become clear. Masked diffusion models (Sahoo et al., 2024) offer a flexible generation order and
predict multiple tokens in parallel, but tokens updated within the same step are conditionally indepen-
dent given the current state and cannot condition on one another’s realized values, making aggressive
parallel updates prone to inconsistencies (Kim et al., 2025). Tightly constrained problems therefore
require many conservative updates, and correcting earlier errors requires additional mechanisms such
as remasking (Wang et al., 2026).
Continuous flow models over discrete data offer a promising alternative, modeling all tokens and their
interdependencies simultaneously. Recent work has demonstrated that continuous flow models can
effectively perform unconditional generation of natural language (Lee et al., 2026; Hu et al., 2026),
but their ability to perform structured reasoning remains largely unexplored. Indeed, in our own
experiments, a naive application of such continuous flows to structured reasoning tasks like Sudoku
solves only approximately13%on the Sudoku-Extreme benchmark (Wang et al., 2025a).
*Co-first author. Correspondence to Alec Helbling:alechelbling@gatech.edu
See code at:https://github.com/helblazer811/Flow-Reasoning-Models
arXiv:2606.29150v3 [cs.AI] 1 Sep 2026
Figure 1:Flow Reasoning Models turn stable recurrent dynamics into efficient reasoning.Left:
a conceptual view of the recurrent solution landscape. Error states occupy unstable basins, while the
correct solution forms a stable attractor that recurrent sampling converges toward. Right: solve rate
versus inference FLOPs on Sudoku-Extreme. At the highlighted matched solve rate, FRM uses 44×
fewer FLOPs than the comparison method. The landscape is an explanatory schematic rather than a
literal three-dimensional embedding of model states.
We introduce Flow Reasoning Models (FRMs), which turn continuous flows over discrete outputs into
recurrent reasoning models that iteratively refine candidate solutions. Self-conditioning has previously
been used to improve unconditional generation (Chen et al., 2023; Hu et al., 2026). We observe that
it can be particularly useful for decomposing complex reasoning into successive refinement steps:
FRMs feed each prediction back into the flow as the state to be refined at the next step. This yields an
interpretable recurrent state that can be directly decoded into the model’s current candidate solution.
It also provides a training-efficient form of recurrence that requires no backpropagation through
time and retains the canonical flow-matching objective. Adding self-conditioning alone significantly
improves performance, raising the solve rate on Sudoku-Extreme from roughly 13% to 33%, but still
leaving most problems unsolved.
This limitation becomes clearer through a dynamical-systems interpretation of FRMs: recurrent
refinement performs learned fixed-point iteration over candidate solutions. Under this view, correct
solutions should form stable, error-correcting attractors, while incorrect states should remain transient.
Conventional self-conditioning fails to produce these dynamics on challenging problems, instead
converging to confidently incorrect fixed points. We trace this failure to exposure bias between the
one-step conditioning states used during training and the recursively generated states encountered
during inference (Bengio et al., 2015; Huang et al., 2025). We introduce Fixed-Point Forcing (FPF),
which trains on rollout-derived conditioning states so that the model learns to correct states produced
by its own dynamics. Our results support this attractor picture: under FPF, recurrent refinement
moves predictions toward the ground truth, correct solutions converge while incorrect states remain
dynamically active, and convergence becomes strongly predictive of correctness.
Our core contributions are as follows:
1. Flow Reasoning Models (FRMs), a novel generative modeling framework that turns con-
tinuous flows over discrete structured outputs into recurrent models for reasoning.Their
predictions form an interpretable, directly decodable reasoning state while the models retain the
canonical flow-matching objective and require no backpropagation through time.
2. Fixed-Point Forcing (FPF), a novel training method for recurrent self-conditioned flow
models.We discover that exposure bias can cause these models to converge to spurious fixed
points. FPF mitigates this mismatch by training on rollout-derived conditioning states, making
additional recurrent depth productive and convergence predictive of correctness.
3. State-of-the-art accuracy and efficiency across structured reasoning tasks.Across Sudoku-
Extreme, Maze, and Zebra, FRMs achieve state-of-the-art solve rates and compare favorably
with masked diffusion models and specialized small reasoning models in accuracy and inference
efficiency. On Sudoku-Extreme, FRMs reach a peak solve rate of 99.5% and match EqR’s peak
98.7%solve rate (Huang et al., 2026) with44×fewer inference FLOPs (Figure 1).
2
1 4 8
1 9 3 2
2 4
2 8 3 1
8 1 9 3
4 9
3 5 9
9
8 7
Clues
31 Wrong
1 9 3 3 2 4 8 7 5
4 8 7 1 9 5 3 2 6
5 2 9 6 8 7 5 4 1
7 6 2 8 3 5 1 6 4
8 1 5 5 4 2 9 3 2
3 7 4 2 1 9 2 6 8
4 3 7 6 5 1 4 9 7
9 4 1 2 6 8 7 5 3
2 5 8 9 7 3 6 1 3
Attempt 1
22 Wrong
1 6 3 2 2 4 8 7 9
4 8 7 1 9 5 3 2 5
5 2 9 7 8 3 6 4 1
5 9 2 8 3 7 1 5 4
8 1 5 5 4 2 9 3 7
3 7 4 5 1 9 2 8 6
7 3 6 4 5 1 4 9 8
9 5 1 3 6 2 7 8 3
2 4 8 9 7 1 4 1 5
Attempt 2
14 Wrong
1 5 3 7 2 4 8 5 9
4 8 7 1 9 5 3 2 6
6 2 9 3 8 3 7 4 1
5 9 2 8 3 7 1 6 4
8 1 6 5 4 2 9 3 7
3 7 4 6 1 9 2 8 2
7 3 1 4 5 8 4 9 8
9 4 5 4 6 8 7 1 3
2 4 8 9 7 1 4 1 3
Attempt 3
5 Wrong
1 5 3 2 2 4 8 7 9
4 8 7 1 9 5 3 2 6
6 2 9 7 8 3 5 4 1
5 9 2 8 3 7 1 6 4
8 1 6 5 4 2 9 3 7
3 7 4 6 1 9 2 8 5
7 3 1 4 5 8 6 9 2
9 4 1 3 6 8 7 1 8
2 4 8 9 7 1 4 5 3
Attempt 4
2 Wrong
1 5 3 2 6 4 8 7 9
4 8 7 1 9 5 3 2 6
6 2 9 7 8 3 5 4 1
5 9 2 8 3 7 1 6 4
8 1 6 5 4 2 9 3 7
3 7 4 6 1 9 2 8 5
7 3 1 4 5 8 6 9 2
9 4 5 3 2 8 7 1 8
2 4 8 9 7 1 4 5 3
Attempt 5
Solved
1 5 3 2 6 4 8 7 9
4 8 7 1 9 5 3 2 6
6 2 9 7 8 3 5 4 1
5 9 2 8 3 7 1 6 4
8 1 6 5 4 2 9 3 7
3 7 4 6 1 9 2 8 5
7 3 1 4 5 8 6 9 2
9 4 5 3 2 6 7 1 8
2 6 8 9 7 1 4 5 3
Attempt 6
Figure 2:Recurrent refinement progressively solves a Sudoku-Extreme instance.Starting from
the fixed clues (gray), we decode the FRM’s prediction after each recurrent attempt, with incorrect
entries shown in red. The rollout illustrates how recurrent computation revises globally inconsistent
early predictions rather than committing to them permanently.
2 Flow Reasoning Models
2.1 Discrete Flows for Conditional Reasoning
We formulate reasoning as conditional generation over data pairs (c,y)∼p data. Here c denotes
the observed problem specification, for example, the given clues in Sudoku or the maze layout,
andy= (y 1,...,y L) denotes its discrete solution over vocabularyV. Only the solution is noised
and generated: c is supplied as a separate conditioning input and held fixed throughout training
and inference. Following work that models discrete data through continuous or simplex-valued
representations (Austin et al., 2021; Gat et al., 2024; Chen et al., 2023; Stark et al., 2024), we encode
yas a one-hot endpointx 1∈{0,1} L×|V| and decode predictions by positionwise argmax.
Flow matching connects Gaussian noiseε∼N(0,I) to this endpoint along a probability path (Lip-
man et al., 2023; Albergo et al., 2025). We use the linear interpolant
xt = (1−t)ε+tx 1, t∈[0,1].(1)
We adopt the categorical clean-prediction parameterization of Flow Language Models (Lee et al.,
2026): a denoiserDt
θ(xt|c) predicts a categorical distribution over the clean token at each position.
The corresponding clean endpoint prediction determines the probability-flow velocity:
vt
θ(xt|c) =
Dt
θ(xt|c)−x t
/(1−t).(2)
The same output is therefore both a directly decodable candidate solution and the quantity used to
advance the flow. We train it with tokenwise cross-entropy,
LCE(θ) =E t,c,y,ε
"
−
LX
i=1
logDt
θ(xt|c) i,yi
#
.(3)
This standard discrete-flow model is our FLM baseline. On its own it leaves a substantial gap on
structured reasoning; FRMs add a recurrent axis while retaining this path and objective.
2.2 Self-Conditioning as Recurrent Reasoning
Self-conditioning.Self-conditioning augments a denoiser with its own previous output as an
additional input (Chen et al., 2023). We write the resulting model asDt
θ(xt|c,s) , wheres carries a
previous clean-solution prediction ands=∅ denotes a zero-valued null carry. Conventional training
uses two passes: a null-carry pass produces the detached prediction es= stopgrad[Dt
θ(xt|c,∅)] ,
and the supervised pass receives eitheresor the null carry. The probability path and endpoint loss in
Eq. (3) remain unchanged, and gradients do not pass throughes.
Self-conditioning creates recurrence.At inference, FRMs repeatedly feed the latest clean predic-
tion back throughs. This feedback lets later evaluations preserve useful decisions, revise inconsistent
ones, and correct earlier mistakes. It also creates a discrete reasoning depth k, separate from
continuous flow timet. Holding(x t,t)fixed, recurrent refinement is
s(0)
t =∅, s (k+1)
t =D t
θ(xt|c,s (k)
t ),(4)
so each carry directly estimates the same clean solution. This gives every update direct supervision,
allowing detached training without backpropagation through time. A sampler can alternate between
advancing the flow state xt and applying additional recurrent updates at the current flow time.
Although self-conditioning substantially improves refinement, its gains saturate with depth on
Sudoku-Extreme (Fig. 6b), motivating the fixed-point analysis and training method developed next.
3
Stopgrad
(a) Conventional self-conditioning
Stopgrad (b) Fixed-Point Forcing
Figure 3:Fixed-Point Forcing replaces one-pass carries with rollout-derived carries.Conven-
tional self-conditioning forms a detached carry with one denoiser pass at the supervised interpolant.
Fixed-Point Forcing instead forms the detached carry through repeated application of the denoiser,
exposing the loss-bearing update to a state produced by the model’s recurrent inference dynamics.
3 Fixed-Point Forcing Promotes Correct Solutions as Stable Attractors
The recurrence in Eq. (4) defines a dynamical system over candidate solutions. Fixing (xt,c,t) ,
repeated application ofDt
θ performs fixed-point iteration over the self-conditioning state. During an
FPF rollout, however, the flow state, time, and carry evolve jointly, so this fixed-point iteration is a
held-state view rather than a literal description of how the FPF carry is constructed. Flow time moves
through a family of denoising problems, while reasoning depth iterates the corresponding denoiser
toward a stable prediction. For a problemcwith goaly ⋆, the desired held-state behavior is
s(k)
t −→s⋆
t, D t
θ(xt|c,s ⋆
t ) =s ⋆
t,decode(s ⋆
t ) =y ⋆.(5)
A useful solution should be attracting: imperfect nearby states should move toward it under additional
reasoning depth. Stable states that decode to incorrect solutions are insteadspurious fixed points.
This perspective supplies a common language for the rest of the paper: training determines the
recurrent state distribution, inference probes the resulting closed-loop dynamics, and useful test-time
computation requires those dynamics to correct rather than stabilize errors.
3.1 Exposure Bias in the Recurrent State
Conventional self-conditioning trains with a detached one-pass carry produced from the ground-truth-
derived interpolantxt = (1−t)ε+ty , withes= stopgrad[Dt
θ(xt|c,∅)] (Fig. 4, left). Recurrent
inference instead feeds predictions back repeatedly, so the carry at depthk is generated by the model’s
own closed-loop dynamics rather than by one pass from a ground-truth-derived state. Training and
inference therefore induce different carry distributions,
ptrain(s|x t,c,t)̸=p (k)
infer(s|bxt,c,t),(6)
and the mismatch grows with depth.
This mismatch has two coupled effects. First, the denoiser is not calibrated for its own recurrent
states: an incorrect but overconfident prediction can be fed back as reliable evidence, amplify its error,
and settle at a spurious fixed point. Second, one-pass training rarely presents the subtle, low-residual
errors that remain after several refinement steps, so the model is not trained to correct precisely the
states encountered near convergence. On challenging problems, recurrence can therefore stabilize
and sharpen an incorrect solution, increasing gold-target cross-entropy with depth (Fig. 6).
3.2 Fixed-Point Forcing
Fixed-Point Forcing (FPF) replaces the one-pass carry used in conventional self-conditioning with
a detached carry produced by the model’s own multi-step inference dynamics. It thereby trains
each recurrent update on the kinds of states produced by earlier updates, directly targeting the
train–inference mismatch in Eq. (6).
4