FastFlow: Accelerating The Generative Flow Matching Models with Bandit Inference
Authors: Divya Jyoti Bajpai
Dhruv Bhardwaj
Soumya Roy
Tejas Duseja
Harsh Agarwal
Aashay Sandansing
Manjesh Kumar Hanawal
Venue: ICLR 2026 Poster (2026)
Keywords: generative modelling
faster inference.
Primary area: generative models
TL;DR: Adaptive inference method for accelerating flow matching based visual generation.

Abstract: Flow-matching models deliver state-of-the-art fidelity in image and video generation, but the inherent sequential denoising process renders them slower. Existing acceleration methods like distillation, trajectory truncation, and consistency approaches are static, require retraining, and often fail to generalize across tasks. We propose FastFlow, a plug-and-play adaptive inference framework that accelerates generation in flow matching models. FastFlow identifies denoising steps that produce only minor adjustments to the denoising path and approximates them without using the full neural network models used for velocity predictions. The approximation utilizes finite-difference velocity estimates from prior predictions to efficiently extrapolate future states, enabling faster advancements along the denoising path at zero compute cost. This enables skipping computation at intermediary steps. We model the decision of how many steps to safely skip before requiring a full model computation as a multi-armed bandit problem. The bandit learns the optimal skips to balance speed with performance. FastFlow integrates seamlessly with existing pipelines and generalizes across image generation, video generation, and editing tasks. Experiments demonstrate a speedup of over $2.6\times$ while maintaining high-quality outputs. The source code for this work can be found at https://github.com/Div290/FastFlow.

