WorksComputer Science
Scout-Refine-Correct: Teaching Flow Models to Refine Their Own Samples
Abstract
The quality of image generation models trained with diffusion or flow matching is largely fixed by the training budget: at inference, the only available lever is the number of sampling steps, and additional steps improve quality only up to a point. We present a training recipe, Scout-Refine-Correct (SRC), that instead gives a flow-matching generator a genuine inference-time refinement capability. At each sampling step the model takes a scout rollout – steps ahead along its own trajectory – extrapolates a full-sample estimate, and feeds that estimate back to itself as a self-conditioning signal before taking the real step. This can be repeated for refinement rounds. Two correction losses, applied during training at states the model's own rollouts actually reach rather than only on the ground-truth path, teach the model to use this signal to reach new samples instead of collapsing to a suboptimal one. On ImageNet-256, SRC improves LightningDiT-B from FID~14.5 to FID~7.26 at NFE~550, matching a privileged best-of- baseline that uses an oracle FID verifier to choose among samples. SRC uses no external verifier, no reward signal, and, after ablation, almost no extra parameters over the base architecture. Combining SRC with best-of- improves the result further, to FID~3.81 at NFE~4400, showing that the two axes are complementary. We ablate the main design choices – the architectural pathway for the scout signal, the scout horizon, each correction loss, and the training schedule to demonstrate key working components of training.
Introduction
A recent finding in language modeling is that accuracy can scale with how much the model is allowed to compute at inference time - not just with parameter count or training compute. Chain-of-thought prompting [23] and self-consistency [22] spend that compute as extra generated tokens. Later models learn the behavior itself, either by outcome-reward reinforcement learning [9] or by supervised training on reasoning traces [20]. No handwritten chain of thought is required at test time: the model learns, from training, that spending more of its own intermediate computation pays off. We use the word reasoning in exactly this sense throughout this paper - not textual chain-of-thought, but test-time compute that a trained model has learned to spend productively on. improving its own answer - and ask whether an analogous capability can be trained into image generators.
Flow matching [17, 18] is now a standard way to train those generators, including large text-to-image systems [5, 14], and it extends to video [11] and to discrete data [7, 15]. Self-conditioning [1], in which the model conditions on its own previous estimate, is a natural place to spend extra computation inside the sampler. Prior attempts to bring reasoning to image generation usually rely on working with prompt conditioning. Reflection and prompt-refinement pipelines [13, 16] iterate with an auxiliary model, while the image model’s own forward computation is untouched. Closer to our setting, inference-time scaling has been studied by sampling many candidates and selecting among them with a verifier [19] - this is also the source of the FID-oracle best-of- baseline we compare against throughout this paper. Critically, that approach is a pure inference-time search: no training changes, and it is bounded by whatever diversity the base model’s sampling distribution already contains. It therefore cannot discover behavior the base model was never trained to produce. Looped and recursive networks build the extra computation into the architecture instead [2, 3, 6, 8, 12].
Our direction is to push the refinement signal into the training objective itself, for pure class-conditional image generation (deliberately simpler than text-to-image, so the effect is not confounded with prompt-level search). We keep the architecture close to the base model and implement the loop at the level of trajectory integration. We train the model so that, at inference, it can look steps ahead along its own sampling trajectory, extrapolate a tentative full-sample estimate from that look-ahead, and condition its very next step on that estimate - with two correction losses supervising exactly the states this look-ahead-and-condition loop actually visits, while not relying on external reward model, human feedback or architectural modifications to the model.
Contributions
A training-and-inference recipe that gives flow-matching image generators a genuine inference-time refinement capability, requiring no reward model and almost no architectural overhead beyond the base model.
Proposed approach demonstrates FID on ImageNet that significantly outperforms model baselines and matches an oracle-verifier best-of- baseline with zero verifier calls, and composing with best-of- for a further large improvement to a new best FID at matched compute.
A systematic ablation of every structural design choice - the architectural pathway for the scout signal, the scout horizon, each correction/rollout loss term, and the training-stage schedule - isolating exactly which pieces actually contribute to model quality.
Related Works
Flow Matching
Flow matching [17, 18] has emerged as a dominant paradigm for training large-scale image generators, such as StableDiffusion 3 [5] and Flux [14]. It has been widely adopted in other domains, including video generation [11] and discrete data such as language [7, 15]. In the discrete domain one common technique that improves inference quality is self-conditioning [1], which lets the model condition on its own previous output.
Reasoning Capabilities
Reasoning as a property of deep learning models originated in large language models with manual techniques like CoT [23], self-consistency [22]. Later reasoning models appeared, which embed reasoning capabilities models through RL [9] or SFT on reasoning traces [20]. In this work, we understand reasoning as the ability of a model to allocate more computation at inference time in order to improve the task at hand. For images and diffusion models, it has first been pursued through verifier-based search [19] and through pipelines that call external models [13, 16] to improve prompt alignment or instruction following in image editing.
Looped Models
Looped models are a related line of recurrent architectures. Common lines of work include looped transformers [3, 6, 8], as well as recursive models of small size trained on specific tasks [12]. Recent work [2] shows that such models can be applied to text-conditioned image generation. This models explicitly explore idea of ”refining” output through architecture network. In contrast, in this work we keep architecture almost identical to the original DiT, while loops are implemented at trajectory integration level.
Method
We learn a conditional velocity field for flow generation on the linear interpolation path:
whose conditional flow-matching target is .
Self-Conditioning
The first modification is self-conditioning [1]. It was originally proposed for binary and discrete diffusion, where the denoiser receives a second input : its own previous estimate of the clean sample, alongside the usual . Under our parametrization, the network predicts a velocity , and the sample estimate is obtained by extrapolating that velocity to :
During training, half of each training batch sees and the other half sees a stop-gradient one-shot estimate from Eq. (2) with . This gives the model one free look at its unconditioned prediction and then trains it to improve on that guess. At inference, the signal is carried and updated across the denoising steps.
In-place refine (R-scaling)
A natural next step is to keep iterating on at a fixed time . Once exists, it can be refined in place: is re-estimated at the same for rounds before the real step is taken. This is fixed-point iteration on the denoiser. Similar behavior is studied by [10], where the desired outcome is convergence to a stable solution . We do observe this convergence, but quality plateaus at FID no matter how many rounds are used (Figure 2).
Figure 2. In-place refinement of a basic self-conditioning model (no scout, no correction loss): FID vs. refinement rounds . Quality saturates at almost immediately – extra refinement compute buys nothing without the correction losses of § 3.2.
The reason is that training never teaches the model what to do with a possibly wrong, self-generated . The plain flow-matching loss is always evaluated on the true trajectory , so there is no gradient that corrects errors introduced by conditioning the model on its own off-trajectory rollout. This motivates the correction loss introduced next.
Self-Correction
To move past the in-place refinement plateau, the loss must supervise the model at states reached by its own, possibly imperfect rollout. These states lie off the ground-truth interpolation path, which plain flow matching never visits. Rather than introducing a reinforcement-learning objective with an oracle FID reward, we follow [21] and use the following target. Take a state produced by the model’s own rollout, re-noise it toward the same noise with a random mixing factor , and supervise the model at that re-noised point with the analytic straight-line velocity toward the true . This pulls an off-path point back toward the valid sample. We call the procedure ReNoiseCorrect (Alg. 1). The main difference from SOAR is that we do not apply classifier-free guidance when forming , because we found that it hurts training.
Algorithm 1 RENOISECORRECT – turn any rollout endpoint into supervised corrections with analytic targets.
Require: rollout point at time ; conditioning ; the sample’s own
for do
\quad
\quad ; \quad
\quad
\quad
end for
return
Scout-Refine-Correct
K-step scout rollout
The last design choice is to form from a point further along the trajectory, rather than from the current point or the next one. In the scout rollout, the model takes null-conditioned Euler steps forward in from and reaches a scout state . One model call at , extrapolated with Eq. (2), produces the scout estimate . This more informed condition then guides the single main step.
During training, the -step scout rollout is stop-gradient: it does not send a training signal directly back to the model.
Training
The full training step is given in Alg. 2. It builds a -step rollout and then takes one step over the same horizon, conditioned on . Correction losses are applied at both points and pull both rollouts toward the ground-truth . is sampled once per training step from a uniform range, but the model never observes it. We found that explicitly conditioning on scout information, such as
Algorithm 2 Single SRC training step.
Require: batch ; network ; see Table 1 for full list of hyperparameters
| symbol | meaning | value |
| self-cond fraction of batch | 0.5 | |
| scout step size (fixed) | 0.02 | |
| scout-count range | 1..3 | |
| re-noise draws per rollout point | 2 | |
| loss weights | 1, 1 |
Table 1. Training recipe hyperparameters.
, ,
,
,
K-rollout + signal
Main step with
Correction losses
the number of steps , does not improve the model. In addition to the two correction losses, the standard flow-matching loss at is applied to the half of the batch whose self-conditioning signal is dropped.
Table 1 lists the recipe’s hyperparameters. Figure 1 shows the main components of the step: the -rollout, the main step conditioned on , and the random renoising used by ReNoiseCorrect.

