Introducing Flow Reasoning Models. We developed a recurrent flow-based architecture to efficiently solve structured reasoning problems (e.g., Sudoku). FRMs apply continuous flows to discrete data and recurrently refine their past mistakes through self-conditioning.

FRMs are dramatically more efficient at inference than competing methods like HRM, TRM, and masked diffusion. On Sudoku-Extreme, FRMs match the next best method EqR’s 98.7% solve rate with 44× fewer FLOPs and reach a higher 99.5% peak accuracy.

Unlike conventional self-conditioning training, we apply multiple recurrent passes to the self-conditioned flow. This mitigates exposure bias in the self-conditioned carry state and dramatically improves performance (e.g., Sudoku-Extreme goes from ~30% to 99%).

Flow Reasoning Models admit a surprisingly elegant dynamical-systems perspective. Correct answers are fixed-point attractors of the self-conditioned flow’s dynamics.

Link to paper here:

Code coming soon:

So basically with Flow Matching

@nopainkiller waow this is really cool research direction!

@nopainkiller Ty ty!

honestly the 30 to 99 ablation is more interesting than the 44x. training on the messy states the model actually hits at inference instead of clean ones is the scheduled sampling idea again, and it looks like thats doing more of the work than the flow part

Cool, seems related to

Nice! I'll check it out.

Someone on your team came across it, we just realized it was cited in v1, alongside Biroli and Mezard's work which is also related (you can find more relevant citations in our paper). Wyart also looked at cycling diffusion around the same time as us arXiv:2605.27006

Alec really does have the most pleasing visuals for his work.

Ouch, scooped. Good work.

looks very interesting! can't wait to see the code!

When you say self-conditioning, is it conditioning on previous logits or on a decoded discrete sample at each recurrent step?

Good question. We condition on the previous logits rather than the decoded sample. These logits retain valuable information.

Great work! I wonder how FRM compares to ERM, which also reaches peak accuracy, given that their names happen to be very close😃

Woww amazing

What is the "Adaptive MDLM" used in this work? Is this the top-probability-margin sampler from Kim et al?

Yep!

Nice

Coll

Nice nice!!! Did something similar with a heavy harness and a SLM Tower of Hanoi at 100 disk Congratulations on the release

This is really cool!

perfect!

Great visualization! Since you seem to be aware of HRM, TRM, EqR, please also check SE-RRM ( , ICML2026)

Excited to take a look at the paper. Congrats!

very cool work!

Very cool!! How does it compare to ELF (language flows) conceptually? (Apart from the fact that this isn't language-based)

Thanks! The core difference is that ELF operates no embeddings of tokens from some external encoder (like T5). In our setting, we use a one hot encoding similar to Flow Language Models. This makes sense for problems like sudoku where digits are interchangeable and there is no inherent semantics differentiating the different vocabulary elements.

Intresting if this is so fast in inference can we distill large models after training into FRMs?

Is it generalized or only works for sudoku problem ? Did you try other richer problems ?

@adamnemecek1 is this Energy Based Model?

Where do you see this going when dealing with continuous problem such as robotics policies?

Can you describe the residual in your DiT? I'm waiting for you code to drop so I understand what happened there. I'm comparing to which fully depends on carrying the hidden state.

We take the logits, the un-decoded output, of the last denoising pass as an additional conditioning signal.

Just finished testing FRM, Stage A -> Stage B (FPF), I found that it starts with some degradation before it picks back up. Carried information mechanism doesn't appear to deliver (self-conditioning on the model's own predictions). Now just waiting for you code to confirm diff

Hi! Have you run any experiments on ARC-AGI?

Wrote an article on it Flow Reasoning Models: Turning Flows Into Efficient Recurrent Reasoners

Beautiful! Have you considered using FPF’s convergence signal as a learned per-token error/value-of-compute map? you could halt easy cases, refine unresolved regions, and replay confidently wrong low residual states? It could make recurrence both adaptive and locally targeted.

What does the edge it's following represent?

Wow! Have you tested any other discrete optimization problem than sudoku? I.e doing this for maxcut or vertex cover etc I.e neural combinatorial optimization

Agreed

Great research! The self-conditioning loop mirrors how good science works: propose, verify, falsify, refine. Love seeing that built into the architecture itself! Any plans to test it beyond Sudoku?

I built these last month lmao. Nice research. Did you check out the block version of this?