Published as a conference paper at ICLR 2026
FASTFLOW: ACCELERATING THE GENERATIVE FLOW MATCHING MODELS WITH BANDIT INFERENCE
Divya Jyoti Bajpai', Dhruv Bhardwaj'. Soumya Roy?, Tejas Duseja², Harsh Agarwal', Aashay Sandansing'. Manjesh K. Hanawal'
IIniaa Institute of Technology Bombay AAmaoon
{divyajyoti petaadyoti.bappai.. 23d1594, mhanawal]eiitb. in (dhruvbrd, dusejat, hragarwl [eagarawwammazoncccom @eamazon com meetsouumarooy@mma com
ABSTRACT
Flow-matching models deliver state-of-the-an fidelity in image and video genera- tion, but the inherent sequential denoising process renders them slower. Existing acceleration methods like distillation, trajectory truncation, and consistency ap- proaches are static, require retraining, and often fail to generalize across tasks, We propose FastFlow, plug-and-play adaptive inference framework that accel- erates generation in flow matching models. FastFlow identifies denoising steps that produce only minor adjustments to the denoising path and approximates them without using the full neural network models used for velocity predictions. The approximation utilizes finiteddifference velocity estimates from prior predictions efficiently extrapolate future states, enabling faster advancements along the de- noising path at zero compute cost. This enables skipping computation at inter- mediary steps. We model the decision of how many steps to safely skip before requiring full model computation as a multi-armed bandit problem. The bandit learns the optimal skips to balance speed with performance. FastFlow integrates seamlessly with existing pipelines and generalizes across image generation, video generation, and editing tasks. Experiments demonstrate speedup of over 2.6x while maintaining high-quality outputs. The source code for this work can be found at/ntps:://sottt /ttp::://gtthb. con/Divv90/Fast72
INTRODUCTION
Recently, flow-matching (FM) models Lipman et al. (2022) have emerged as an effective approach for visual generation, offering both high fidelity and computational efficiency. By learning contin- uous vector fields that transport simple distributions to complex data distributions, they generate samples along smooth, iterative trajectories. Unlike diffusion models Croitoru al. (2023), FM achieves faster convergence and fewer sampling steps while maintaining comparable or better per- ceptual quality. This framework allows precise control over the generative process, where increas- ing the number of flow integration steps typically improves perceptual quality in both images and videos. Despite these advances, inference speed remains major bottleneck Yan al. (2024); Davtyan et al. (2025) due to the several reverse denoising steps that are performed sequentially. As model sizes grow and generation tasks demand higher resolutions or longer video durations, the computational cost becomes prohibitive, resulting in substantial latency during inference.
Several acceleration strategics- as distillation Luhman & Luhman (202 Yan et al. (0024); Kornilov et al. (2024), trajectory truncation Dhariwal & Nichol (2021) Lu et al. (2022); Liu et al. (2025a). and consistency training Yang et al. 2202)) Zhang & Zhoul Dao et al. (2025) have been proposed. While effective, these approaches have limitations: they require additional training phases, rely on large-scale data, and incur non-trive computational overhead. Moreover, they apply uniform inference schedule across all inputs, overlooking the fact that some samples may converge

---

Published as a conference paper at ICLR 2026
Compute Skipped
Compute
Approx.
Approx.
Approx.
Compute
Reward
Approx
0 4 6
0 4
Figure I: Overview of our method. At each step, the multi-armed bandit (MAB) selects the number of steps to approximate the trajectory. The bandit receives reward proportional to the number of steps successfully approximated, while deviations from the computed velocity incur a penalty. This adaptive strategy allows the model to balance efficiency and accuracy across the trajectory.
with fewer steps, while others require longer trajectories to maintain fidelity. This one- poo-size-fits-lle design leads to inefficiencies, as many intermediate steps contribute little to the final quality.
In this work, we propose novel adaptive inference framework that reduces cost by approximat- ing redundant intermediate denoising steps instead of fully computing them. Our approach builds on the observation that flow-matching models often follow approximately linear denoising trajec- tories Lipman et al. (2022) as they are trained to follow linear paths. Leveraging this property, we approximate future states using Taylor series expansions and local velocity estimates derived from the model dynamics, thereby reducing the number of expensive forward passes. We show that our approximation is sound by establishing theoretical bound on the deviation of the final state of the approximate trajectory from that of the full model. When approximation fails to maintain fidelity, the system reverts to full model predictions. The central challenge, therefore, is determine when approximation suffices and when precise computation is necessary.
We address this challenge by formulating the decision process as multi-armed bandit (MAB) problem. At each step, bandit adaptively selects how many future steps can be approximated before requiring the next full model evaluation. Each arm corresponds to the number of steps to approximate, and subsequent full evaluation provides feedback to assess approximation accuracy. The reward balances two competing objectives: (i) reducing computational cost by skipping evalu- ations, and (ii) limiting deviation from the true model trajectory. This adaptation allows the system to adjust inference complexity on a per-sample basis, learning over time when approximation is reliable and when exact prediction is necessary. Fig. D illlusttasss our method (details in Section 3.2
In existing caching-based acceleration approaches, TeaCache Liu et al. (022a)), caches residuals and re-uses them at later inference steps. However, they based criteria to decide if cache can be reused. In our experiments, we also observed that when specific speedup (c.g., 2x) is required, TeaCache unintentionally ends up with a fixed caching schedule across generations, consistently skipping the same subset of timesteps regardless of in- put complexity. Finally, TeaCache relies on handcrafted polynomial fitting of noisy inputs, which typically requires prior model- or task-specific knowledge to perform optimally (see Appendix A.
hand-crafted relative-L.1 distance-
Our approach both efficient and adaptive: at every timestep, the bandit dynamically learns to minimize redundancy by adapting to the complexity of the data distribution. Unlike prior accelera- tion strategics, our method introduces zero retraining overhead, requires no auxiliary networks, and integrates scamlessly as true plug-and-play solution. In summary, our key contributions are:
We propose FastFlow, a method to accelerate visual generation skipping redundant de- noising steps, while using simple Euler-solver for flow, and first-order Taylor series expansion for velocities. The trade-off of speed v/s error is set up as a Multi-Armed Ban- dit (MAB) objective, enabling the model dynamically learn when full computation is necessary.
We establish a theoretical bound the deviation of the final state from the approximated trajectories with that obtained by the full model (see Thm. 3.I).
Our framework is model-agnostic, requires retraining auxiliary networks, and can be seamlessly integrated into existing flow-matching pipelines, making it a practical and general solution for faster visual generation.
2

---

Published as a conference paper at ICLR 2026
Extensive experiments across image generation, video generation, and image editing demonstrate more than 2.6x speedup while maintaining generation quality, showing that method achieves acceleration without sacrificing fidelity.
2 RELATED WORKS
Recently, Flow Matching Lipman et al. (2022;
: Dao et al. (2023): Labs et al. (2025) : Deng et al.
(2025) has gained prominence as a strong counterpart to diffusion models Croitoru al. (2023);
Xing et al. (2024); Yang et al. (2023); [hhu et al. (2023), since it establishes deterministic corre- spondence between random noise and data. This benefits applications such as image inversion Deng al. (2024), editing Wang et al. (2024), and video synthesis Kong et al. (2024); Wan et al. 2025 where reduced randomness leads to faster sampling with fewer neural evaluations. Multimodal van- ants, like FlowTok He al. (2025), compress text and images into joint token space improve inference speed, and large-scale systems like FLUX. Labs et al. (2025) demonstrate that flows can approach the performance of diffusion models at low compute cost. In video domains, Pyramidal Flow Matching Jin et al. (2024) cuts down complexity using hierarchical generation.
Nonetheless, the reliance iterative sampling continues hinder real-time deployment, To miti- gate this, most acceleration work has involved retraining- based schemes Lee et al. (2023); Bartosh
al. (202). Knowledge distillation methods Luhman & Luhman (2021); Song el al. (2023); Lu
et al. (022bb]; Kornilov et al. (2024): [Salimans & Ho (2022), including InstaFlow Liu et al. (2023),
LeDiFlow Zwick al. (2025) and Diff2Flow Schusterbauer et al. (2025). leverage diffusion priors
for one- or few-step generation, while PeRFlow Yan et al. (2024) simplifies trajectories via piece- approaches Dhariwal & Nichol (202T); [u et al.) (2022); Shaul et al. (2023), such TeaCache Liu al. (2025a). skip redundant steps using timestep embed- dings, whereas consistency-base methods Yang et al. (2024); Zhang & Zhou (2025); ); Haber et al. (2025); ; Dao et al. (2025) combine adversarial and consistency objectives for high-fidelity few-step synthesis. Additionally, higher-order pseudo-numerical solvers, as in PNDM Liu et al. (2022a), improve the speed quality tradeoff in diffusion inference.
wise rectified flows. Sampling-acceleratn
While existing methods remain static and often struggle to generalize across different models, tasks, and datasets, FastFlow offers universally compatible solution for any FM-based model. It dynami- cally adapts, identifying and skipping redundant steps based on the incoming data distribution, while the finit-ddifference approximation boosts efficiency achieve significant speedups. Remarkably, FastFlow is training-free and incurs negligible computational overhead, making it both practical and highly effective well-world scenarios.
METHODOLOGY
In this section, we provide details of method, starting with detailed description of the flow matching models and then detailing our application to the flow matching models.
3.1 FLOW MATCHING OVERVIEW
Consider two probability densities To and ग on Rd representing the source and target distributions. Flow Matching (FM) seeks to learn a deterministic, time-continuous flow that transports samples from Ty Tl, governed by an ordinary differential equation (ODE). Formally, FM introduces time-dependent velocity field v Rd x [0, 1] Rd giving rise to the initial value problem
dx: dt
v(r,,)). t), To No. te [0,1].
Here, Fz. E d denotes the sample state at time t, while the velocity field v(z,, t), typically pa- rameterized by neural network, is optimized such that the terminal distribution at f = 1 matches TT. This ODE defines flow map b (2o) that evolves samples along continuous trajectories, with @ (mr) ~ Ti. The central task FM is thus to learn a velocity field u(z,, t) that realizes this transport.
Inference: As closed-form solutions for 2, are generally unavailable for learned velocity fields, numerical solvers required. FM most often employs the forward Fuler method for its simplicity
3

---

Published as a conference paper at ICLR 2026
.x and efficiency. The interval [0, 1] is discretized into steps {to 0, 0,......, 1}, possibly with non-uniform intervals. Starting from 2n ~ To, the trajectory is advanced as
Eias1 = Ite. + Aty. ((Itett)); At = tx+1 tk.
(2)
This discretization approximates the continuous flow with a finite sequence of updates, where each step moves the sample in the direction given by the velocity field. Owing to its low computational cost and suitability for parallel hardware, Euler's method remains the default choice in most FM implementations.
For our method, we need to find all the redundant denoising steps, as there will be many due to straight line trajectories that are learned during training and then replace them using some good approximation the true model predictions.
3.2 OUR METHON
Approximating velocity. To accelerate sampling, we look at a simple mechanism to approximate velocities at different timesteps, instead of re-computing from the model. Using the first-order Taylor series expansion for rz-A: and taking a time derivative results in:
o(z+Ai,, t + At) == dr--st v(11,t) + At dv(x,,t) dt
(3)
dt
A natural direction for approximation is to use the most recent velocity estimate computed from the model assuming du(z,,t) - O. In previous works, this is accompanied by static criteria to decide whether re-computation from the model is necessary.
However, we find that even in the regions where velocity seems to be smooth and linear, it makes minor adjustments, ignoring those leads to accumulated errors during generation (see Figure making above strategy overly simplistic for aggressive skipping.
Instead of re-using the same velocity estimate, we update using finite-difference approximation of Eq. 3 utilizing the past velocity estimates. We write this approximation at discrete time steps as follows (where p < k):
o ( tx+1) ss u(Tk, tx) + At v(Iea tx) ( tp)
(4)
tx tv
Below we establish bound on the deviations in the flow value of the approximated velocity esti- mates while skipping set of time-steps during inference with that obtained by the full model.
Theorem 3.1. Let {str"e) denote the trajectory obtained using the exact velocity field with the forward Euler method, and let { [pprox } be the trajectory where velocity evaluations are skipped at subset of steps S [ .O....,T- 1} and are instead approximated, for simplicity, via first-ordrr Taylor expansion in time. Under assumptions of smoothness of velocity field, the cumulative error in the final state after T steps with uniform step size At 1/T is bounded by:
S
eT = |
approx
true
O
The proof of this theorem can found Appendix B This result shows that the final error grows linearly with the number of steps skipped and thus provides formal guarantee on the stability of our approximation scheme.
Deciding Redundant Steps. A central challenge in our framework lies in determining when to perform model evaluation versus when to rely on an approximation. Since each approximation in- evitably introduces eиror, uncontrolled propagation may cause the trajectory to deviate significantly from the true dynamics. Moreover, the tolerance to approximation errors can vary across samples of different complexity, implying that the decision criterion must adapt dynamically the evolving data distribution. Thus, we cast the problem of detecting redundant steps as an online sequential decision-makinn problem, formalized via the Multi-Armed Bandit (MAB) framework.
In an MAB setup, an agent iteratively selects actions from finite set, aiming to maximize cumu- lative reward while balancing exploration of uncertain actions and exploitation of actions known to
4

---

Published as a conference paper at ICLR 2026
yield high rewards. At timestep tg. let An, denote the action set, where each action dr A corresponds to skipping ar steps before the next model evaluation. A separate bandit is instantiated at each timestep, learning adaptive policy for choosing a, based on approximation performance.
Let v( (x) denote the true model velocity, o(Z1, (x) its approximation under the chosen skip strategy, and :(: is a discrepancy measure (e.g., mean-squared error). We define the reward asso- ciated with action Ctzy as
r(ar)))) p att - ((((Tre (u), o tx)):
-tt
(5)
The scalar μ > balances the trade-off between efficiency (favoring larger ax) and accuracy (pe- nalizing deviation from the true velocity).
This reward structure formalizes the intuition that skipping more steps accelerates inference, but incurs penalty proportional max, E ET r(ot,)) where и denotes the adaptive policy that maps history of past rewards and actions to the choice of a₁ By construction, the optimal policy x' learns to exploit redundan- cies in locally smooth regions of the trajectory while reverting to exact model evaluations in regions of high curvature or instability.
the local emror. The MAB objective then becomes
Algorithm. Algorithm D presents the pseudo-code of FastFlow. The procedure begins with initial- ization: we specify the timestep grid, the velocity prediction model .M, the action sets A,, available to each bandit B and the trade-off parameter μs. Each bandit is then initialized from a full genera- tion using the first prompt, ensuring that each action is at least played once.
At inference time, when the trajectory reaches state Tia the corresponding bandit Bi, selects skip length m == Ctt, via an upper-confidence bound strategy (line 5). This choice reflects a balance between exploration of new skip patterns and exploitation of those that have yielded high reward. The trajectory then advances m steps using finite-difference extrapolation, followed by an exact evaluation of M at the terminal point.
The reward couples efficiency with reliability: longer skips are encouraged by the term l Ott but this gain is counterbalanced by a velocity mismatch loss that anchors accuracy. Concretely, if at = m, the extrapolated velocity ((T f++++1) is contrasted with the true velocity o( +4 This loss is crucial, as it directly measures the drift introduced by approxima- tion: even small velocity errors accumulate along the trajectory, so penalizing the mismatch ensures stability. By continually updating bandit statistics under this trade-off, FastFlow adapts its policy across timesteps, recomputing when approximation would deviate significantly, while exploiting skips where the loss remains small.
Computational Complexity of Bandits: FastFlow employs multi-armed bandits (MABs) to deter- mine the number of steps to skip and approximate. MABs are computationally lightweight, adding negligible overhead, as they only maintain list of rewards computed as in line 5 of Algorithm This efficiency is further confirmed empirically in our experiments.
FastFlow and Linear multi-step solvers: We reformulate an skip due to method, on top of a Euler solver as a multi-step update in Appendix C
EXPERIMENTS
We evaluate our approach across text-to-image generation, image editing, and text-to-video genera- tion. Below we describe the datasets used in each setting.
Datasets: We use the GenEval benchmark Ghosh et al. (023). collection of 553 prompts designed to evaluate compositional reasoning in sot-tt--mmae generation. The prompts are organized to probe key abilities such as object occurrence, spatial relations, color binding, and numerical consistency, making GenEval widely adopted standard for testing fine inn-ggained semantic alignment.
For image editing, we adopt the GEdit benchmark Liu et al. (2025)), which comprises 606 real-world editing instructions in English. The instructions span broad spectrum of opera- coons-including object manipulation, color changes, layout adjustments, and systematic evaluation of both localized edits and global scene transformations.
5

---

Published as a conference paper at ICLR 2026
Algorithm 1 FastFlow: Bandit-driven approach for accelerated Flow Matching inference
Require: Zt, Initial flow state
(lo, li....; }r:: Timesteps
M: Velocity model
{Bt, Ti=
T--1, Bandit agents
{At, Action sets for bandit agents
H4 T 2.0: Trade-off parameter, Exploration constant.
k: Time index (loop variable)
p: Time index of most recent (actual) velocity evaluation
m. Skip length (in number time indices)
1: Initialize the mean arm rewards Q and arm counts N for bandit agents {B,,)k=d IT- using the first
prompt.
2: Compute initial velocities v(2t, ta), u( 11) t- M(zto: M(re, (1) and set +- 0.
3: Itz f- 2t, + (1) (11 ((1--t). (o).
4: k 1=2
5: while k -
6: n 4 number of time B,, is invoked.
7: Bandit Bi selects skip length m = are + arg maXaEAr,
In Q(a)+7v N(a)
8: Define Ü(t,, tp. At) = v + At v( de) - tp) <p<<
tu
9:
if m > O then
Atk+mak t- txtm tk-
11:
Tty.m t- Diy + Ö(lRR tp: Alx+m))) Ats-mmk
12:
end if
13:
Alx+mt1.ttm + (1++m91 (etm). Z(e-+ + Fletm + i(tx, tp, (1+m+1k+mm Atx+mtiktm
14:
15:
o(2ix+mer1 tx+m+1) =M[Fre+m+t (k+m+1).
Compute reward: r(ar,)) . ar elo((tlttt tps Alu+m+ a( (x+m-1))
Update bandit Bi, statistics: N(ar.) - N(ar))) +1, Q(ar.) Σj r(a,) ( [ag=are) N(ar)
17:
18:
p k; end while
k ++ k +m
Ensure: Final trajectory {Itz T
To measure temporal and multimodal consistency in video generation, dataset. We construct a representative evaluation set by sampling 80 prompts, uniformly selecting 5 from each of the 16 dimensions defined by the benchmark. This ensures balanced coverage across diverse factors such as motion dynamics, object persistence, camera control, and scene composition, yielding challenging yet comprehensive testbed for generative video models.
subset of VBench
Baselines: We compare our method against the following baselines:
The standard sampling procedure, where the model executes the complete de- noising trajectory without acceleration. This serves as the fidelity upper bound and the reference point for all accelerated methods.
Full Generation:
TeaCache: TeaCache accelerates generation by caching intermediate representations and reusing them across timesteps. This eliminates redundant computation and reduces inference time, though fidelity can degrade due to approximations introduced in cached states.
InstaFlow: now-matching--aatt based sampler trained for ultra-fast generation (down single step) on the Stable- Soabll-Diffuiion-v1... model. While highly efficient, it sacrifices fidelity compared to full sampling. We evaluate InstaFlow using the released SableeDiifuusionvll weights.
PeRFlow (Piecewise Rectified Flow): PeRFlow Yan et al. (2024) straightens the diffusion trajec- tory via piecewise-ling linear rectification over segmented timesteps, enabling few-step generation with checkpoints. Ours: Our approach accelerates inference by selectively approximating redundant steps. A Multi- Armed Bandit dynamically decides where to apply approximation, balancing efficiency with fidelity.
favorable quality-efficicee tradeoffs. We report using the official

---

Published as a conference paper at ICLR 2026
Method
TO
CT
ATTR
PO
Overall f
CLIPIQA 1
Spd. Lat. 4
Full Model
Full 50
0.90
0.81
0.85
0.59
0.54
0.78
0.85
1.00x
36.2
Full 25
0.99
0.91
0.78
0.84
0.62
0,51
0.77
0.82
2.00
19.5
Full 10
0.99
0.88
0.68
0.84
0.56
0.48
0.74
0.75
5.00x
07.3
Static Speedup Methods
InstaFlow PerFlow
0.86
0.20
0.21
0.66
0.04
0.02
0.33
0.74
50.0
01.5
0.99
0.79
0.44
0.85
0.25
0.15
0.58
0.80
x.00
08.2
Teacache
0.99
0.89
0.78
0.83
0.58
0.52
0.76
0.80
1
20.6
Ours (FastFlow)
FastFlow-50 50
0.99
0.91
0.80
0.86
0.63
0.51
0.78
0.83
2.65 X
13.7
FastFlow-25
0.99
0.91
0.76
0.84
0.59
0.50
0.77
0.80
4.54
08.6
FastFlow-10
0.98
0.84
0.65
0.84
0.54
0.47
0.72
0.73
7.14x
05.5
Table 1: Comparison of flow-matching acceleration methods. SO: Single Object, TO: Two Object, CT: Counting, CL: Color, ATTR: Color Attribute, PO: Position, Overall: Overall score, CLIPIQA: Perceptual Image Quality. Speedup is relative full-50 step generation. Latency average infer- ence time per image (s).
Method
SO
TO
CO
CL
ATTR
PO
Overall
CLIPIQA
Spd. f Lat.
Full Model
Full
0.98
0.79
0.73
0.78
0.44
0.21
0.65
0.84
1.00x
33.8
Full 25
0.98
0.78
0.71
0.76
0.43
0.18
0.64
0.80
2.00
17.5
Full
0.97
0.66
0.59
0.67
0.41
0.15
0.57
5.00
07.1
TeaCache
TeaCache-50 50
0.98
0.79
0.71
0.76
0.43
0.21
0.64
0.80
1.91
18.3
TeaCache-25
0.97
0.76
0.70
0.74
0.43
0.17
0.62
0.78
3.45
10.3
FlowFase (Ours)
FlowFast 50
0.97
0.78
0.72
0.77
0.44
0.20
0.64
0.82
2.57
13.9
FlowFast 25
0.97
0.78
0.71
0.75
0.42
0.18
0.63
0.79
4.21
08.5
FlowFast 10
0.95
0.64
0.54
0.66
0.40
0.14
0.55
0.57
7.59
05.2
Table Comparison of Full model, TeaCache, and FlowFast (ours). Best values in each column are bolded. FlowFast achieves significantly better performance--fficcinnyy trade-offs while main- taining competitive accuracy and perceptual quality.
For all baselines, we adopt the official hyperparameters provided in their codebases. Table Tea- Cache is applied is released, and in Figure 2 we further evaluate it across timesteps to emphasise its plug-and-play flexibility, An ablation over μ is given in Figure 7
Models. To demonstrate the versatility of our approach, we evaluate across multiple state-of-the-art models: for image generation, BAGEL, Flux-Kontext, and PeRFlow; for image editing, BAGEL, and Step-1X-Ede and for video generation, Hunyuan Video.
Hyperparameters. We consider two key hyperparameters. (i) Arm set: Each arm represents the number of steps to skip. Since the feasible skip length naturally decreases the remaining steps shrink, we design the arm set adaptively with respect to the current generation step. For faimeess, the arm set is kept fixed across models and tasks, and updated only when the generation horizon changes. (ii) Error scaling factor μ.: To normalize rewards, we define μ
M))(,,, where total steps the maximum MSE is estimated from the first full generation pass. This choice rescales error values to the same order step counts, ensuring stable bandit updates while explicitly encoding the trade- off between efficiency (fewer steps) and fidelity (lower error). We run the experiments on a single NVIDIA A 100 GPU.

---

Published as a conference paper at ICLR 2026
Samantic Consistency SCI
Percoptual Quality (G,PQ)
Overall (0
70
Score (BAGEL)
Staps Stape
Speedhu
Speedup
Semantic Consistency
Perceptual Quality (G,PQ)
Overall (C
Store (PAANN)
Steps
49
Speedup(1)
Speedup(x)
Speedupt)
Full Model
Tee Cache
Fastflow
Figure 2: Comparison of edit quality across two models: BAGEL and FLUX. Each subfigure reports semantic consistency (GLSC), perceptual quality (G.PQ) and overall score (G_O) versus speedup.
Vbonch
BRISQUE
233
50 Supe
10
Speedup
Speedup [x]
RadtRoow
Figure 3: Comparison of the Video generation for the Hun Yuan model. We report the VBench score an the BRISQUE metric for the quality of frames generated.
4.1 RESULTS
Image Generation: Tables [ [and]] present a comprchensive evaluation of FastFlow against existing baselines across multiple dimensions, including single-object (SO) and two-object (TO) generation, compositional accuracy, and object positioning. While semantic correctness is important, percep- tual quality is equally critical; to capture this, we report CLIPIQA scores-a state-of-the-ar Image Quality Assessment metric. Our method consistently surpasses prior approaches, achieving sub- stantial speedups over full-step generation while maintaining competitive fidelity. Notably, speedup is measured relative to the full 50-step generation. Although InstaFlow and PerFlow (Table I are rendering speedup comparisons inexact the reported latency still provides meaningful wall-clock comparison.
trained on Stalle-iiffssien variants variants-rrederrig
Image Editing: Figure 2 illustrates the performance of our method on image editing using BAGEL and FLUX models. Evaluations are conducted on the GEdit dataset, with GPT-4.1 serving as an automatic judge to score edits on semantic consistency (G.SCC (G_SC), perceptual quality (G. (G.PQ), and an overall quality measure (G_O). Our approach achieves the highest speedup among all baselines while preserving, and in many cases improving, the quality of the edits.
Video Generation. Figure rreporss results on video synthesis using the VBench benchmark. which multiple dimensions including motion dynamics, temporal consistency, and scene composition. For perceptual assessment of individual frames, we additionally employ the no-reference BRISQUE metric. Our method consistently surpasses baselines, delivering sharper frames and more coherent temporal evolution while achieving substantial acceleration.
Collectively, these results demonstrate that FastFlow offers a transformative trade-off between effi- ciency and quality. By dramatically reducing computation without sacrificing perceptual or semantic
8

---

Published as a conference paper at ICLR 2026
Figure 4: L1-relative error between consecutive velocity predictions the BAGEL model. While the trajectories may appear constant at intermediate scales, a finer analysis uncovers subtle yet sys- tematic variations, indicating that the underlying dynamics are not strictly stable.
BAGEL
Prompt: photo red giraffe with black cellphone.
50 Steps
25 Steps
Steps+TeaCacht 1.85x Speedup
FastFoow 2.67% Speedup
FLUX
Prompt: A photo of red umbrella and green
50 Steps
25 Steps
50 Steps TeaCache Speedup
50 Steps-FastFlew
2.75x Speedup
Figure 5: Generated instance for image generation task for BAGEL and FLUX models.
fidelity, method sets standard for fast, high-quality image generation and editing. This opens the door to practical, real-time applications on resource-constrained devices, making advanced generative modeling more accessible and scalable.
4.2 ANALYSIS
Empirical evidence motivating approximation: Figure we illustrate the L1-relative error
I|tts dx)--((,,,,) A2+1)ll of velocity predictions across consecutive steps, providing insight into how
[| Ak+13ll
the model refines trajectories over time. We observe clear three-phase pattern: the model first establishes the coarse flow, then performs subtle refinements during intermediate steps, and finally adjusts again in the later steps to finalize the trajectory.
Prior work Liu et al. (2025)) has largely relied on zoomed-out trends, where intermediate updates appear nearly constant, motivating strategies that approximate future states solely from the last step. However, finer-grained inspection reveals that these intermediate refinements, though small, are not negligible-subtte fluctuations accumulate and can lead significant deviations ignored. This phenomenon, consistently observed in both generation and editing tasks, highlights the need for approximation methods that capture intermediate dynamics rather than oversimplifying them.
Qualitative Analysis. Figure illustrates image generation with BAGEL and FLUX. Simply trun- cating steps severely harms fidelity, especially for challenging prompts, yielding incomplete or dis- torted images. TeaCache produces closer outputs but still misses fine-grained details and realism. In contrast, FastFlow delivers results nearly indistinguishable from full-step generation, while being substantially faster.

---

Published as a conference paper at ICLR 2026
135
L1-Relative change
Timestep
Timestap 15
57
Timestep 25
Timestap 35
Timestep
0.5
2.5
Fraction
9.3
0.5
Step
Figure 6: The figure illustrates how our method adaptively skips redundant steps regions of slow variation, while reverting to full model evaluations when velocity changes are significant. Explana- tion can be found in Appendix A.3
Figure 10 shows editing examples. Direct step reduction either fails apply edits introduces visual artifacts. TeaCache improves but struggles with precise integration. FastFlow, however, in- corporates edits similar full generation, consistently preserving semantic intent and visual quality.
In summary, the strong speedup of FastFlow stems from its aggressive yet principled approximation, which skips redundant updates without diverging from the model trajectory. The multi-armed bandit controller further adapts to dataset and model dynamics (see Figure 11 learning where to skip and where refin,, enabling acceleration without sacrificing quality.
CONCLUSION
We introduced new framework FastFlow, that accelerates flow-based generative models by adap- tively skipping redundant steps while safely approximating the underlying trajectory. Unlike static reduction strategies, approach dynamically adjusts the difficulty of incoming sam- ples sles-inipping more aggressively for easy cases while allocating more model computation to harder ones. The trajectory approximation further empowers the decision-male (MAB) capture fine- grained variations, enabling efficient yet faithful generation. Across diverse datasets and tasks, our method consistently outperforms existing baselines, establishing a new paradigm for fast, high- fidelity generative modeling. One limitation of using MAB is the speedup may not be observed in initial steps due inherent explorations.
ETHICS AND REPRODUCIBILITY STATEMENT
We confirm that have read and adhere the conference Code of Ethics. To the best of knowledge, this work is original and all relevant prior work has been properly cited. All authors have contributed to and take responsibility for the content. No LLMs were used in the preparation of this manuscript, except where explicitly disclosed as part of the proposed method.
ACKNOWLEDGEMENTS
Divya Jyoti Bajpai is supported by the Prime Minister's Research Fellowship (PMRF), Govt. of India. Manjesh K. Hanawal thanks funding support from Telecom Centre of Excellence(TCOE), Department of Telecommunication (DoT) and Ministry of Electronics and Information Technology (MeitY). We also thank funding support from Amazon IlT-Bombay AI-MI Initiative (AIAIMI.))
10

---

Published as a conference paper at ICLR 2026
REFERENCES
Grigory Bartosh, Dmitry P Vetrov, and Christian Andersson Naesseth, Neural flow diffusion models: Learnable forward process for improved diffusion modelling. Advances Neural Information Processing Systems, 37:73952-73985, 2024.
Florinel-Alin Croitoru, Vlad Hondru, Radu Tudor Ionescu, and Mubarak Shah. Diffusion models in vision: A survey, IEEE transactions on pattern analysis and machine intelligence, 45(9): 10850-10869, 2023.
Quan Dao, Hao Phung, Binh Nguyen, and Anh Tran. Flow matching in latent space. arXiv preprint arXiv:2307.08698, 2023.
Quan Dao, Hao Phung, Trung Tuan Dao, Dimitris N Metaxas, and Anh Tran. Self-corrected flow distillation for consistent one-step and few-step image generation. Proceedings of the AAAI Conference on Artificial Intelligence, volume 39, pp. 2654-2662, 2025.
Aram Davtyan, Leello Tadesse Dadi, Volkan Cevher, and Paolo Favaro. Faster inference of flow- based generative models via improved data-noise coupling. In The Thirteenth International Con- ference on Learning Representations, 2025.
Chaorui Deng, Deyao Zhu, Kunchang Li, Chenhui Gou, Feng Li, Zeyu Wang, Shu Zhong, Weihao Yu, Xiaonan Nie. Ziang Song, et al. Emerging properties in unified multimodal pretraining, arXiv preprint arXiv:2505. 14683, 2025.
Yingying Deng. Xiangyu He, Changwang Mei, Peisong Wang, and Fan Tang. Fireflow: Fast inver- sion of rectified flow for image semantic editing. arXiv preprint arXiv:2412.07517, 2024.
Prafulla Dhariwal and Alexander Nichol. Diffusion models beat gans image synthesis. Advances in neural information processing systems, 34:8780-8794, 2021.
Dhruba Ghosh, Hannaneh Hajishirzi, and Ludwig Schmidt. Geneval: An object-focuser framework for evaluating text-to-image alignment. Advances in Neural Information Processing Systems, 36: 52132-52152, 2023.
Eldad Haber, Shadab Ahamed, Md Shahriar Rahim Siddiqui, Niloufar Zakariaci, and Moshe Eliasof. Iterative flow matching path correction and gradual refinement for enhanced generative model- ing. arXiv preprint arXiv:2502. /6445, 2025.
Ju He, Qihang Yu, Qihao Liu, and Liang-Chieh Chen. Flowtok: Flowing seamlessly across text and image tokens. arXiv preprint ar 23v:2503..1072 2025.
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. arXiv preprint arXiv:2410.05955 2024.
Weijie Kong, Qi Tian, Zijian Zhang, Rox Min, Zuozhuo Dai, Jin Zhou, Jiangfeng Xiong, Xin Li, Bo Wu, Jianwei Zhang, et Hunyuanvideo: A systematic framework for large video generative models. arXiv preprint arXiv:2412.036600 2024.
Nikita Kornilov, Petr Mokrov, Alexander Gasnikov, and Aleksandr Korotin. Optimal flow match- ing: Learning straight trajectories in just one step. Advances in Neural Information Processing Systems, 37:104 1110004880-00 80-104404, 2024.
Black Forest Labs, Stephen Batifol, Andreas Blattmann, Frederic Boesel, Saksham Consul, Cyril Diagne, Tim Dockhorn, Jack English, Zion English, Patrick Esser, et al. Flux. kontext: Flow matching for in-context image generation and editing in latent space. arXiv preprint 25775 2025.
Sangyun Lee, Beomsu Kim, and Jong Chul Ye. Minimizing trajectory curvature of ode-based gen- erative models. In International Conference on Machine Learning, pp. 18957-18973. PMLR, 2023.
11

---

Published as a conference paper at ICLR 2026
Yaron Lipman, Ricky TQ Chen, Heli Ben- Ben-Hamu, Maximilian Nickel, and Matt Le. Flow matching for generative modeling. arXiv preprint arXiv:2110.22777, 2022.
Feng Liu, Shiwei Zhang. Xiaofeng Wang, Yujie Wei, Haonan Qiu, Yuzhong Zhao, Yingya Zhang, Qixiang Ye, and Fang Wan. Timestep embedding tells: It's time to cache for video diffusion model. In Proceedings of the Computer Vision and Putlern Recognition Conference, pp. 7353- 7363, 2025a.
Luping Liu, Yi Ren, Zhijie Lin, and Zhou Zhao. Pseudo numerical methods for diffusion models manifolds. In The Twelfth International Conference on Learning Representations, 2022a.
Shiyu Liu, Yucheng Han, Peng Xing, Fukun Yin, Rui Wang, Wei Cheng, Jiaqi Liao, Yingming Wang, Honghao Fu, Chunrui Han, et al. Steplx-edit A practical framework for general image editing. arXiv preprint arXiv:2504. 17761, 2025b.
Xingchao Liu, Chengyue Gong, and Qiang Liu. Flow straight and fast: Learning to generate and transfer data with rectified flow. arXiv preprint arXiv:2209.0.83 00000,, 2022b.
Xingchao Liu, Xiwen Zhang, Jianzhu Ma, Jian Peng, et al. Instaflow: One step is enough for high-quality diffusion-based text-to-image generation. In The Twelfth International Conference on Learning Representations, 2023.
Cheng Lu, Yuhao Zhou, Fan Bao, Jianfei Chen, Chongxuan Li, and Jun Zhu. Dpm-solver: fast ode solver for diffusson probabilistic model sampling in around 10 steps. Advances in neural information processing systems, 35:5775-5787, 2022.
Eric Luhman and Troy Luhman. Knowledge distillation in iterative generative models for improved sampling speed. arXiv preprint arxivv2201.02255. 2021.
Tim Salimans and Jonathan Ho. Progressive distillation for fast sampling of diffusion models. arXiv preprint arXiv:2202.00512 2022.
Johannes Schusterbauer, Ming Gui, Frank Fundel, and Björn Ommer. Diff2flow: Training flow matching models via diffusion model alignment. In Proceedings of the Computer Vision and Pattern Recognition Conference, pp. 28347-28357, 2025.
Neta Shaul, Juan Perez, Ricky TQ Chen, Ali Thabet, Albert Pumarola, and Yaron Lipman. Bespoke solvers for generative flow models. arXiv preprint arXiv:2310.1991 190079955 2023.
Yang Song, Prafulla Dhariwal, Mark Chen, and Ilya Sutskever. Consistency models. 2023.
Endree Suli and David Mayers, An introduction numerical analysis. Cambridge University Press, 2003.
Team Wan, Ang Wang, Baole Ai, Bin Wen, Chaojie Mao, Chen-Wei Xie, Di Chen, Feiwu Yu, Haiming Zhao, Jianxiao Yang, et al. Wan: Open and advanced large-scale video generative models. arXiv preprint arXiv:2503.203 200.23043..0,4, 2025.
Jiangshan Wang, Junfu Pu, Zhongang Qi, Jiayi Guo, Yue Ma, Nisha Huang, Yuxin Chen, Xiu Li, and Ying Shan. Taming rectified flow for inversion and editing. arXiv preprint 2rX.0:2411.04766, 2024.
Zhen Xing, Qijun Feng, Haoran Chen, Qi Dai, Han Hu, Hang Xu, Zuxuan Wu, and Yu-Gang Jiang. A survey on video diffusion models. ACM Computing Surveys, 57(2):1-42, 2024.
Hanshu Yan, Xingchao Liu, Jiachun Pan, Jun Hao Liew, Qiang Liu, and Jiashi Feng. Perflow: Piecewise rectified flow universal plug-and and--la accelerator. Advances in Neural Information Processing Systems, 37:78630-78652 2024.
Ling Yang. Zhilong Zhang, Yang Song. Shenda Hong, Runsheng Xu, Yue Zhao, Wentao Zhang, Bin Cui, and Ming-Hsuan Yang. Diffusion models: comprehensive survey of methods and applications. ACM computing surveys, 56(4):1-39, 2023.
12

---

Published as a conference paper at ICLR 2026
Steps Steps
0.005
Geneval Score (%)
75
0.0005
74
2.0
4.5
Speedup
Figure Caption
Ling Yang, Zixiang Zhang, Zhilong Zhang, Xingchao Liu, Minkai Xu, Wentao Zhang, Chenlin Meng, Stefano Ermon, and Bin Cui. Consistency flow matching: Defining straight flows with velocity consistency. arXiv preprint arXiv:2407.02339, 2024.
Yuchen Zhang and Jian Zhou. Inverse flow and consistency models. In Forty-second International Conference on Machine Learning, 2025.
Yuanzhi Zhu, Zhaohai Li, Tianwei Wang. Mengchao He, and Cong Yao. Conditional text image generation with diffusion models. In Proceedings of the IEEE/CVF Conference Computer Vision and Pattern Recognition, pp. 1-235-14244 2023.
Pascal Zwick, Nils Friederich, Maximilian Beichter, Lennart Hilbert, Ralf Mikut, and Oliver Bring- mann. Lediflow: Learned distribution- guided flow matching accelerate image generation, arXiv preprint arXiv:2505.20723, 2025.
A APPENDIX
A.1 FASTFLOW VS. TEACACHE VS. DIRECT REDUCTION
FastFlow vs. Direct Reduction, natural question arises: why not simply reduce the number of diffusion steps directly? While straightforward, this approach is fundamentally different from FastFlow. Direct reduction applies static truncation of steps, which effectively assumes that the velocity removed step can be approximated by reusing the velocity from the previous step. This oversimplification discards useful intermediate information and can degrade generation quality.
In contrast, FastFlow adaptive. Instead of discarding steps outright, it selectively identifies which steps must be computed by the model and which can be approximated using prior computations. This ensures that efficiency achieved without sacrificing fidelity, especially for complex prompts.
FastFlow vs. TeaCeche. TeaCache approaches acceleration differently: it uses timestep embed- dings of noisy inputs and applies polynomial fitting scheme determine whether a step should be cached. While conceptually simple, this design comes with two key limitations: 1) It requires calibration via polynomial fitting, which introduces task- and model-specific tuning overhead. 2) not truly dynamic the caching threshold is fixed once target speedup is specified, and in empirical evaluation (50 video generations and 100 image generations), we consistently observed that TeaCache converges to repetitive caching patterns (e.g., alternating steps for 2x speedup), gardless of the complexity of the prompt. This indicates that the method does not effectively adapt to prompt-specific generation difficulty, but rather applies globally fixed caching strategy.
Advantages of FastFlow. Unlike TeaCache, FastFlow is truly dynamic. It learns on-the-ft fly during inference and adapts to the complexity of each prompt. For simpler generations, aggressively
13

---

Published as a conference paper at ICLR 2026
reduces the number of model calls to maximize speedup, while for complex prompts, it reverts to additional steps to preserve quality. This adaptiveness enables FastFlow to provide consistently better trade-offs between efficiency and fidelity compared to static baselines like TeaCache.
A.2 SPEEDUP VS PERFORMANCE CURVE
In Figure 7 we show the speedup vs performance trade-off in our method, it also gives a sense of what number of steps choose and with what μt, given a speedup. For instance, given speedup of 2.3x, whether user should choose 50 steps with some high value of μ or 25 steps with some low values of p.
A.3 FASTFLOW'S SKIP PATTERNS:
Figure couureojillusten iillustrates how our method adapts skip decisions to the model's internal dynamics. The plot shows the mean squared error (MSE) of consecutive velocities alongside frequency with which different skip lengths are selected.
When velocity fluctuations are high, FastFlow consistently chooses shorter skips, preserving aceu- racy. During intermediate regions where changes are smoother, it shifts toward longer skips, accel- erating computation. Finally, as fluctuations re-emerge toward later steps, the method automatically reduces the skip length again. This adaptive behavior explains why FastFlow achieves significant speedups without compromising fidelity: it skips aggressively only when the trajectory stable and reverts fine-grained updates when the dynamics demand precision.
A.4 ADAPTIVENESS OF FASTFLOW
The adaptiveness of our method can be further seen in the Figure 11 we find that our method can adjust the speedup based on the complexity of the incoming samples, if sample required more model computations it reverts back to lesser number of skips and approximations and in the case of an easier generation the model can further gain speedup by aggressively skipping multiple redundant steps making our method to choice for adaptive visual generation.
A.5 REGRET CURVES
In Figure we plot the cumulative regret of bandits deployed at different points the denoising trajectory. Across all positions, the cumulative regret begins to flatten between 50 and 100 samples, demonstrating that the bandit rapidly identifies the near-optimal skipping strategy. The small amount of regret accumulated in the first 50 samples is expected because several arms are only marginally suboptimal; choosing them does not significantly affect performance.
A key reason for this fast convergence is the reward structure: it assigns noticeably higher reward to the truly optimal arms, creating a strong separation between optimal and suboptimal choices. This makes the identification of the best easier, allowing the bandit switch from exploration to exploitation very quickly. As a result, our method converges rapidly within a small number of samples.
A.6 EMPIRICAL VALIDATION OF ERROR BOUND
In Figure 9 we provide results that verify the tightness of the bound which is developed in Theorem 3.1 The bound clearly shows a good amount of tightness when the number skipped steps are small and as the number of steps skipped incraeses tehe bound becomes weaker, which is intuitive as well since the bound plays
B THEORETICAL ANALYSIS
Assumptions: The velocity field v(x,,) () is assumed be smooth and satisfy the following condi- tions for constants Lzg, M > 0:
1. Lipschitz continuity in space: (] 1) vly, t)ll Tea i vll for all x, y TRd
14

---

Published as a conference paper at ICLR 2026
3.5
Cumulative regret
0.5
stp
Bendiaa cmp
stpp
Bandit step
Bandit step
Bandi: at stop
250
Samples
Figure 8: The regret curves for various bandits applied at different steps, the results are the average of five random runs where randomness comes from the reshuffling of data.
Error
Skipped steps
Figure 9: The plot represents empirical error vs the error developed in the Theorem 3.1
FOOD MENU
FOOD MENU
SANDWICH
FOOD MENU
Originel image
50 steps
25 slece
aleps-FastFloo 2.9 speedup
hotwind
col breeze
codtreeze
coleee
Change the toxt Tholwind to roall bressn'
Original image
50 slepss
25 steps
50 steps-Faattloo
2.76x speedup
Figure 10: Generated instance for image editing task for BAGEL and FLUX models.
15

---

Published as a conference paper at ICLR 2026
TeaCCcche
Speed Up: 1.91x
Speed Up: 1.91x
FasiFlow
Speed Up: 2.05x
Adaptiveness
Speed Up: 2.70x
Prompt: A cat and lion eating noodles.
Prompt: A photo cat.
Figure 11: An illustration of the adaptiveness of our method. For simpler generation prompts, it achieves higher speedups by reducing inference calls, whereas for more complex samples, FastFlow automatically reverts to additional model calls. In contrast, baselines such as Teacache remain static across timesteps, showing no dependence on generation complexity.
Flux
BAGEL
Hyperparam
Generation
Editing
Generation
Editing
Image resol.
1360x768
1024 x 1024
Guidance scale
2.5
2.5
cfg teg__lee_ccaeeeeee
efg scale
Guidance rescale
0
0
efy sgg_im__sene scale =
cfg img_sllee
scale
0.001
0.005
0.001
0,005
cfg-interval
[0.4, 1.0]
[0.0, 1.0]
timestep-shift
3
cfg_renorm_min
0
renorm_lype Arms
"global"
"text cexxnee
[0.2.4.6] (50), [0.2,4.6] (25), [0,1,2.3] (10)
same BAGEL
Table 3: Hyperparameter settings for Flux and BAGEL. We report separate values for generation and editing. Both models share the same arm configurations, while image resolution and condition- ing scales differ.
2. Bounded second time-derivative:
v'2(z.() 01
< M for all x E Rd
Theorem B.1. Let {atruc] denote the trajectory obtained using the exact velocity field with the forward Euler method, and let approx } be the trajectory where velocity evaluations are skipped at a subset of steps S fo....,T 13 and are instead approximated, for simplicity, via a first-order Taylor expansion in time.
T
16

---

Published as a conference paper at ICLR 2026
Under above assumptions, the cumulative error in the final state after T steps with uniform step size At = 1/T is bounded by:
ET = | Etr
Approx
truee
73
Proof. Let ck == | for the true and approximate trajectories are given by:
apprex
truel
Ey be the spatial error at timestep ig. The forward Euler updates
true true + At . v true txx
Fle+1
approx 1x+1
approx At 2t2
where ög is the (potentially approximated) velocity used at step k. By subtracting the two update equations and applying the triangle inequality, we derive the error recurrence:
approx truuee + At(u2 - =( Ek+1 = || 244
true -ta))l
< es + AL ||0x v((t ie 44)ll-
We bound the velocity mismatch term by splitting it into the approximation error and the propagated error:
U v( tx)ll S 1 v(2 (xpppprox txlll
[1 .x) - v(
- true tx
Approximation Fror
Propagated Firor
The propagated error is bounded by the spatial Lipschitz condition:
[10
approx tx) - v( true tx)]l I Lyck-
For the approximation error, skip occurs (k S), we use the bound on the second derivative. The remainder term of a first-order Taylor expansion gives:
M
0
u(a
opprox tw)l S (At)².
no skip occurs (k & S), this error i. Combining these bounds, the full error recurrence becomes:
el+ S En At 1 [[REE)
M (21)2 + LEER
2
M
< + D1)ER + (KEE)) 2 (A1)3
We unroll this recurrence starting from the initial condition 0:
T-1
Σ
1 (NES) (At)3 (1 -.At
0=
Using the inequality (1 + x) E we can bound the exponential term:
(1 L,A ( < ch.Ttr L.
Substituting this back, we get a sum over the S steps where an error was introduced:
M (At) e =1|- Me (At)
eT
KES
Finally, with At 1/T, the bound is:
L 1
eT S
T3
which proves that et = 0
7.7
17

---

Published as a conference paper at ICLR 2026
Interpretation:
The upper bound the overall error be interpreted as:
1. We show that global eтrоr between our update to the Euler solver, and Euler solver with full evaluation small (as above).
2. The overall the total number of timesteps.
grows linearly with the number of skipped steps, but decays rapidly with
3. The proof provides a strong theoretical motivation for our choice of the bandit reward. The goal is maximize the number of skipped steps, while lowering the local error.
4.
Approximating velocities in regions of large curvature (i.e., large M) increases the overall error.
C FASTFLOW AND LINEAR MULTI-STEP METHODS
Given the first-order Taylor approximation for velocity, and Euler solver for FastFlow, re- formulation to cast our updates in form of a Linear multi-step can be obtained as follows.
Assume that as per method and uniform step-size, we evaluate the velocities v(r,, k), 0( 1) and then skip m steps as per a bandit action. Then #44m+1, with a Euler step update is given by:
Tk+m+1 Fk+m + h v( k m)
(6)
We approximate 2k+m and u k + m) as follows:
Ik+m = 2 + m h u(rk, k)
(7)
o(#k4m, k m) z u k)) + m h r( kt) r v(
(8)
h
Updating (2), (3) in (1), with some simplification results in: 2k+m+1 = ny + h2m + 1) u(rk, k) - m o( k -1]]
(9)
This is multi-step update with order=1. The update is consistent, and the Local Truncation Error (at step k + m - 1, when bandit skips m steps at step k)) can be shown to be as (after accounting for a division by in Suli & Mayers 2003
kk.m
2. 2. + 1)
m² +
11.
&x
di3 (4+) (42)
m
112
dr (1. ((h))
di
(10)
C.1 COLVER-AGNOSTEE ACCELERATION
Our primary contribution a training-free acceleration framework for Flow Matching models based dynamic bandit objective. Unlike heuristic step-skipping strategies, skip model evaluations as an adaptive bandit optimization problem. The method is solver-agnostic and operates on top of existing numerical solvers without modifying their update rules. reduces computation by selectively skipping model evaluations during inference and does not introduce new solver. In the main paper, results are shown with the Euler solver; here we additionally evaluate higher-order solvers.
the decision to
We report results on the BAGEL model evaluated on the GenEval dataset. Speedup computed as
T Tmax
Speedup Average number of model evaluations'
with Tiax = 50. "Overall" and "CLIPIQA" denote perceptual quality metrics (higher better).
18

---

Published as a conference paper at ICLR 2026
Method
SO
TO
CO
CL
ATTR
PO
Overall
CLIPIQA
Speedup
Euler (Full, 70=
0.99
0.90
0.81
0.85
0.59
0.54
0.78
0.85
1.00
2-AB (Full, -5) 0.99
0.93
0.81
0.87
0.60
0.48
0.78
0.85
1.00
4-AB (Full, T'=50)
0.99
0.92
0.80
0.87
0.61
0.48
0.78
0.87
1.00
Fuler FastFlow
0.99
0.91
0.80
0.86
0.63
0.51
0.78
0.83
2.65
2-AB FastFlow
0.99
0.93
0.80
0.87
0.59
0.48
0.78
0.83
2.45
4-AB + FastFlow
0.99
0.93
0.81
0.87
0.61
0.48
0.78
0.84
2.37
Table 4: Performance across solvers GenEval. FastFlow consistently achieves 2.37x-2.65x
speedup while maintaining comparable perceptual quality, demonstrating solver-agnostic behavior.
19


Reviews:
[{"review_id": "AGajkCDJso", "reviewer": "Reviewer_D8Ff", "summary": "This paper proposes a training free, plug and play acceleration scheme for flow matching Euler sampler at inference time using multi-arm bandit algorithms to choose the most relevant steps given a low-budget step sizes. More specifically, FastFlow aims to skip a variable number of intermediate time steps and approximate the missing velocities using a finite difference in time, and the choice of how many steps to skip is cast as a multiarmed bandit with reward. A theorem gives a bound on the terminal deviation between the approximated and full trajectories under smoothness assumptions, with uniform step size and a set $\\mathcal{S}$ of skipped steps. Experiments on image generation, image editing, and video generation claim speedups up to about 2.6 times while maintaining GenEval and CLIP based IQA metrics near full sampling. Qualitative examples are shown for BAGEL and FLUX models and HunyuanVideo.", "questions": "- Please quantify compute precisely. Report average number of model calls per sample and the distribution of skip lengths $\\alpha_t$.\n- Please compare against AdaptiveDiffusion and AdaDiff under the same backbones and prompts, and include DeepCache on image tasks and TeaCache on both image and video. Use the same target speed levels and report NFE matched comparisons.\n- See also other remarks in Weaknesses on the theoretical bound.", "limitations": "", "rating": 4, "confidence": 4, "soundness": 3, "presentation": 2, "contribution": 2, "strengths": "I think the most notable point is that the method is training-free and easy to integrate into existing flow matching pipelines. The speedup figures are plausible given the cost model of flow samplers where every velocity evaluation dominates wall time. I also like recasting the step-size selection as a bandit objective, whichh directly encodes the speed-accuracy tradeoff", "weaknesses": "- I think the novelty is thinner than the paper suggests. The velocity extrapolator collapses to a two step Adams Bashforth style predictor in uniform time-step. The work should at least acknowledge this equivalence and position itself relative to, for example,  PNDM [1], and other linear multistep sampling strategies already common in diffusion code bases. Empirically, a direct comparison to a simple two step predictor that still evaluates the model at checkpoints would be informative. Moreover, the statement that most alternative accelerators require retraining is not fully accurate. TeaCache and DeepCache are training free, and the recent adaptive skipping line is also training free in some variants. These should be acknowledged and compared.\n\n- The theory is reassuring but optimistic in scale. For example, with $T=50$ and $∣S∣=25$, the error upper bound term $O(|S|/T^3)$ suggests very small terminal deviations unless the bounding constants are large. However, in the empirical evaluation, the experiments do show quality drop at aggressive skip levels, so either the constants are large or the bound does not capture the dominant error channel. A local error monitor beyond the velocity mismatch would be more principled, for example, an embedded predictor-corrector or curvature proxy, as in adaptive time-stepping literature.\n\n- The experimental section omits several highly related baselines. AdaptiveDiffusion and AdaDiff are the most obvious, but there are also solver learning baselines such as Bespoke Solvers and S4S that reduce NFE without training the base generator. A comparison would help position FastFlow on the quality versus NFE Pareto.\n\n\n[1] Luping Liu, Yi Ren, Zhijie Lin, Zhou Zhao (2022); Pseudo Numerical Methods for Diffusion Models on Manifolds, ICLR 2022.\n\n[2] Neta Shaul, Juan Perez, Ricky T. Q. Chen, Ali Thabet, Albert Pumarola, Yaron Lipman (2023), Bespoke Solvers for Generative Flow Models, ICLR 2024.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "xHNKVgfn43", "reviewer": "Reviewer_qEHL", "summary": "This paper proposes FastFlow, a plug-and-play adaptive inference framework that accelerates generation in flow matching models. FastFlow identifies denoising steps that produce only minor adjustments to the denoising path and approximates them without using the full neural network models used for velocity predictions. The approximation utilizes finite-difference velocity estimates from prior predictions to efficiently extrapolate future states, enabling faster advancements along the denoising path at zero compute cost.", "questions": "can the method combined with modern fast samplers instead of Euler?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "- the motivation to accelerate flow-matching models is reasonable.\n- the proposed method is plug-and-play and introduce negalectable extra costs", "weaknesses": "- missing comparisons on ImageNet 256", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "MIl0tkU0JZ", "reviewer": "Reviewer_Tpv2", "summary": "This paper introduces FastFlow, a plug-and-play adaptive inference framework to accelerate generative flow-matching models by skipping redundant denoising steps. The key insight is that flow-matching generative trajectories are often approximately linear, so intermediate states can be extrapolated cheaply instead of recomputing every step. FastFlow uses a finite-difference (Taylor series) approximation of the model’s velocity field to predict future states, allowing the method to advance multiple steps at zero neural network cost. Crucially, the framework employs a multi-armed bandit (MAB) at each timestep to adaptively decide how many steps to skip before the next full model evaluation. The bandit’s reward balances two objectives: (i) speed (skipping more steps) and (ii) accuracy (penalizing deviation from the true model trajectory). By learning this trade-off online per sample, FastFlow dynamically skips only those steps that would have minimal effect on final output. The approach is model-agnostic (no retraining or extra networks required) and integrates seamlessly into existing flow-matching pipelines.\n\nThe paper provides a theoretical bound on the error induced by skipping steps, formulates the skip decision as an online bandit problem, and demonstrates various experiments on text-to-image generation, image editing, and text-to-video generation. Empirically, FastFlow achieves over 2.6× speedup in inference while maintaining output quality comparable to the full model across these tasks. This represents a significant improvement over prior static acceleration methods, which often require retraining or sacrifice fidelity.\n\nThough this method is effective when multiple steps are necessary, there are already many few-step or even one-step models (e.g., distillation or shortcut models) available today, so I am not sure whether this method is truly useful in practical scenarios.", "questions": "How many samples or iterations does it typically take for the bandit policy to stabilize? In your experiments, after seeding with one full generation, does FastFlow achieve near-optimal skipping immediately on the next sample, or does it require a few generations to fully adapt? Clarifying this can help understand use-cases. Any insight into how the bandit’s learning curve looks would be helpful.\n\nDid you observe any failure cases or significantly reduced speedups for particular input types or prompts that might cause non-linear dynamics? Analyzing a case where FastFlow nearly defaults to the full model would illustrate its limits and robustness.\n\nTheorem 3.1 gives an error bound $O(|S|/T^3)$. Did you empirically measure how close the practical error comes to this bound? In other words, is the bound reasonably tight or very conservative? Some intuition or experiment on how the final output error grows with number of skips in practice.", "limitations": "", "rating": 6, "confidence": 3, "soundness": 4, "presentation": 3, "contribution": 3, "strengths": "Unlike static acceleration schemes, FastFlow adapts to each sample’s complexity. The multi-armed bandit dynamically decides per timestep how many steps to skip, meaning simpler cases automatically run faster while complex cases get more compute. This adaptive inference is novel and ensures no one-size-fits-all schedule, leading to greater robustness across diverse inputs.\n\nThe proposed framework is model-agnostic and plug-and-play, so it can be applied to existing pretrained flow-matching models without any retraining or fine-tuning. There’s no need for distilling a new model or training an auxiliary network, which makes the method very practical. It can be integrated into current pipelines with minimal effort, offering immediate speed benefits.", "weaknesses": "It requires some exploration to learn the optimal skipping policy. You acknowledge that the speedup may not fully materialize in the very first steps or first few samples due to this exploration phase. In practice, you mitigate this by seeding the bandit with one full generation, but if a user only generates a handful of samples, the adaptive policy might not have time to reach peak efficiency. In scenarios with very few inference runs, the benefit of FastFlow could be less pronounced.\n\nThe effectiveness of FastFlow rests on the assumption that the generative trajectories are locally smooth/linear enough to be extrapolated. While flow-matching models do encourage linear paths, there might be cases of highly non-linear or complex dynamics where the Taylor approximation could be less accurate. Therefore, essentially, FastFlow may be less effective if the model’s velocity field changes rapidly in unpredictable ways.\n\nTable 1 and Table 2 are overlapped. Please adjust the margin via \\vspace.\n\nThis paper contains some typos and grammatical issues. Here are the ones I found just by skimming through it:\n* L67: a a theoretical -> a theoretical\n* L95: We setup -> We set up\n* L170: a static criteria -> a static criterion\n* L364: is applied is as -> is applied as\n* L388: an the -> and the\n* L490: it’s content -> its content", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "k5DCUl64mo", "reviewer": "Reviewer_r4c2", "summary": "The paper proposes FastFlow, a plug-and-play adaptive inference framework that accelerates flow-matching generative models without retraining. The key idea is to approximate redundant denoising steps using a finite-difference Taylor expansion of the model’s velocity field, thereby skipping expensive neural evaluations when the dynamics are locally smooth. To decide how many steps can be safely skipped, FastFlow formulates the process as a multi-armed bandit (MAB) problem that adaptively balances efficiency and fidelity during sampling. Overall, FastFlow achieves acceleration while maintaining perceptual and semantic fidelity across multiple generative domains.", "questions": "How does the method perform when coupled with quantization method? Also can this be utilized in flow models after reflow training? Ideally, reflow models have straight, non-crossing paths where the proposed method might not be as effective. I supposed experiment presented in Figure 4 using rectified flow models FLUX schnell can show a different trend.", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "The paper is clearly written and easy to follow, with a well-motivated goal: accelerating flow-matching models to benefit the broader generative modeling ecosystem. I especially appreciate the inclusion of image editing, where real-time interaction is critical. While reusing the previous step’s velocity is not new, bandit-driven policy for adaptive step skipping is novel in this context to my knowledge and is presented in a concrete, convincing way.", "weaknesses": "The proposed method relies on heuristic parameters such as $p$ for velocity approximation and $\\mu$ for the reward regularization term. It would be helpful to clarify how these parameters are chosen in practice and whether the method is robust to variations in their values.\n\nFig. 2–3 consistently show that FastFlow has higher latency than TeaCache (for comparable compute). Is this overhead coming from the multi-armed bandits? It seems that the overhead is not negligible. Can the authors clarify this behavior? Similarly, the result for FastFlow-10 in image generation (Table 1) shows only minor gains compared to Full-10. Additionally, the authors mention that the baselines follow the official hyperparameters. What are these parameters, and could this violate an apples-to-apples comparison? Overall, my concern is that the experiments either show marginal gains or may have presented in an unfair manner. \n\nLastly, the paper would be strengthened by including an ablation study on the contribution of the multi-armed bandit algorithm. For instance, comparing FastFlow against simpler alternatives such as uniform or piecewise-constant skipping schedules.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)