Figure 1. Conceptual scheme of the SRC pipeline. A scout rollout looks ahead to form a more informed estimate , and the main rollout then advances the current state under that condition. Correction losses train both rollouts.
Inference
Plain self-conditioning carries from one main step to the next, computing it once and reusing it at no extra cost. Our training instead produces a useful estimate at times closer to the data. After comparing inference regimes, including in-place refinement (outer loop) and scout rollouts of depth (inner loop), we use the procedure in Alg. 3 to search over inference budgets. The budget is computed by following formula:
We fix main Euler steps in every setup. The pair can be chosen at inference time. After searching through grid of values and discarding unstable
Algorithm 3 SRC inference step with a -step scout and refinement rounds.
Require: ; ; , ,
for do
for do
end for
end for
return
operating points, we end up with high-quality FiD/NFE frontier.
Results
Image generation
We evaluate on ImageNet-256 [4], and the base architecture is LightningDiT-B [24]. Detailed training hyperparameters are given in Appendix § 6. We compare SRC with three baselines: scaling the number of sampling steps of the base model, scaling the in-place refinement rounds of a self-conditioned model, and an oracle best-of- baseline that selects the candidate which most improves the target FID. In Figure 3 it can be seen that sampling-step scaling leaves the base LightningDiT-B checkpoint at roughly the same quality. Self-conditioning -scaling plateaus after a gain of about 3 FID. SRC reaches a single-sample best of FID 7.26 at NFE 550 (). It is competitive with the privileged best-of- oracle even though training never observes the FID metric.
Figure 3. FID vs. NFE on ImageNet-256: sampling-step scaling alone (base model, flat), vanilla self-conditioning -scaling (plateaus at ), and SRC’s single-sample frontier (global best FID 7.26 at NFE 550).
Combining SRC with best-of-. We apply best-of- to SRC in a refine-then-select pipeline: draw independent SRC samples at a fixed , keep the sample selected by the FID oracle, and measure how quality scales with at different anchors.
(a) Same-budget result. Anchored at the inexpensive end of our frontier (, NFE 200), SRC with best-of- beats the baseline best-of- oracle at every NFE where both are measured. This includes beating the baseline’s own best-of- ceiling (FID 5.97 at ) with only a quarter of that NFE and far fewer draws (Table 2).
| NFE | SRC ()+BoN | baseline BoN |
| 200 | 7.89 | 8.25 |
| 400 | 6.53 | 6.96 |
| 800 | 5.45 () | 5.97 () |
| 1600 | 4.12 | - |
Table 2. Same-budget comparison: SRC anchored at versus the baseline best-of- oracle
(b) Beyond the best-of- frontier. Starting from the best single-sample SRC setting (, , NFE 550) and scaling to , SRC with best-of- reaches FID 3.81 at NFE 4400 (Table 3). Refinement combined with verifier search therefore both wins at a smaller NFE budget and continues to a higher-quality operating point.
| SRC (, )+best-of- | NFE | |
| 1 | 7.26 | 550 |
| 2 | 5.99 | 1100 |
| 4 | 5.02 | 2200 |
| 8 | 3.81 (new global best) | 4400 |
Table 3. Scaling SRC+best-of- past where the baseline best-of- oracle was ever measured.
Qualitative effect on images. Figure 4 shows that SRC refinement visibly restructures the sampled image. Spending the extra compute on more denoising steps, or on tuning the classifier-free guidance scale, does not have the same effect. Figure 6 checks the latter directly by showing the pixel difference after each kind of scaling.

