Momentum Guidance: Plug-and-Play Guidance for Flow Models¶
Conference: ECCV 2026
Paper: ECCV page
Area: Image Generation
Keywords: flow model guidance, classifier-free guidance, Rectified Flow, inference-time guidance, velocity momentum
TL;DR¶
The paper proposes Momentum Guidance (MG): it treats an exponential moving average of past model velocities along the sampling trajectory as a "smoother reference branch" and extrapolates the current velocity away from it, giving flow models the same sharpening effect as CFG without any extra network evaluation, auxiliary model, or unconditional branch — and it stacks directly on top of CFG.
Background & Motivation¶
Continuous-time generative models — diffusion models and Rectified-Flow-style flow models — already synthesize images, audio and video at high quality, yet pretrained flow models are almost never used in their raw conditional form: samples drawn without guidance tend to look diffuse, with blurry texture and little fine-grained detail. This is not specific to flow models; it is the familiar regression-to-the-mean effect, where a predictor trained under a mean-squared objective averages over the many plausible outputs consistent with a condition. Image restoration has long recognised that such averaging produces oversmoothed results with weak high-frequency texture, and language generation reshapes the predictive distribution in a similar spirit through temperature scaling and nucleus sampling. The paper traces this oversmoothing to two concrete sources: first, the network's regression target (velocity, clean data, or noise) is a conditional mean under MSE, so it averages over multiple plausible outcomes; second, the EMA of model parameters widely used in training averages model states along the optimisation trajectory and further smooths the learned velocity field. Together they bias pretrained models toward blurry, low-detail outputs.
If blur comes from averaging, inference-time guidance is the reverse operation — pushing predictions away from a smoother reference estimate. CFG takes the conditional velocity as the primary prediction and the unconditional velocity as the reference (the unconditional branch is smoother because it averages over the conditioning variable), while Autoguidance swaps that branch for a weaker model such as an earlier checkpoint or a smaller network. Both can be read as de-smoothing the model's predictions. The tension lies in where the reference comes from: obtaining that smoother reference costs CFG an extra unconditional forward pass at every step (doubling the NFE), while Autoguidance requires an auxiliary checkpoint and additional memory — and large open models such as FLUX.1-dev or Qwen-Image simply do not release such weak checkpoints, which makes Autoguidance impractical in many real settings.
The angle this paper takes is that only a smoother reference is needed, and the marginal-preservation property of Rectified Flow guarantees that earlier (noisier) points along the trajectory already correspond to smoother marginals — so the sampler's own history supplies that reference and nothing external is required. Core idea: maintain a "velocity momentum" during sampling — an exponential moving average of past model velocities — and extrapolate the current velocity away from it, letting trajectory history play the role of CFG's unconditional branch or Autoguidance's auxiliary model, yielding training-free, plug-and-play guidance at zero extra network evaluations.
Method¶
Overall Architecture¶
MG acts purely at inference time: the input is a pretrained Rectified Flow velocity network plus a standard sampler (by default the Euler sampler on a uniformly discretised time grid), and the output is the final sample. Beyond the usual flow state \(Z_t\), it maintains only a velocity momentum \(m_t\) — an EMA buffer of the same shape as \(Z_t\), initialised to the model velocity at the first step. Each subsequent step then does two independent things: it queries the model once as usual to get the current velocity \(v_{t_i}\), and then (1) advances the flow state with an extrapolated velocity — the current velocity plus \(\alpha\) times the gap between the current velocity and the momentum — and (2) updates the momentum by EMA with the current velocity for later steps. There is no training, no auxiliary network, and no additional function evaluation; the only hyper-parameters are the extrapolation strength \(\alpha\) and the momentum decay \(\beta\).
The reason this works is the marginal-preservation property of Rectified Flow. With a Gaussian source, the marginal at time \(t\) can be viewed as the data distribution convolved with a Gaussian kernel whose scale varies with \(t\), so smaller \(t\) means stronger smoothing; and the velocity field is tied to the marginal's score function through a known identity, so velocity estimates inherit the same smoothness ordering as the marginals: velocities from early in the trajectory correspond to smoother distributions, while later ones approach the sharp, data-like distribution. The "smooth reference" CFG tries to obtain from an unconditional branch has therefore been sitting on the sampler's own path all along; MG simply stores it as an EMA.
Importantly, MG does not aim to replace CFG but to be orthogonal to it: when used together, the CFG-extrapolated velocity is taken as MG's base velocity, and MG extrapolates once more on top of it, with CFG kept active at every timestep. The two push in different directions — CFG moves away along the "average over the conditioning variable" direction, MG away along the "trajectory history" direction — so they compose. (The guidance term is a pure update-rule design that prose plus formulas convey fully, so no flowchart is forced here.)
Key Designs¶
1. Velocity momentum: using the sampler's own history as a "smoother reference branch"
The pain point this targets is very concrete: every existing de-smoothing guidance scheme needs a smoother reference prediction first, and the two routes to it — CFG's extra unconditional forward pass, Autoguidance's weak checkpoint — cost either double the NFE or a dependency on auxiliary weights that often do not exist. MG's observation is that the reference need not come from another model or another branch; it can come from the past of the same trajectory. The justification is the smoothness ordering above: the velocities computed at earlier, higher-noise steps were conditional means of smoother marginals, so aggregating them yields a naturally smooth reference.
The aggregation is an exponential moving average, in the same spirit as momentum in optimisation:
where \(\beta \in [0,1)\) controls how fast the velocity history decays. A larger \(\beta\) biases the reference toward earlier, smoother estimates, producing a steadier but more stale momentum; a smaller \(\beta\) keeps the reference closer to the current step. EMA is preferred over simply reusing the previous step's velocity because a single-step velocity is both noisy and reflects the smoothness of only one instant, whereas the EMA blends estimates from several noise levels into a more stable and more clearly smoothed reference — the same rationale by which first-order momentum suppresses gradient noise in optimisation. The paper visualises the effect with the "implied clean-data prediction" \(\hat{X}_{1|t}\) — the conditional data mean implied by the current velocity field (see below). On FLUX.1-dev with \(\alpha=0.6,\ \beta=0.8\), MG's estimates develop clearer object structure and more stable colour early in the trajectory than a CFG=1.5 baseline, and the extrapolation direction \((v_t - m_t)\) behaves tellingly: it first aligns with coarse object geometry and only gradually concentrates on high-frequency details such as petal boundaries and dew droplets as the flow approaches the data distribution. In other words, the momentum absorbs what is already settled and smooth, while the extrapolation term carries what is newly emerging.
2. Extrapolated update: squeezing the sharpening into one vector addition for zero extra NFE
Given the reference, the sharpening step is formally identical to CFG — except that the thing being pushed away from is now the momentum \(m_{t_i}\):
with \(\Delta t = t_{i+1}-t_i\) and \(\alpha \ge 0\) governing how far the update extrapolates toward sharper distributions; \(\alpha = 0\) reduces to the standard Euler update. The crucial engineering property is that \(v_\theta(Z_{t_i},t_i)\) is the very forward pass the base sampler would have computed anyway — MG adds only a same-shaped subtraction and addition, so the number of function evaluations per step, the intermediate activations held in memory, and everything scaling with batch size are unchanged. The only extra state is one momentum buffer shaped like the flow state: \(32\times32\times4\) latents on ImageNet-256 (SD encoder, DiT-XL backbone) and on the order of \(128\times128\times16\) for 1024² FLUX.1-dev — negligible relative to model parameters and activations. This is precisely where MG parts ways with CFG: CFG needs two evaluations per step, MG needs one.
Two implementation details accompany the update: MG uses an unbiased EMA correction (an Adam-style bias correction that cancels the bias of the momentum in the first few steps) and momentum normalisation (so that the extrapolation term does not blow up when the momentum's magnitude and the current velocity's scale disagree); ⚠️ the exact forms of both are not spelled out in the main text and should be checked against the appendix. Extrapolation is also not "the stronger the better": too large an \(\alpha\), or too persistent a momentum (too large a \(\beta\)), over-corrects the velocity and degrades quality — which is part of why momentum normalisation is needed.
3. Orthogonal, plug-and-play composition with CFG, plus the guidance interval
MG is designed not to compete with CFG but to slot into an existing pipeline. When combined, the base velocity becomes the CFG-extrapolated velocity, CFG stays active throughout, and MG extrapolates once more on top of it. This means MG can be attached very lightly to any sampling loop that uses a conditional velocity: no retraining, no network changes, no extra conditioning inputs. The benefit is verified systematically on ImageNet-256: across every guidance strength from CFG = 1.0 (no CFG) to 2.0, and across all three sampling budgets (16/32/64), MG lowers FID — and it does not merely shift the optimal CFG, it depresses the whole FID curve. On the precision–recall plane it raises precision while better preserving recall, pushing the Pareto frontier outward, something that simply increasing CFG (trading recall for precision) cannot do. It also stacks on methods that already perform "bad-model guidance": adding MG on top of RAE (a guided baseline leveraging an additional vision foundation model) still improves it.
Following the Guidance Interval idea, the paper also sweeps the application interval of MG over \([0.1,0.6]\), \([0.1,0.7]\), \([0.2,0.6]\) and \([0.0,1.0]\), showing that "when to guide" and "how strongly to guide" are two independently tunable dimensions. Notably the interval restriction is used only on ImageNet; in the text-to-image experiments on SD3 / FLUX.1-dev, MG is applied at all timesteps with no interval cropping, tuning only \(\alpha\) and \(\beta\) — which suggests the default configuration is stable enough that no model-specific schedule redesign is needed.
Loss & Training¶
MG is a purely inference-time method: it introduces no new training objective and fine-tunes no parameters. The guided base model is still trained with the standard Rectified Flow mean-squared-error objective — predicting the displacement \(X_1 - X_0\) from noise to data (equivalently, the conditional expected velocity along the interpolation path \(X_t = tX_1 + (1-t)X_0\)). All of MG's "tuning" therefore happens at inference and concerns three quantities:
- \(\alpha\) (extrapolation strength) and \(\beta\) (EMA decay): on ImageNet-256 the paper grid-searches \((\alpha,\beta)\) per (CFG scale, NFE budget) pair using FID-10K and reports the winners on FID-50K; on SD3 / FLUX.1-dev only these two are tuned; on HunyuanVideo they are fixed at \(\alpha=0.6,\ \beta=0.2\) with no exhaustive search.
- The application interval (optional): the four time intervals listed above were swept on ImageNet.
The base sampler is the standard Euler sampler on a uniformly discretised time grid (text-to-image runs reuse each model's default schedule). The paper states explicitly that MG's extra memory is one EMA buffer shaped like the flow state, and its extra compute is elementwise addition and subtraction — the NFE is unchanged.
Key Experimental Results¶
Main Results¶
Three settings are evaluated: ImageNet-256 (official Rectified Flow codebase with an improved DiT-XL and an SD encoder for latents) for systematic ablation; large-scale text-to-image (SD3, FLUX.1-dev) on 3,200 HPSv2 prompts at 1024², scored by HPSv2.1 and ImageReward; and text-to-video (HunyuanVideo, VBench protocol, 540p / 65 frames, shared random seed 42 across methods).
Table 1: FID-50K on ImageNet-256 across guidance strength and sampling budget (\(w=1\) is MG without CFG; the rest is MG on top of CFG)
| Guidance setting | Method | NFE=16 | NFE=32 | NFE=64 |
|---|---|---|---|---|
| \(w=1.0\) (no CFG) | Baseline | 7.76 | 5.57 | 4.75 |
| + MG | 4.46 | 3.58 | 3.26 | |
| \(w=1.2\) | CFG | 3.26 | 2.20 | 1.89 |
| CFG + MG | 2.00 | 1.71 | 1.60 | |
| \(w=1.4\) | CFG | 2.38 | 2.04 | 2.03 |
| CFG + MG | 1.85 | 1.90 | 1.99 | |
| \(w=1.6\) | CFG | 3.13 | 3.17 | 3.34 |
| CFG + MG | 2.62 | 2.89 | 3.17 | |
| \(w=1.8\) | CFG | 4.48 | 4.76 | 4.99 |
| CFG + MG | 3.49 | 3.96 | 4.62 | |
| \(w=2.0\) | CFG | 5.94 | 6.36 | 6.62 |
| CFG + MG | 4.62 | 5.27 | 6.08 |
The paper reports an average FID reduction of 36.54% without CFG and 25.42% when stacked on CFG = 1.2 (both averaged across sampling settings; the raw per-setting numbers are in the table above and can be checked directly). The strongest entry in Table 1 is CFG = 1.2 with 64 NFEs, which is also the best FID in the table.
Table 2: Comparison with guidance baselines (ImageNet-256, FID/IS/Precision/Recall, 50K samples)
| NFE | Method | FID-50K ↓ | IS ↑ | Precision ↑ | Recall ↑ |
|---|---|---|---|---|---|
| 16 | CFG-int (\(\omega\)=1.4) | 2.352 | 249.85 | 0.791 | 0.612 |
| 16 | CFG-int + MG (\(\omega\)=1.4) | 1.553 | 268.03 | 0.799 | 0.636 |
| 16 | ADG (\(\omega\)=1.4) | 2.324 | 275.28 | 0.827 | 0.570 |
| 16 | CFG++ (\(\omega\)=0.6) | 2.620 | 368.80 | 0.842 | 0.572 |
| 32 | CFG-int (\(\omega\)=1.4) | 1.642 | 264.75 | 0.800 | 0.626 |
| 32 | CFG-int + MG (\(\omega\)=1.4) | 1.408 | 274.99 | 0.801 | 0.633 |
| 64 | CFG-int (\(\omega\)=1.4) | 1.462 | 271.34 | 0.803 | 0.625 |
| 64 | CFG-int + MG (\(\omega\)=1.4) | 1.380 | 277.73 | 0.802 | 0.630 |
| 50/2 | RAE† (\(\omega\)=1.0) | 1.535 | 241.56 | 0.791 | 0.644 |
| 50/2 | RAE† + MG (\(\omega\)=1.0) | 1.376 | 242.83 | 0.790 | 0.642 |
CFG-int is the interval-schedule baseline that activates CFG only on \(t\in[0.125,1]\), whereas MG is applied over the full interval \([0,1]\); † marks baselines that use vision foundation models beyond the base flow model (RAE). ADG and CFG++ are reported at their best FID after searching the suggested hyper-parameters. MG lowers FID below CFG-int at every matched NFE, and reaches 1.553 at only 16 steps, better than the 32-step baseline (1.642).
Table 3: Transfer to text-to-image and text-to-video (SD3 28 steps / FLUX.1-dev 50 steps / HunyuanVideo)
| Model | Metric | Baseline | + MG |
|---|---|---|---|
| SD3 | HPSv2.1 @ CFG=1 / @ CFG=5 | 22.87 / 30.22 | 27.37 / 30.62 |
| SD3 | ImageReward @ CFG=1 / @ CFG=5 | −0.093 / 1.099 | 0.395 / 1.111 |
| FLUX.1-dev | HPSv2.1 @ CFG=1 / @ CFG=3 | 24.40 / 31.28 | 24.80 / 31.29 |
| FLUX.1-dev | ImageReward @ CFG=1 / @ CFG=3 | 0.345 / 1.094 | 0.391 / 1.096 |
| HunyuanVideo | VBench quality / semantic / total | 0.842 / 0.716 / 0.816 | 0.845 / 0.717 / 0.819 |
On both text-to-image models MG improves HPSv2.1 at every CFG scale (roughly 0.2–0.4 on SD3 for CFG = 2–5, and a smaller 0.02–0.07 on FLUX.1-dev); ImageReward improves in most configurations with very slight drops at the larger CFG values. On video, MG uses a fixed \(\alpha=0.6,\ \beta=0.2\) with no prompt-specific tuning, lifting the VBench total score from 0.816 to 0.819.
Ablation Study¶
Table 4: Behaviour of the hyper-parameters and the sampling budget (ImageNet-256; FID-10K for selection, FID-50K for reporting)
| Config / variable | Observation | Note |
|---|---|---|
| \(\alpha = 0\) | Reduces to the original sampler (or original CFG) | The boundary of the landscape in Fig. 4 |
| \(\alpha\) increased moderately from 0 | FID drops over a wide region | The extrapolation is indeed de-smoothing |
| \(\alpha\) too large | FID rises again | Velocity is over-corrected and quality degrades |
| \(\beta\) too large (too persistent) | FID rises again | Reference is too stale; the sharpening direction drifts |
| Best region | Moderate \(\alpha\) + small-to-medium \(\beta\) | Strong extrapolation prefers a shorter momentum memory |
| NFE = 16 | Most \((\alpha,\beta)\) settings already beat the baseline | The gain is largest at small sampling budgets |
| MG application interval (4 settings swept) | Best FID taken | Motivated by Guidance Interval |
Table 5: Per-dimension VBench comparison (HunyuanVideo, \(\alpha=0.6,\beta=0.2\), 540p)
| Dimension | Baseline | + MG | Dimension | Baseline | + MG |
|---|---|---|---|---|---|
| Subject Consistency | 0.962 | 0.962 | Multiple Objects | 0.679 | 0.708 |
| Motion Smoothness | 0.992 | 0.991 | Object Class | 0.731 | 0.765 |
| Dynamic Degree | 0.639 | 0.653 | Spatial Relation | 0.871 | 0.885 |
| Background Consistency | 0.974 | 0.975 | Temporal Flicker | 0.695 | 0.681 |
| Scene | 0.387 | 0.356 | Appearance Style | 0.991 | 0.991 |
| Overall Consistency | 0.266 | 0.265 | Temporal Style | 0.241 | 0.240 |
| Aesthetic Quality | 0.623 | 0.624 | Human Action | 0.930 | 0.920 |
| Imaging Quality | 0.653 | 0.668 |
Key Findings¶
- MG depresses the whole curve rather than shifting the optimal CFG. The ablation in Fig. 3 shows that at 16/32/64 steps the best MG configuration sits below the vanilla CFG curve at every budget, and the shaded band (the range spanned by the remaining \((\alpha,\beta)\) choices) shows that most configurations beat the baseline — the method is not hyper-parameter fragile. The gain grows as the budget shrinks, and is largest at NFE = 16, which matters most for few-step generation.
- It changes how precision and recall are traded off. Increasing CFG alone necessarily buys precision with recall; MG raises precision while holding or even raising recall (in Table 2 precision is roughly flat while recall is consistently higher), so the Pareto frontier expands outward instead of sliding along the curve. This is the paper's central empirical claim.
- The reference source is interchangeable and composable. Adding MG on top of RAE — a guided method that already consumes an extra vision foundation model — still helps (1.535 → 1.376), suggesting that "trajectory history" and "weaker or extra model" carry complementary information as references.
- The optimum sits at "moderate extrapolation with a short memory." Raising \(\alpha\) from zero helps broadly, but too large an \(\alpha\) or too large a \(\beta\) over-corrects; the pattern is consistent at 16/32/64 steps, hinting that strong extrapolation needs recent smooth information rather than a long history.
- Gains vary with model scale and task. The FID improvement on ImageNet-256 is large (tens of percent), whereas HPSv2.1 on SD3 / FLUX.1-dev improves by only tenths of a point (especially little on FLUX.1-dev); on video the total score rises by only 0.003, with small drops on Scene, Temporal Flicker and Human Action. In short, MG is most effective in the small-model, few-step, class-conditional regime, and on large models with default schedules it is more of a "reliably non-negative" incremental gain.
Highlights & Insights¶
- It removes the hidden premise that guidance needs an external reference branch. CFG uses an unconditional branch, Autoguidance a weak checkpoint, SAG/PAG perturbed attention — all assume the reference must come from somewhere outside the model. MG points out that the sampling trajectory's own past already is that reference (thanks to RF's marginal-preservation smoothness ordering), a clean observation that buys a hard advantage: zero extra NFE.
- The momentum analogy from optimisation is placed in exactly the right spot. Here momentum does not accelerate convergence; it constructs a low-variance, provably smoother reference — EMA acts as a temporal low-pass filter. That trick transfers to the analysis of any iterative sampler.
- The \(\hat{X}_{1|t}\) diagnostic is a reusable analysis tool. Inspecting how guidance reshapes the trajectory in image space (via the implied clean-data prediction) explains where along the flow guidance does its work far better than looking at final samples alone; it also yields the counter-intuitive finding that the extrapolation direction first carries coarse contours and only later high-frequency detail, i.e. the momentum absorbs what is already settled while the extrapolation term carries what is new.
- Concrete transferable hooks: (1) any generative model with an ODE/SDE sampler (video, 3D, audio, TTS) can hang this EMA momentum on its loop, since it only requires a velocity/score network queried step by step; (2) few-step distilled and consistency models also iterate over multiple steps, and the largest gains here occur precisely in the small-NFE regime, so they are worth testing; (3) because \(m_t\) carries coarse structure while \((v_t - m_t)\) carries detail, the two can be scaled separately, opening a route to controllable generation that "adds detail without changing composition."
Limitations & Future Work¶
- The paper has no dedicated limitations section; the conclusion emphasises simplicity and generality. The points below are observations from reading.
- \(\alpha\) and \(\beta\) remain hand-tuned hyper-parameters found by grid search. On ImageNet they are searched for every (CFG, NFE) pair via FID-10K, and on HunyuanVideo a single setting is simply fixed. What is missing is a trajectory-adaptive schedule: mechanically, early steps should lean on the smoother reference (larger \(\beta\) for stable coarse structure) and later steps should tighten it (smaller \(\beta\) to sharpen detail), whereas the current implementation uses constants throughout.
- The momentum assumption may weaken at 16 steps. MG relies on "earlier velocities are smoother," but with few-step sampling the gaps between consecutive time points are large and only a handful of points are available for the EMA, so the averaging behaves differently from the many-step case. The paper shows the gain is largest at NFE = 16 but offers no explanatory analysis of how the optimal \(\beta\) relates to step count.
- Gains are modest on large models, and a few metrics regress. On SD3/FLUX.1-dev the HPSv2.1 improvement is on the order of 0.02–0.07, and VBench's Scene (0.387 → 0.356), Temporal Flicker and Human Action also dip slightly; the paper reports "improvement in most configurations" but does not discuss the source of these regressions, nor does it offer any evaluation beyond preference metrics.
- A theoretical characterisation is missing. MG and CFG are described as orthogonal, but this is verified only empirically: the paper does not derive which modified distribution or score function MG sharpens toward, nor how \(\alpha\) relates to a sampling temperature. With that analysis, \(\alpha\) and \(\beta\) would not need grid search.
- Improvement directions: make \(\alpha\) and \(\beta\) functions of flow time with light adaptivity (e.g. scaling the extrapolation strength by the angle between the current velocity and the momentum — a small angle means the directions agree and one can push harder); replace the single-step EMA with an explicit low-pass filter or polynomial extrapolation along the trajectory; combine with methods that modify the guidance update direction, such as ADG or CFG++, and validate; and verify on few-step distilled and consistency models whether the gains persist.
Related Work & Insights¶
- vs CFG: CFG extrapolates along "conditional velocity − unconditional velocity," with the reference costing an extra forward pass. MG extrapolates along "current velocity − trajectory velocity momentum," with the reference coming from history that was already computed. MG needs one evaluation per step (CFG needs two) and does not require the model to support an unconditional branch; in exchange it adds a hyper-parameter \(\beta\) to tune, and the reference's "smoothness" is implicitly set by \(\beta\) and the step size rather than having the explicit semantics of an unconditional branch.
- vs Autoguidance: both replace the reference with a "worse/smoother" prediction, but Autoguidance's reference is a separately trained weak model requiring an extra checkpoint (rarely released for large open models) and extra memory, whereas MG's reference is produced by the sampling process itself, making it far more plug-and-play. Conversely, Autoguidance's reference quality is more controllable, while MG's depends on \(\beta\) and on the discretisation of the trajectory.
- vs Guidance Interval / CFG++ / ADG: these change the schedule, constraint, or direction of the guidance update (which timesteps to guide on, constraining the update to a manifold, replacing extrapolation with rotation in the angle domain) while still using CFG's unconditional branch as the reference. MG changes where the reference comes from, making it an orthogonal line of improvement; the paper measures the stacking effect (MG on top of CFG-int and RAE both improve further). Conversely, ADG's argument that latent guidance should rotate rather than extrapolate suggests MG's linear extrapolation may face similar direction issues in high-dimensional latent spaces — worth testing further.
- vs self-attention guidance such as SAG / PAG / SEG: these construct degraded/smoothed predictions inside the same network (perturbed attention, smoothed attention energy) and indeed need no auxiliary model, but they modify the network internals and require an additional perturbed evaluation. MG only touches the sampling loop and never the network, so it is more broadly compatible and adds no evaluation at all.
Rating¶
- Novelty: ⭐⭐⭐⭐ Moving the "smoother reference" from outside the model to the sampling trajectory itself is a simple idea with genuine insight, and it buys a hard engineering advantage: zero extra NFE
- Experimental Thoroughness: ⭐⭐⭐⭐ Covers ImageNet-256, SD3, FLUX.1-dev and HunyuanVideo across image and video domains, with systematic ablations (CFG × NFE grid, \(\alpha\)/\(\beta\) landscape, interval sweep) and a convincing precision–recall frontier analysis; but no full same-budget comparison against the newest guidance methods, and gains on large models are small
- Writing Quality: ⭐⭐⭐⭐ The motivation chain (two sources of oversmoothing → guidance as de-smoothing → trajectory history as the reference) is clearly told and the pseudocode is only nine lines; some formulas are corrupted in the cached text, and a few implementation details (unbiased EMA correction, momentum normalisation) are left to the appendix
- Value: ⭐⭐⭐⭐ Training-free, no retraining, zero extra evaluations, and stackable on CFG — an extremely low practical barrier, usable by anyone sampling with a flow model; the main caveat is that the hyper-parameters still need per-model grid search