Figure 4. SRC refinement compared with scaling the number of inference steps and with scaling the classifier-free guidance weight.

Figure 6. Pixel differences for SRC refinement and for classifier-free guidance scaling, on the same examples.
Design choices
We pose this section as a sequence of design questions around SRC training, each answered by a targeted ablation, rather than a results dump:
Which correction/rollout terms contribute to the resulting quality?
What is the effect of dropping the self-conditioned flow-matching loss?
How wide should the training-time scout horizon be?
How should self-conditioning pretraining and SRC training be balanced?
Is tuning the classifier-free-guidance scale a free substitute for our refinement?
Which train components contribute to the resulting quality?
In this experiment we run leave-one-out ablation of the SRC+K-cond model - it is slightly different from SRC by an explicit conditioning pathway for . In Figure 5 for this ablations we show scaling for fixed , as well as some other operating points. Notably, removing conditioning on (which is our final SRC version) behaves almost same and can be better especially without refining. Among the remaining choices, removing main-corr is by far the most damaging: FID becomes completely flat, so the model never learns to use the refined scout condition at inference time. Removing scout-corr also hurts substantially, raising the best FID to 9.43. Removing the non-self-conditioned flow-matching term or the -step rollout also degrades the quality frontier. SRC itself appears in the same figure as the ablation that removes the architectural change. An additive version of this study, in which each training component is introduced on the way from self-conditioning to SRC, is given in Appendix § 7.
Figure 5. (a) FID vs. inference-time at . (b) FID at four decisive operating cells. main-corr is the single most critical term; scout-corr is also clearly load-bearing, while -conditioning doesn’t introduce significant gains.
What is the effect of dropping self-conditioned flow matching loss?
SRC keeps the flow-matching loss on the part of the batch that does not use self-conditioning, but drops the flow-matching loss evaluated while the network is conditioned on its own estimate. We compare two correction-trained models that differ only in this term: flow matching at the current state with conditioning . The earlier variant keeps the term, and the later drops it.
Table 4 demonstrates effect of such change, reporting LPIPS between decoded at as at . It can be observed that the term, that distance is already near zero by . Without it, an extra round moves the sample substantially, while the FiD rapidly improves - between and from FiD moves from 15.17 to 10.98.
| with self-conditioned FM | 0.013 | 0.003 |
| without self-conditioned FM | 0.164 | 0.183 |
Table 4. Mean LPIPS between refinement round and round , averaged over images and sampling steps. The two rows are the self-conditioning baseline that keeps the term and the later model that drops it.
How wide should the training-time scout horizon be?
Table 5 sweeps the training-time scout horizon and reports each variant’s best operating point - is the best setting. Current interpretation of larger not helping with scaling is that being too close to data limits exploration of the model.
Training-stage budget ablation
SRC training can be composed of following stages: (a) self-conditioned pretraining, (b) SRC with a fixed scout depth , and (c) the final scout-and-correction stage. Training runs are all limited to 210k iterations. Table 6 compares budget splits among these stages. The split (120k, 60k, 30k) beats the four alter-
| best FID | |
| 2 | 7.21 |
| 3 | 7.18 |
| 4 | 7.49 |
| 6 | 8.30 |
| 8 | 9.99 |
caption: Training-time scout horizon (). is the best of the tested values.
:::
natives, including both variants that skip a stage, so all three stages contribute.
| (a,b,c) steps | FID @ best KR |
| (120k, 0, 90k) – no stage b | 7.85 |
| (120k, 90k, 0) – no stage c | 8.88 |
| (120k, 60k, 30k) | 7.18 |
| (120k, 30k, 60k) | 7.53 |
| (90k, 90k, 30k) | 7.34 |
caption: Training-stage budget. The (120k, 60k, 30k) split is the best of the five schedules tested.
:::
Is cfg-scale tuning a free substitute for our refinement?
At a fixed budget of NFE=50, raising the classifier-free guidance scale improves FID from 14.52 to 9.54. SRC overtakes it by NFE=150 by reaching FID 8.36 and keeps improving while the guidance sweep saturates. However more important distinction is qualitative - in terms of perceptual difference SRC produces completely different images, as highlighted in Figure 6 shows that SRC refinement changes pose, composition, and fine structure, whereas guidance-scale tuning changes only small regions.
Conclusion
We presented Scout-Refine-Correct, a training recipe that teaches a flow-matching image generator to spend extra computation at inference time on its own sample. At every step the model looks steps ahead, refines the resulting self-conditioning signal for rounds, and then takes one informed step. Two correction losses supervise the off-path states that these rollouts actually reach, so the additional computation changes the sample rather than saturating.
On class-conditional ImageNet-256, SRC improves LightningDiT-B from FID 14 to FID 7.26 at 550 network evaluations. This matches a privileged best-of- oracle that selects samples with the true FID statistic, while SRC itself uses no verifier and no reward model. Using both together reaches FID 3.81 at 4400 evaluations. Qualitatively, the refinement changes pose, composition, and fine detail. Increasing the number of denoising steps or the classifier-free guidance scale does not produce the same change.
The ablations locate the source of this behavior. The main and scout correction losses are required for the model to use the scouted signal. Dropping flow matching on the self-conditioned state improves quality at one refinement round, but later rounds no longer converge. The scout horizon and the split of the three training stages both have a clear best setting, and neither guidance-scale tuning nor a longer Euler schedule replaces the correction training.
Training details
All models are trained on ImageNet-256. The path is linear flow with a velocity target, logit-normal time sampling, and a cosine loss term. The optimizer is AdamW with and no weight decay. Unless noted, evaluation uses 50 Euler steps, classifier-free guidance scale 5, interval start 0.11, and timestep shift 0.3 (default sampling parameters from Lightning-B).
LightningDiT-B
The step-scaling and best-of- baselines use LightningDiT-B/1, trained for 60k steps at batch size 1024 and learning rate . The backbone uses rotary position embeddings, RMSNorm, and SwiGLU. It has no self-conditioning input. Its standard 50-step sample reaches FID 14.52.
Self-conditioning baseline
The in-place refinement baseline is trained separately for 120k steps, at batch size 256 and learning rate . It is not a fine-tune of LightningDiT-B. Relative to that backbone, rotary embeddings are replaced by a learned positional embedding, QK-norm is turned on, and the network gains a second input , its own estimate of the clean sample.
Figure 7 shows where that input enters. is embedded by a separate bias-free patch embedder, so the trained null maps to the zero token, and those tokens are concatenated with the image tokens. A single AdaLN slot, driven by the usual time and class vector, modulates the blocks. There is no second AdaLN slot and no input for the scout depth . Half of each batch is trained with and half with a stop-gradient one-step estimate, which is the standard self-conditioning bootstrap. At inference this checkpoint carries the estimate from one step to the next; the -scaling curve refines it in place before the step.
Figure 7. The architecture used from the self-conditioning baseline through SRC: enters only as concatenated tokens from a bias-free embedder, and one AdaLN slot is driven by time and class. is not a network input.
Three-stage SRC schedule
SRC keeps the self-conditioning architecture and warm-starts from that 120k checkpoint. The schedule is (120k, 60k, 30k), 210k steps in total. Stages 2 and 3 use batch size 128 and learning rate .
Stage 2 (120k to 180k) adds the two correction losses while the self-conditioning signal is still a same-point estimate: one frozen prediction at the current , with no -step look-ahead. Both the scout and the main correction are on. Each is the mean of independent re-noisings of the same rollout point. Flow matching on the self-conditioned state is still applied, in addition to ordinary flow matching on the half of the batch that sees (it can be turned off just fine, but keeping it for this stage was found beneficial for later). The scout step used inside the correction is a single step of size .
Stage 3 (180k to 210k) is the final SRC recipe. The signal is no longer formed at the current point. is drawn once per step from , and is extrapolated after frozen Euler steps of size 0.02. The main correction then covers that same horizon in one hop. The self-conditioned flow-matching term is dropped: the self-conditioned half of the batch is supervised only by the two correction losses, still with . Ordinary flow matching remains on the other half. The architecture is unchanged, so still only sets the rollout length. All SRC numbers in the paper use this 210k checkpoint.
More visual reasoning examples
Figure 8 compares SRC refinement with vanilla self-conditioning refinement on the same seeds and classes. The self-conditioning side is the -scaling baseline whose FID plateaus in Figure 2. Columns are matched in NFE. On the left, SRC uses settings at NFE 50, 100, 200, and 550. On the right, vanilla self-conditioning uses its reference step at NFE 50, then , , and , which land at NFE 100, 200, and 550. Extra rounds of in-place refinement leave the sample close to where it started. SRC keeps composition and layout while improving readability and coherence of the object in the image.

Figure 8. Matched-seed comparison of SRC refinement and vanilla self-conditioning refinement. Left: SRC at NFE {50, 100, 200, 550}. Right: vanilla self-conditioning at the same NFEs (reference, , , ). The right-hand family is the baseline that plateaus in Figure 2.
References
- [1]Ting Chen, Ruixiang Zhang, and Geoffrey Hinton. Analog bits: Generating discrete data using diffusion models with self-conditioning. arXiv preprint arXiv:2208.04202, 2022.
- [2]Yong Xieng Cheng, Tianyi Chen, Wenwen Tong, Haiwen Diao, Zhongang Cai, Lei Yang, Ziwei Liu, Lew ei Lu, Dahua Lin, and Gao Huang. Looped diffusion transformer. arXiv preprint arXiv:2609.40305, 2026.
- [3]Mostafa Dehghani, Stephan Gouws, Oriol Vinyals, Jakob Uszkoreit, and Łukasz Kaiser. Universal transformers. arXiv preprint arXiv:1807.03819, 2018.arxiv.org/abs/1807.03819
- [4]Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pages 248–255. Ieee, 2009.
- [5]Patrick Esser, Sumith Kulal, Andreas Blattmann, Rahim Entezari, Jonas Müller, Harry Saini, Yam Levi, Dominik Lorenz, Axel Sauer, Frederic Boesel, et al. Scaling rectified flow transformers for high-resolution image synthesis. In Forty-first international conference on machine learning, 2024.arxiv.org/abs/2403.03206
- [6]Ying Fan, Yilun Du, Kannan Ramchandran, and Kangwook Lee. Looped transformers for length generalization. In International Conference on Learning Representations, pages 14502–14520, 2025.arxiv.org/abs/2409.15647
- [7]Itai Gat, Tal Remez, Neta Shaul, Felix Kreuk, Ricky TQ Chen, Gabriel Synnaeve, Yossi Adi, and Yaron Lipman. Discrete flow matching. Advances in Neural Information Processing Systems, 37:133345–133385, 2024.arxiv.org/abs/2407.15595
- [8]Jonas Geiping, Sean McLeish, Neel Jain, John Kirchenbauer, Siddharth Singh, Brian Bartoldson, Bhavya Kailkhura, Abhinav Bhatele, and Tom Goldstein. Scaling up test-time compute with latent reasoning: A recurrent depth approach. Advances in Neural Information Processing Systems, 38:41340–41391, 2026.arxiv.org/abs/2502.05171
- [9]Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Peiyi Wang, Qihao Zhu, Runxin Xu, Ruoyu Zhang, Shirong Ma, Xiao Bi, et al. Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning. arXiv preprint arXiv:2501.12948, 2025.DOI
- [10]Alec Helbling, Andrey Bryutkin, Mauro Martino, Nima Dehmamy, and Hendrik Strobelt. Flow reasoning models: Scaling reasoning through iterative self-refinement. arXiv preprint arXiv:2606.29150, 2026.
- [11]Yang Jin, Zhicheng Sun, Ningyuan Li, Kun Xu, Hao Jiang, Nan Zhuang, Quzhe Huang, Yang Song, Yadong Mu, and Zhouchen Lin. Pyramidal flow matching for efficient video generative modeling. In International Conference on Learning Representations, pages 23378–23402, 2025.arxiv.org/abs/2410.05954
- [12]Alexia Jolicoeur-Martineau. Less is more: Recursive reasoning with tiny networks. arXiv preprint arXiv:2510.04871, 2025.
- [13]Siqi Quo, Jiachun Jin, Zetong Zhou, Ye Ma, Yugang Wang, Quan Chen, Peng Jiang, Xiao Yang, Jun Zhu, Kai Yu, et al. Think-then-generate: Reasoning-aware text-to-image diffusion with llm encoders. arXiv preprint arXiv:2601.10332, 2026.arxiv.org/abs/2601.10332
- [14]Black Forest Labs, Stephen Batifol, Andreas Blattmann, Frederic Boesel, Saksham Consul, Cyril Diagne, Tim Dockhorn, Jack English, Zion English, Patrick Esser, et al. Flux. 1 Kontext: Flow matching for in-context image generation and editing in latent space. arXiv preprint arXiv:2506.15742, 2025.arxiv.org/abs/2506.15742
- [15]Chanhyuk Lee, Jaehoon Yoo, Manan Agarwal, Sheel Shah, Jerry Huang, Aditi Raghunathan, Seunghoon Hong, Nicholas M Boffi, and Jinwoo Kim. Flow map language models: One-step language modeling via continuous denoising. arXiv preprint arXiv:2602.16813, 2026.arxiv.org/abs/2602.16813
- [16]Shufan Li, Konstantinos Kallidromitis, Akash Gokul, Arsh Koneru, Yusuke Kato, Kazuki Kozuka, and Aditya Grover. Reflect-dit: Inference-time scaling for text-to-image diffusion transformers via in-context reflection. In 2025 IEEE/CVF International Conference on Computer Vision (ICCV), pages 15657–15668. IEEE, 2025.arxiv.org/abs/2503.12271
- [17]Yaron Lipman, Ricky TQ Chen, Heli Ben-Hamu, Maximilian Nickel, and Matt Le. Flow matching for generative modeling. arXiv preprint arXiv:2210.02747, 2022.arxiv.org/abs/2210.02747
- [18]Xingchao Liu, Chengyue Gong, and Qiang Liu. Flow straight and fast: Learning to generate and transfer data with rectified flow. arXiv preprint arXiv:2209.03003, 2022.arxiv.org/abs/2209.03003
- [19]Nanye Ma, Shangyuan Tong, Haolin Jia, Hexiang Hu, Yu-Chuan Su, Mingda Zhang, Xuan Yang, Yandong Li, Tommi Jaakkola, Xuhui Jia, et al. Inference-time scaling for diffusion models beyond scaling denoising steps. arXiv preprint arXiv:2501.09732, 2025.arxiv.org/abs/2501.09732
- [20]Niklas Muennighoff, Zitong Yang, Weijia Shi, Xiang Lisa Li, Li Fei-Fei, Hannaneh Hajishirzi, Luke Zettlemoyer, Percy Liang, Emmanuel Candès, and Tatsunori B Hashimoto. s1: Simple test-time scaling. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pages 20286–20332, 2025.arxiv.org/abs/2501.19393
- [21]You Qin, Linqing Wang, Hao Fei, Roger Zimmermann, Liefeng Bo, Qinglin Lu, and Chaoyun Wang. Self-correction for optimal alignment and refinement in diffusion models. arXiv preprint arXiv:2604.12617, 2026.arxiv.org/abs/2604.12617
- [22]Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. Self-consistency improves chain of thought reasoning in language models. arXiv preprint arXiv:2203.11171, 2022.arxiv.org/abs/2203.11171
- [23]Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, et al. Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems, 35:24824–24837, 2022.
- [24]Jingfeng Yao, Bin Yang, and Xinggang Wang. Reconstruction vs. generation: Taming optimization dilemma in latent diffusion models. In 2025 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 15703–15712. IEEE, 2025.arxiv.org/abs/2501.01423



