TamedFlow: Trajectory-Aware Distillation for Teacher-Assisted Diffusion Sampling

Introduction

Diffusion Transformers (DiTs) have become a leading backbone for high-fidelity visual generation ([19]), yet iterative denoising imposes high inference latency. Each sample requires dozens of sequential forward passes, with costs scaling rapidly with model parameters, resolution, and sequence length. Existing acceleration strategies attack complementary aspects of this cost: step-reduction methods shorten the solver schedule ([25, 14, 3, 6]); parameter compression lowers per-step computation; and adaptive inference reuses or forecasts intermediate activations ([17, 23, 10 b]). Combining parameter compression with adaptive execution is intuitively appealing, promising cheaper evaluations while skipping redundant computation. All headline experiments below use fixed-step DDIM integration to evaluate compression and adaptive execution under a unified solver convention.

In practice, this composition can break down. In our controlled diagnostic (Appendix Table 1), attaching the evaluated adaptive reuse methods directly to a compressed student degrades sample quality, inflating ImageNet $256 \times256$ FID from 5.56 to between 10.40 and 13.18. We term this failure mode the Combination Gap. This result exposes an operational mismatch: a student trained for pointwise agreement need not remain reliable after its own predictions alter the states encountered later. Rather than applying internal reuse unchanged to the compact model, we let the student generate short trajectory drafts and reserve teacher intervention for drafts predicted to deviate.

Chaining student predictions into drafts, however, introduces compounding integration drift. Proposition 3.1 characterizes this through an Euler rollout bound: spatial sensitivity can amplify local student–teacher velocity mismatch over sequential steps. To stabilize drafting against this amplification, we introduce TamedFlow, combining trajectory-aware distillation with selective teacher rescue (Figure 1). During training, cross-architecture feature alignment (AlignNet) grounds student representations in teacher layers; a near-identity Velocity Alignment Head (VAH) absorbs residual velocity errors; and randomized $K$-step rollout supervision ($K \sim\mathcal{U}(1,5)$) penalizes both intermediate mismatch and accumulated endpoint drift. A two-stage curriculum introduces the multi-step objectives only after feature alignment.

At inference, TamedFlow uses an asymmetric execution policy. A compact Learnable Trajectory Estimator (LTE, 4M parameters) scores completed drafts from pooled student tokens and timestep embeddings without teacher access. If confidence exceeds threshold $\tau$, the draft is accepted, advancing $K$ steps while bypassing the teacher. If rejected, the sampler rolls back to the pre-draft state and advances one step with teacher rescue. Varying $\tau$ selects among measured operating points between throughput and fidelity without sequential teacher verification.

Distilling DiT-XL/2 into a 130M DiT-B/2 student on ImageNet $256 \times256$, TamedFlow attains FID 2.58 at 2.25× measured speedup (0.464 s vs. 1.044 s) over the DDIM-50 teacher. At comparable latency, TamedFlow improves FID over the evaluated training-free adaptive baselines (e.g., FoCa at FID 2.65, 0.466 s). Controlled ablations support trajectory supervision and learned routing at nearly matched latency, while evaluations on ImageNet $512 \times512$, MS-COCO, and Latte video DiTs extend the empirical scope. In summary, our contributions are:

• Diagnostic and analysis of the Combination Gap. We document the failure of applying the evaluated adaptive reuse methods to a compressed DiT, and derive a DDIM rollout bound characterizing how sequential drafting can amplify local velocity errors.

• Trajectory-stabilized speculative distillation. We introduce TamedFlow, uniting feature alignment, residual velocity correction, and randomized rollout supervision to optimize a compressed DiT for autonomous multi-step drafting.

• Learned routing and deployment evaluation. We propose an asymmetric execution policy via a 4M-parameter LTE to accept reliable drafts or trigger teacher rescue, evaluating quality–latency trade-offs across resolutions, text conditioning, and video alongside physical deployment costs.

Related Work

Related Work

Prior work on DiT acceleration reduces the number of solver evaluations, the cost of each evaluation, or the teacher computation retained during adaptive execution. TamedFlow studies their interface: whether a compressed student can reliably replace short segments of a teacher trajectory.

Step Count Reduction in Diffusion and Flow Models

Step reduction lowers the number of solver evaluations. Higher-order solvers improve numerical efficiency for a fixed model [24, 13], while distillation changes the model: progressive distillation shortens the schedule [21], consistency models match predictions across noise levels [25, 14], MeanFlow and Model-Guidance alter the target or absorb guidance [3, 26]. Other formulations align distributions or scores, distill autoregressively, transfer trajectories, or train few-step students adversarially [28, 32, 6, 15, 22]. These methods optimize a sparse standalone sampler deployed entirely on its own. TamedFlow instead retains a multi-step teacher as a reliable safeguard and uses the student to propose short trajectory segments whose acceptance is decided adaptively online.

A related line studies trajectory geometry. Rectified flow and InstaFlow construct straighter paths [12]; interpolant transformers unify diffusion and flow parametrizations [16]; and guided path sampling corrects trajectories during integration [8]. TCD and Hyper-SD learn consistency or trajectory segments for few-step sampling [30, 20]. TamedFlow keeps the teacher path as the reference, trains a cross-architecture student for selectively accepted rollouts, and retains teacher rescue in the deployed sampler.

Per-Step Compute Acceleration and Feature Caching

Per-step methods keep the schedule while avoiding full recomputation. Feature-reuse methods cache activations across timesteps or blocks [17, 2, 23, 33, 35, 27]; forecasting methods extrapolate future features (Liu et al., 2025a;b; Cai et al., 2026; Huang et al., 2025); and learned schedulers select policies per sample [29]. These methods exploit local regularity in intermediate computations. Our same-student diagnostic shows that their evaluated configurations do not transfer directly to the compressed student, but does not isolate a universal caching failure mechanism.

Most reuse methods leave the model unchanged and decide which internal computations can be skipped. TamedFlow instead trains the student under rollout supervision and learns whether an entire student-generated segment can advance without a teacher call. DisCa [34] also studies incompatibility between step-distilled video DiTs and feature caches, but repairs the cache side with a predictor and Restricted MeanFlow schedule. TamedFlow acts on the draft student instead.

Speculative Verification in Generative Paradigms

Speculative decoding verifies proposed tokens with a target model [7]; causal masking permits parallel verification and exact correction. Diffusion lacks this structure because each teacher state depends on the preceding prediction. Replaying a $K$-step draft exactly would require sequential teacher evaluations and remove much of the saving. SpecDiff [18] studies self-speculative diffusion under this constraint. TamedFlow replaces exact verification with learned trajectory estimation. The LTE scores student-internal features after a draft using rollout agreement as its training target. Accepted drafts avoid the teacher; rejected drafts return to the pre-draft state for one teacher step. Routing is therefore inexpensive and online, but approximate and not distribution-preserving by construction.

Preliminaries: Diffusion Models, DiT, and Flow Matching

Diffusion models ([4]) learn to reverse a gradual noising process, so generation requires a sequence of state-dependent model evaluations. A Diffusion Transformer (DiT) ([19]) implements the denoiser with a transformer over latent patches and injects timestep and condition information through adaptive layer normalization. Our method is expressed in velocity form because both its trajectory loss and its stability analysis act on the vector field followed during sampling.

Flow matching ([9]) casts generation as a probability-path ODE. With $x_0 \sim\mathcal{N}(0, I)$, $x_1 \sim p_{\mathrm{data}}$, and the linear interpolant $x_t = (1-t)x_0 + tx_1$, the conditional velocity $x_1 - x_0$ supplies the regression target:

We use forward flow time, from noise at $t = 0$ to data at $t = 1$. The main experiments use the stated DDIM schedules; the Euler discretization below is an analysis device and the rollout rule used to define the trajectory objectives.

Spatial Error Amplification and Rollout Stability

Pointwise velocity matching constrains the student at sampled states but not the states reached after its own predictions are chained. The following proposition separates the local mismatch that initiates drift from the spatial sensitivity that amplifies it. It applies to sequential Euler drafts and does not analyze internal feature caching or forecasting.

where $h>0$ is the fixed Euler integration step size; for $C=0$, the right-hand side is interpreted as $Kh\|\delta_v\|_\infty$. For $KhC\ll1$, this implies the few-step expansion $Kh\|\delta_v\|_\infty+ O(K^2h^2C\|\delta_v\|_\infty)$.

The recurrence $\|e_{k+1}\|_2 \leq(1+hC)\|e_k\|_2 + h\|\delta_v\|_\infty$, unrolled from $e_0=0$, gives Eq. (2); Appendix § 11 gives the proof. The implication for method design is limited but useful: reducing one-step mismatch is insufficient when the same error is repeatedly propagated, so training should also expose the student to short rollouts. The bound neither establishes a universal quadratic error law nor guarantees that our objectives minimize $C$.

Stagewise Training

Figure 2 summarizes AlignNet for feature alignment, VAH for residual velocity correction, and LTE for draft scoring. A two-stage curriculum separates feature initialization from rollout supervision.

Setup and state extraction. Let $v_T$ and $v_S$ denote the teacher and student velocity fields used by the solver. Pointwise distillation uses $\mathcal{L}_v = \mathbb{E}[D^{-1}\|v_S(x_t,t)-v_T(x_t,t)\|_2^2]$, where $D$ is the latent dimension; Stage 2 applies this loss to the aligned student velocity defined below. The student backbone also exposes hidden tokens from its ordinary forward pass, which the LTE later uses for routing without an additional backbone evaluation.

Stage 1: Feature alignment. Stage 1 freezes VAH and trains the backbone with velocity and intermediate-feature matching. AlignNet uses 2-layer MLP projectors to pair student layers $\{3, 7, 11\}$ with teacher layers $\{9, 18, 27\}$, spanning early through late representations.

Here $\pi(3)=9$, $\pi(7)=18$, and $\pi(11)=27$. The Stage 1 objective $\mathcal{L}_{\mathrm{stage1}}=\mathcal{L}_v+\lambda_{\mathrm{align}}\mathcal{L}_{\mathrm{align}}$ initializes a student whose intermediate representation and velocity prediction are both anchored to the teacher before free-running supervision begins.

Stage 2: Rollout supervision. After Stage 1 stabilizes, we activate rollout-level supervision. To learn a residual velocity correction, we unfreeze the Velocity Alignment Head (VAH), a convolutional residual head initialized with a small output correction, so $v_S^{\mathrm{aligned}}\approx v_S$:

Stage 2 trains the model for short-horizon use. We compare aligned student and teacher velocities at teacher states and separately penalize the endpoints obtained when each model follows its own rollout:

where $\mathcal{L}_{\mathrm{roll}}(K)=\frac{1}{KD}\sum_{k=0}^{K-1}\left\|v_S^{\mathrm{aligned}}(x_T^{(k)},t+k\Delta t)-v_T(x_T^{(k)},t+k\Delta t)\right\|_2^2$ is teacher-state velocity anchoring, whereas $\mathcal{L}_z=D^{-1}\left\|x_S^{\mathrm{roll}}(K)-x_T^{\mathrm{roll}}(K)\right\|_2^2$ is the free-running endpoint loss obtained by rolling each field from the same start state on its own states. The endpoint loss backpropagates through the unrolled student steps, while training samples $K$ uniformly from $\{1,2,3,4,5\}$ so the model is not specialized to one horizon. For any fixed teacher-state rollout, $\|\delta_v\|_\infty\le\sqrt{KD\mathcal{L}_{\mathrm{roll}}}$; this links the empirical loss to the forcing term in Proposition 3.1, but is not a uniform guarantee from the average training objective. The LTE is trained with

where $\bar{f}_S^{\mathrm{last}}$ denotes mean-pooled hidden tokens from the last student forward in the draft and $\operatorname{sg}[\cdot]$ denotes stop-gradient. Thus the LTE learns from the same type of signal available online, while its loss does not perturb the student backbone.

Self-Speculative Execution via Confidence Routing

For a $K$-step draft, the target score $c^*$ combines endpoint rollout deviation with the velocity error at the shared start state:

with latent dimension $D$ and temperatures $T_z$, $T_v$. The score decreases as either discrepancy grows; it is a regression target, not a calibrated probability that a draft preserves sample quality. At inference the LTE predicts this score from student features alone.

LTE inference. For a clipped draft of length $m$, the LTE uses mean-pooled tokens and the timestep embedding from the last drafting forward at $t_{i+m-1}$, together with the condition representation:

The LTE has no explicit horizon input, so its score is an empirical routing signal rather than a horizon-specific error guarantee.

Routing. The student drafts $K$ steps, clipped at the schedule boundary. If $c \ge\tau$, the sampler accepts the entire draft and bypasses the teacher; otherwise it discards the tentative states, restores the pre-draft state, and advances one step with the teacher. Appendix § 13 gives the full algorithm.

Experiments

Experimental Setup

Models and datasets. The primary setting distills a 675M DiT-XL/2 teacher $T_\phi$ [19] into a 130M DiT-B/2 student $S_\theta$ on class-conditional ImageNet at 256 $\times$ 256. We evaluate resolution scaling on ImageNet $512 \times512$, text conditioning on MS-COCO, and video generation with Latte on FaceForensics. For COCO, a shared 19.9M text-conditioning adapter maps 77-token CLIP ViT-L/14 features into the DiT conditioning space; the teacher and student use this shared adapter while the ImageNet-trained VAH and LTE remain fixed. For Latte, the student, AlignNet, VAH, and LTE are retrained for the evaluated video-DiT setting. Complete training schedules, solver settings, and adaptation protocols are provided in Appendices § 6 and E.

Metrics and reporting. On ImageNet, we report FID-50K and Inception Score (IS); on MS-COCO, FID-30K and CLIP-Score computed with OpenAI CLIP ViT-L/14; and on FaceForensics, FVD and video Inception Score. Image and text-to-image wall-clock latency and speedup are measured on a single A800-80GB GPU at batch size one and averaged over 10 runs. All baseline rows are measured in our local implementations under the same reporting protocol. Speedup is normalized to the corresponding teacher, and the LTE accept rate is the fraction of routing events that retain the student draft. FLOPs count backbone evaluations, whereas latency also includes VAH, LTE, rollback, and solver overhead.

Baselines. We compare against schedule-reduction references (DDIM-25 and DDIM-20), full-scale few-step distillation methods (Progressive Distillation [21], LCM [14], and ARD [6]), and adaptive or speculative methods ($\Delta$-DiT [2], TaylorSeer [10], FoCa [31], FORA [23], SpeCa [11], and SpecDiff [18]). Adaptive and speculative baselines are re-implemented in the matched DiT-XL/2 pipeline and measured locally under the same latency protocol. Few-step distillation baselines use the full teacher architecture without parameter compression. Appendix § 7 details the comparison scope and accounting assumptions.

Main Results

Quality–latency operating points. Table 1 compares complete systems across speedup regimes. Four-step distillation baselines attain aggressive $14\times$–$15\times$ acceleration at the cost of severe FID degradation. TamedFlow instead targets moderate acceleration with tight quality retention: at $\tau= 0.85$, it matches the DDIM-50 teacher within 0.02 FID (2.33 vs. 2.35) at $1.73\times$ speedup; at default $\tau= 0.80$, it reaches FID 2.58 at $2.25\times$ speedup (0.464 s).

Method	Latency (s) $\downarrow$	Speedup $\uparrow$	FLOPs (T) $\downarrow$	FID $\downarrow$	IS $\uparrow$
DDIM-50 Teacher	1.044	$1.00\times$	23.74	2.35	237.62
Pure Student	0.180	$5.80\times$	2.30	5.56 (+3.21)	195.07 (-42.55)
Full-Scale Few-Step Distillation
Progressive Distill. (step=4) [21]	0.068	$15.35\times$	0.474	10.25 (+7.90)	181.58 (-56.04)
LCM (step=4) [14]	0.072	$14.50\times$	0.476	6.81 (+4.46)	202.73 (-34.89)
ARD (step=4) [6] ($N = 6$)	0.074	$14.11\times$	0.480	4.32 (+1.97)	209.03 (-28.59)
1.5$\times$–2.0$\times$ Speedup Range
DDIM-25	0.558	$1.87\times$	11.87	3.21 (+0.86)	229.91 (-7.71)
$\Delta$-DiT [2] ($N = 2$)	0.684	$1.53\times$	18.04	2.78 (+0.43)	223.47 (-14.15)
TaylorSeer [10] ($N = 2$)	0.630	$1.66\times$	12.35	2.47 (+0.12)	230.21 (-7.41)
FoCa [31] ($N = 2$)	0.634	$1.65\times$	12.35	2.37 (+0.02)	233.70 (-3.92)
SpecDiff [18]	0.644	$1.62\times$	14.58	2.39 (+0.04)	235.18 (-2.44)
TamedFlow ($\tau= 0.85$)	0.602	$1.73\times$	8.53	2.33 (-0.02)	236.15 (-1.47)
2.0$\times$–2.5$\times$ Speedup Range
DDIM-20	0.442	$2.36\times$	9.49	3.87 (+1.52)	219.40 (-18.22)
FORA [23] ($N = 3$)	0.482	$2.17\times$	8.58	3.65 (+1.30)	228.14 (-9.48)
TaylorSeer [10] ($N = 3$)	0.477	$2.19\times$	8.56	2.73 (+0.38)	229.36 (-8.26)
FoCa [31] ($N = 3$)	0.466	$2.24\times$	8.56	2.65 (+0.30)	230.56 (-7.06)
SpeCa [11]	0.504	$2.07\times$	4.76	2.78 (+0.43)	229.74 (-7.88)
TamedFlow ($\tau= 0.80$)	0.464	$2.25\times$	6.83	2.58 (+0.23)	233.43 (-4.19)

In the $2.0\times$ to $2.5\times$ range under nearly matched latencies around 0.46 to 0.48 seconds, TamedFlow achieves better quality than FoCa at FID 2.65 and TaylorSeer at FID 2.73, alongside a higher Inception Score. This represents a quality advantage at matched latency rather than a throughput claim from millisecond-scale differences. Although SpeCa reports lower backbone FLOPs of 4.76 T, its FID is 0.20 worse, and backbone FLOPs omit runtime overheads like rollback, VAH, and LTE that are fully captured by measured latency. Thus, TamedFlow’s edge lies in its empirical Pareto trade-off for the deployed system, not a FLOPs-only claim.

Qualitative study. Figure 3 compares generated samples under matched speedup ($2.1\times$–$2.25\times$). TamedFlow preserves fine textures and object boundaries more cleanly across diverse classes. For example, it avoids the over-smoothed fur patterns on Tabby and Boxer seen in competing adaptive methods, and retains clear structural separation between the metal hoops and wood grain on Barrel. These visual examples align with aggregate FID trends, while the following ablations isolate the underlying mechanisms.

Component Ablation

Table 2 isolates the contribution of each architectural module and training objective at draft length $K = 3$ and routing threshold $\tau= 0.80$.

Study	Variant	Accept % ↑	Speedup ↑	FID ↓	IS ↑
Component	Full TamedFlow	63.6	2.25×	2.58	233.43
Component	w/o AlignNet	46.2	1.87×	2.95	211.34
Component	w/o VAH	39.3	1.63×	3.23	205.71
Component	w/o LTE	–	5.80×	5.56	195.07
Training	Full TamedFlow	63.6	2.25×	2.58	233.43
Training	w/o $\mathcal{L}_{\mathrm{roll}}$	54.2	2.02×	2.71	230.15
Training	w/o $\mathcal{L}_{z}$ warmup	46.2	1.81×	3.29	203.50
Training	w/o $\mathcal{L}_{z}$	28.1	1.45×	4.15	198.80

Modules and training objectives. AlignNet initializes student representations from intermediate teacher layers; removing it drops acceptance to 46.2% and raises FID to 2.95 due to suboptimal representation grounding. Disabling the VAH reduces acceptance to 39.3% and increases FID to 3.23, reflecting its role in absorbing local residual velocity mismatch (without claiming an explicit theoretical reduction in $\Delta J$). Without the LTE, unrouted student execution reaches 5.80× speedup but degrades severely to FID 5.56 in the absence of corrective recovery. For training losses, omitting rollout supervision $\mathcal{L}_{\mathrm{roll}}$ weakens intermediate velocity consistency and increases FID to 2.71. Removing the endpoint loss $\mathcal{L}_{z}$ has the most severe impact, dropping acceptance to 28.1% and inflating FID to 4.15; its unrolled multi-step gradient directly penalizes compounding trajectory drift during autonomous rollouts. Removing the 10-epoch warmup on $\mathcal{L}_{z}$ yields FID 3.29 due to early optimization shocks before feature representations stabilize.

Routing-policy controls. Table 9 compares policies using the same trained student, VAH, Euler grid, and guidance. At nearly identical latency (0.465 versus 0.464 s), LTE improves FID over random draft acceptance from 4.05 to 2.58. The random control enforces eight teacher updates per trajectory; LTE retains unconstrained $\tau= 0.80$ routing. Thus this comparison supports learned routing at nearly matched latency, without establishing equal teacher usage. Static controls are faster but have worse FID. Appendix § 14.§ 1 gives the execution and call-accounting details.

Routing policy	Teacher updates	Latency (s) ↓	FID ↓
Pure Student	0	0.180	5.56
Static: Random Steps	8	0.348	3.72
Static: Fixed Periodic	8	0.335	3.45
Dynamic: Random Accept	8	0.465	4.05
Dynamic: LTE	Adaptive	0.464	2.58

Routing Dynamics and Sensitivity

Draft length $K$ and threshold $\tau$ balance speedup against fidelity (Appendix Figure 10). Speedup peaks at $K = 3$ because longer drafts compound drift and increase rollback costs upon rejection. As shown in Figure 4, LTE confidence remains high in the mid-noise regime but drops near the plotted noise level 0.22, invoking more teacher rescues late in sampling. The distribution shows clear operational separation between accepted and rejected drafts at the chosen operating point $\tau= 0.80$.

In the reference trace at $K = 3$ and $\tau= 0.80$, 14 of 22 routing events are accepted, allowing student rollouts to cover 42 of the 50 integration steps. Detailed component profiling reveals that teacher rescue accounts for 71.9% of wall-clock latency, whereas student rollouts take 14.9%, rejections with state rollback consume 12.7%, and LTE confidence scoring incurs only 0.5%. The lightweight estimator itself introduces negligible computational latency, but routing accuracy remains paramount: false acceptances allow subtle draft errors to compound and degrade fidelity, while false rejections trigger expensive teacher interventions that erode throughput. This concrete latency breakdown also explains why measured end-to-end speedup does not strictly match backbone FLOPs, as runtime costs from state rollback, synchronization, and auxiliary modules are omitted from nominal FLOP totals.

Cross-Setting Evaluation

On MS-COCO, the teacher and student share a trained 19.9M text adapter while the ImageNet-trained VAH and LTE remain frozen. As reported in Table 3, TamedFlow reaches FID 14.86 and CLIP-Score 29.6 at 1.96× speedup at $\tau= 0.80$, and 2.14× speedup with FID 15.52 at $\tau= 0.75$, outperforming SpeCa and FoCa at comparable latency. This supports transfer of the frozen alignment modules under condition adaptation rather than unadapted zero-shot deployment. Tightening $\tau$ improves FID by 0.66 and CLIP-Score by 0.4 for 52 ms latency, verifying that fidelity recovery stems from teacher intervention rather than student capacity.

Table 3: MS-COCO 30K 256 × 256 text-to-image generation using fixed-step DDIM. TaylorSeer, SpeCa, and FoCa are re-implemented within our DiT-XL/2 pipeline; $N$ denotes each method’s acceleration setting rather than TamedFlow’s draft horizon $K$.

Method	Latency (s) ↓	Speedup ↑	FID ↓	CLIP-S ↑
Teacher DDIM-50	1.184	1.00×	13.54	30.2
Teacher DDIM-25	0.622	1.90×	16.84	28.9
Pure Student	0.203	5.83×	19.30	27.8
TaylorSeer ($N = 3$)	0.580	2.04×	15.47	29.1
SpeCa	0.561	2.11×	16.63	28.4
FoCa ($N = 3$)	0.565	2.09×	16.27	28.5
TamedFlow ($\tau= 0.80$)	0.603	1.96×	14.86	29.6
TamedFlow ($\tau= 0.75$)	0.551	2.14×	15.52	29.2

We further evaluate spatial and temporal scaling. On ImageNet 512 × 512, expanding the latent grid fourfold under the same backbone, TamedFlow achieves FID 3.39 at 2.41× speedup in 1.594 s, outperforming FoCa at FID 3.47 with 2.36× speedup as reported in Appendix C. On the Latte video DiT retrained on FaceForensics at 256 × 256 resolution across 16 frames in Table 4, TamedFlow attains FVD 225.10 and IS 68.90 at 2.22× speedup, surpassing FoCa at FVD 248.30 and TaylorSeer at FVD 253.10. These results confirm that the draft and rescue mechanism transfers reliably across resolutions, conditions, and video modalities.

Table 4: Latte video-DiT transfer on FaceForensics (256 × 256, 16 frames).

Method	Speedup	FVD ↓	IS ↑
Teacher (Latte-XL)	1.00×	208.50	71.20
FoCa	2.06×	248.30	66.80
TaylorSeer	2.10×	253.10	65.90
TamedFlow	2.22×	225.10	68.90

Deployment cost. TamedFlow requires offline training and maintains the teacher, student, VAH, and LTE co-resident in memory, increasing peak allocated VRAM from 2.570 to 3.075 GB (~0.5 GB overhead). This footprint reflects the deliberate choice to retain a high-capacity teacher for selective rescue rather than discarding it. Headline latency is benchmarked for batch-one latent integration without VAE decoding, characterizing interactive generation rather than batched serving throughput. Teacher offloading and weight quantization represent orthogonal opportunities to mitigate co-residency overhead in production.

Conclusion

In this work, we introduced TamedFlow, an acceleration framework that reconciles parameter compression with adaptive execution for Diffusion Transformers. By training a compact student for short-horizon trajectory agreement and employing asymmetric routing with selective teacher rescue, TamedFlow achieves FID 2.58 at $2.25 \times$ speedup over DDIM-50 on ImageNet $256 \times256$, with transfer evaluated across resolutions, text conditioning, and video. Our findings show that pointwise alignment can leave compounding trajectory divergence during autonomous drafting, creating the Combination Gap. Controlled ablations support rollout supervision, and routing controls favor LTE over random decisions at nearly matched latency, suggesting that compression and adaptive inference can be made compatible when the compact model is trained as a multi-step drafter and the sampler retains a recovery path back to the teacher.

Training Hyperparameters

Table 5 summarizes the training hyperparameters for the two stages of TamedFlow.

Component	Stage 1	Stage 2
Optimizer	AdamW ($\beta_1 = 0.9$, $\beta_2 = 0.999$)
Base learning rate	$5 \times10^{-5}$	$1 \times10^{-4}$
Weight decay	0.0
Learning rate schedule	cosine decay with warmup
Warmup epochs	5
Max epochs	10	80
Batch size (per GPU)	32
Global batch size	256
Gradient clipping	1.0
Loss terms
Velocity loss $\mathcal{L}_v$	✓	✓
Alignment loss $\mathcal{L}_{\mathrm{align}}$	$\lambda= 0.25$	–
Rollout loss $\mathcal{L}_{\mathrm{roll}}(K)$	–	$\lambda= 0.8$
Endpoint loss $\mathcal{L}_z$	–	$\lambda_z$ (10-epoch warmup to 30.0)
Confidence loss $\mathcal{L}_{\mathrm{conf}}$	–	$\lambda= 1.0$
Model details
Student architecture	DiT-B/2 (12 layers)
Student parameters	130M
Teacher architecture	DiT-XL/2 (28 layers)
Teacher parameters	675M
AlignNet architecture	3 independent MLPs, $768 \to1152 \to1152$
VAH architecture	3-layer Conv2D residual head, hidden=256
LTE architecture	3 projections; MLP $1024 \to1024 \to256 \to1$
LTE parameters	∼4M (3% of student)
Inference hyperparameters
Draft length $K$	3 (training: $K \sim\mathcal{U}(1,5)$)
Temperature $T_z$	0.5
Temperature $T_v$	0.1
Mixing weight $\alpha$	0.7
Default $\tau$	0.8
LTE training
Gradient isolation	–	✓(stop-gradient)
LTE warmup epochs	5
LTE learning rate	$1 \times10^{-4}$

Baseline Comparison Scope

Table 1 compares end-to-end operating points, not isolated routers. The adaptive baselines retain the 675M teacher, whereas TamedFlow combines a 130M draft student with selective teacher rescue; compression, training, solver choice, routing, and rollback therefore all contribute to the measured result. All baseline entries, including SpecDiff, are evaluated in our local implementations under the stated protocol. TamedFlow FLOPs are backbone-call estimates; end-to-end latency additionally includes VAH, LTE, solver, and rollback overhead.

Table 11 serves a different purpose. It is a quality diagnostic in which adaptive reuse is attached directly to the compressed student, and therefore supports the motivating Combination Gap rather than a latency-matched routing comparison.

Strategy	FID	Strategy	FID
FoCa	10.40	TaylorSeer	11.92
SpeCa	13.18	Dense Student	5.56

Higher-Resolution Evaluation

We evaluate spatial scaling on ImageNet at $512 \times512$ with DiT-XL/2, DDIM-50, and one A800 GPU. The comparison holds the resolution and protocol fixed and tests whether the primary quality–latency ordering survives the larger latent grid.

Method	Latency (s) $\downarrow$	Speedup $\uparrow$	FID $\downarrow$	IS $\uparrow$
Teacher (DiT-XL/2, 675M)	3.842	$1.00\times$	2.87	235.10
TaylorSeer ($N = 3$)	1.715	$2.24\times$	3.76	226.75
FoCa ($N = 3$)	1.628	$2.36\times$	3.47	228.10
TamedFlow ($\tau= 0.80$)	1.594	$2.41\times$	3.39	230.85

Multi-Seed Evaluation

We generate 50K ImageNet samples for each of three evaluation seeds using fixed checkpoints. These repeats quantify sampling variability, not independent training-run variability; every method follows the same evaluation protocol.

Method	Speedup	FID	IS
DDIM-50 Teacher	$1.00\times$	$2.36 \pm0.02$	$237.24 \pm0.48$
TaylorSeer ($N = 3$)	$2.19\times$	$2.71 \pm0.04$	$229.13 \pm0.62$
FoCa ($N = 3$)	$2.21\times$	$2.64 \pm0.03$	$231.24 \pm0.58$
TamedFlow, $\tau= 0.80$	$2.26\times$	$2.56 \pm0.03$	$233.89 \pm0.51$

Efficiency and Transfer Accounting

Deployment footprint. In a controlled A800, batch-size-2, FP32, 50-step latent-only profile with VAE decoding excluded, peak allocated VRAM is 2.570 GB for the teacher, 2.580 GB for FoCa ($N = 3$), 3.066 GB for TaylorSeer ($N = 3$, $O = 3$), and 3.075 GB for TamedFlow. Co-deploying the student and LTE therefore adds about 0.5 GB relative to the teacher-only profile. For the ImageNet and MS-COCO image experiments, all methods use classifier-free guidance at scale 3.5. The teacher FLOP reference includes the complete conditional and unconditional CFG evaluation, while the CFG-distilled student reference counts one student forward; this convention defines the teacher/student references and the TamedFlow backbone estimates.

Routing accounting. In the reference trace at $\tau= 0.80$, 14 of 22 routing events are accepted and 8 are rejected, giving a 63.6% event acceptance rate. Since each accepted event advances $K = 3$ Student steps, accepted drafts cover $42/50 = 84\%$ of the nominal trajectory; the remaining 8 steps use Teacher rescue. The separately measured component profile records 0.07075 s for accepted-draft buckets (14.9%), 0.06031 s for rejected-draft buckets including rollback (12.7%), 0.34142 s for Teacher rescue (71.9%), and 0.00237 s for LTE scoring (0.5%). These buckets sum to 0.47485 s (up to rounding). They are event-level timing buckets from the profiling run, so dividing a bucket by the number of backbone calls would incorrectly attribute rollback and routing overhead to an individual forward. The component profile and the headline latency measurement were collected in different runs: the 0.464 s headline is the separately measured ten-run average. We therefore report both traces without using one to reconstruct the other.

Backbone FLOP accounting. The 50-step references imply $f_S = 2.30/50 = 0.046$ T per CFG-distilled student forward and $f_T = 23.74/50 = 0.4748$ T per teacher update including both CFG branches. With the executed call counts defined in Appendix § 14.§ 1,

For the reference execution with 14 accepted and eight rejected full-length drafts, $N_S = 66$, $N_T = 8$, and $N_{\mathrm{LTE}} = 22$, yielding $66(0.046) + 8(0.4748) = 6.8344$ T. The full-length 13-accept/11-reject reference gives $72(0.046) + 11(0.4748) = 8.5348$ T. The rounded entries in Table 1 are call-based estimates for these reference configurations, not evaluation-set means. In contrast, a static eight-teacher policy has 42 student forwards and a backbone subtotal of $42(0.046) + 8(0.4748) = 5.7304$ T under the same accounting. VAH, LTE, rollback, and solver arithmetic are excluded from these backbone subtotals and included in measured latency. The 22 LTE calls do not require 22 additional student forwards because their features are reused from drafting. Logical conditional and unconditional teacher evaluations may be batched; eight guided teacher updates account for both branches, whereas the CFG-distilled student uses one branch per update. Backbone FLOPs alone do not predict measured latency.

Latte video protocol. We retrain the student, AlignNet, VAH, and LTE for the evaluated Latte video-DiT setting while keeping the TamedFlow training and inference configuration consistent with the primary experiments: Stage 1 for 10 epochs, Stage 2 for 80 epochs, $K = 3$ at inference, randomized $K \sim U(1,5)$ during rollout training, and the same loss weights and threshold as ImageNet. The original Latte teacher/student block configurations are retained; no width, depth, or temporal-factorization search is performed. Spatial and temporal tokens are treated as one spatiotemporal token sequence for AlignNet matching and LTE mean pooling, so the LTE adds no separate temporal backbone. Evaluation uses FaceForensics clips at $256 \times256$ resolution with 16 frames. We use the same clips and evaluation protocol for all methods, batch size 1, deterministic 50-step sampling, and latency measured end-to-end on 8 A800-80GB GPUs. VAE decoding is excluded from the reported latency. The video table reports FVD and video Inception Score together with the teacher-normalized speedup.

MS-COCO adaptation protocol. The shared 19.9M text-conditioning adapter is trained jointly with the teacher and student for 20 epochs (5 Stage 1 and 15 Stage 2). The implementation uses AdamW with learning rate $10^{-4}$ for the text adapter, a 0.1 learning-rate multiplier for the backbone parameters, weight decay 0.01, text-dropout probability 0.05, gradient clipping at 1.0, and EMA decay 0.9999. The DiT backbones are frozen except for the text-conditioning parameters; the LTE and VAH are frozen during this adapter-only adaptation. The adapter maps 77-token CLIP ViT-L/14 features into the DiT conditioning width and is shared by teacher and student.

Proof of the K-Step Trajectory Alignment Bound

Let $x_S^{(k)}$ and $x_T^{(k)}$ denote the states of the student and teacher at step $k$ during a $K$-step sequential Euler rollout, starting from the identical initial state $x_S^{(0)} = x_T^{(0)} = x_t$. We assume a fixed ODE solver step size $h$. With time arguments suppressed at the common $t_k = t + kh$, define the baseline velocity mismatch evaluated strictly on the teacher’s trajectory as $\delta_v^{(k)} \triangleq\tilde{v}_S(x_T^{(k)}) - v_T(x_T^{(k)})$, with its supremum bounded as $\lVert\delta_v\rVert_\infty\triangleq\max_k \lVert\delta_v^{(k)}\rVert_2$. Define the teacher’s Lipschitz constant $L_T \triangleq\sup_{x,t} \lVert\nabla_x v_T(x,t)\rVert_2$, and the Jacobian mismatch $\Delta_J \triangleq\sup_{x,t} \lVert\nabla_x \tilde{v}_S(x,t) - \nabla_x v_T(x,t)\rVert_2$.

Proof. Setup: recursive error accumulation. In a multi-step rollout, each model feeds its own prediction into the next Euler step:

Let $e_k \triangleq x_S^{(k)} - x_T^{(k)}$ denote the spatial deviation at step $k$, with the initial condition $e_0 = 0$. Subtracting the two updates yields the discrete error dynamics:

Decomposing the velocity difference via integral Taylor expansion. To separate the pointwise baseline error from the accumulated spatial drift, we add and subtract the student’s velocity at the

$\widetilde{v}_S(x_S^{(k)})-\mathit{v}_T(x_T^{(k)})=\underbrace{\left(\widetilde{v}_S(x_T^{(k)})-\mathit{v}_T(x_T^{(k)})\right)}_{\delta_v^{(k)}}+\underbrace{\left(\widetilde{v}_S(x_S^{(k)})-\widetilde{v}_S(x_T^{(k)})\right)}_{\text{Drift induced by }e_k}.$$

Since the velocity field $\widetilde{v}_S:\mathbb{R}^{D}\to\mathbb{R}^{D}$ is vector-valued, the scalar Mean Value Theorem does not apply. We instead write the spatial drift using the first-order Taylor expansion with an integral remainder along the line segment connecting $x_T^{(k)}$ and $x_S^{(k)}$:

Taking the $L_2$ norm of the error recurrence, substituting the decomposition and the integral expansion, and applying the triangle inequality yields:

Here, $\sup_x\lVert J_{\widetilde{v}_S}(x)\rVert_2$ is the student’s Lipschitz constant $L_S$. By splitting the student’s Jacobian into the teacher term and the mismatch term, we bound it with the matrix triangle inequality:

Since the integral over $[0,1]$ equals one, substituting the Jacobian bound into the preceding inequality gives the recurrence:

Solving the recurrence. Let $C\triangleq L_T+\Delta J$. Unrolling the recurrence with the initial condition $e_0=0$ yields a geometric series:

To expose the polynomial dependence on $K$ in the few-step regime, we use the Taylor expansion of the exact scalar term $(1+hC)^K$:

For $C=0$ the recurrence gives $\lVert e_K\rVert_2\le Kh\lVert\delta_v\rVert_\infty$. For $KhC\ll1$, expansion of the geometric upper bound gives:

Interpretation. The exact bound isolates the baseline velocity mismatch and shows how the combined Lipschitz/mismatch constant $C=L_T+\Delta J$ amplifies errors with the rollout horizon. In the few-step expansion, this produces the stated quadratic-in-$K$ sensitivity. Pointwise velocity matching directly supervises the forcing term but does not explicitly constrain the spatial amplification constant; it may nevertheless affect both. The expansion concerns an upper bound, not a measured error growth law.

Scope of the VAH Mechanism

VAH is a residual correction trained through the Stage-2 velocity and trajectory objectives in Eq. (5). No separate explicit Jacobian-matching objective is specified by this training recipe. For $v_S^{\mathrm{aligned}}=v_S+\operatorname{VAH}(v_S)$, the chain rule gives $J_{v_S^{\mathrm{aligned}}}=(I+J_{\mathrm{VAH}})J_{v_S}$. This permits changes to local derivatives but does not guarantee reduced Jacobian mismatch. Figure 9 reports velocity mismatch and endpoint drift only. It provides no Jacobian diagnostic: reduction of $\Delta J$ remains a theoretical possibility, not an experimentally established mechanism.

Algorithm 1 TamedFlow Inference

1: Input: $x \sim\mathcal{N}(0, I)$, $y$, discrete times $\{t_0, \ldots, t_N\}$, $K = 3$, threshold $\tau$ 2: $i \leftarrow0$ 3: while $i < N$ do 4: $m \leftarrow\min(K, N-i)$ ▷ Clip the terminal draft horizon 5: $x_{\mathrm{start}} \leftarrow x$ 6: for $k = 1$ to $m$ do ▷ Student drafts $m$ steps 7: $(v_S,\mathrm{tokens}_k) \leftarrow B_\theta(x, t_{i+k-1}, y)$ 8: $v_S \leftarrow v_S + \mathrm{VAH}(v_S)$ 9: $x \leftarrow x + (t_{i+k} - t_{i+k-1}) \cdot v_S$ 10: end for 11: $c \leftarrow\mathrm{LTE}(\mathrm{tokens}_m, e_{t_{i+m-1}}, e_y)$ ▷ Last draft features; no teacher access 12: if $c \geq\tau$ then 13: $i \leftarrow i + m$ ▷ Accept: advance by $m$, no teacher call 14: else 15: $x \leftarrow x_{\mathrm{start}}$ ▷ Reject: roll back to pre-draft state 16: $v_T \leftarrow T_\phi(x, t_i, y)$ ▷ Teacher rescue evaluation step 17: $x \leftarrow x + (t_{i+1} - t_i) \cdot v_T$ 18: $i \leftarrow i + 1$ 19: end if 20: end while 21: return $x$

Inference Details

Velocity-field interface and guidance. The symbol $v_T$ denotes the effective teacher right-hand side used by the Euler solver, including the prescribed conditioning and guidance, rather than specifying the raw prediction type of the underlying DiT. Student–teacher velocity losses and teacher reference rollouts are expressed in this same solver coordinate system. The single-branch student is distilled toward the guided teacher field; a teacher rescue still evaluates the complete guided teacher update. The linear-interpolant objective in § 3.4 introduces the velocity-form convention and, by itself, does not identify the pretrained teacher’s native output parameterization or noise schedule. An architecture name alone does not determine a checkpoint or an output-to-ODE conversion.

Time coordinates. The solver and all rollout equations use increasing flow time $t$, with noise at $t = 0$ and data at $t = 1$. Figure 4 retains a decreasing noise-level plotting coordinate on its upper axis; that axis label is not the forward-time variable in the solver equations. The reported value 0.22 describes that plotted noise coordinate, not forward flow time. Sampling-step indices are used to compare the routing profile with execution order.

Algorithm 1 gives the full routing loop under the forward flow-time convention $t_0 < \cdots< t_N$. The student drafts up to $K$ steps without teacher access, and the LTE scores the draft from the last student forward, the same type of input used during LTE training. Rejection restores the pre-draft state before one teacher rescue step; no endpoint backbone call is added for scoring.

LTE Calibration and Routing Metrics

Table 8 reports held-out routing diagnostics at $\tau= 0.80$ and $K = 3$. The LTE regresses the continuous target $c^{\star}$ in Eq. equation 7; binary labels are introduced only to summarize thresholded routing errors.

Reference labels and routing errors. A draft event is labeled offline as accept when $c^{\star} \geq0.80$ and reject otherwise; the online decision accepts when the prediction $c \geq0.80$. FAR uses the 4,683 reference-reject events as its denominator, FRR uses the 11,984 reference-accept events, and AUC ranks events by continuous $c$. These labels measure agreement with the specified teacher-consistency target, not preservation of final sample quality.

Validation protocol. Threshold and score-temperature choices are selected on a calibration split and then frozen. Table 8 is computed on a held-out trajectory-level split, preventing draft events from one trajectory from appearing in both sets. Continuous-target ECE is the event-weighted 10-bin discrepancy between mean $c$ and mean $c^{\ast}$; it measures score agreement rather than a probability of correct generation.

Support (Reference)	Accept	Reject
Count	11,984	4,683
Metric	Value
False Accept Rate (FAR)	0.063
False Reject Rate (FRR)	0.051
AUC	0.94
Continuous-target ECE (10 bins)	0.034

Table 8: LTE classification and calibration metrics on the ImageNet 256 × 256 validation set at $\tau= 0.80$, $K = 3$. Support counts reference labels obtained by thresholding $c^{\ast}$ at 0.80. FAR and FRR use reference-reject and reference-accept events as their respective denominators. AUC uses continuous predictions; continuous-target ECE uses 10 confidence bins.

The reference-positive fraction is 11,984/16,667 = 71.9%, whereas the online predicted acceptance rate is 63.6%. These use different labels and event populations, so their difference alone does not identify distribution shift. Held-out diagnostics do not establish error rates along free-running online trajectories. Thresholding predicted confidence separates routed events by construction; these held-out diagnostics do not establish calibration against actual draft error.

Routing-control protocol and call accounting

The controls in Table 9 use the same trained student checkpoint, VAH, 50-step Euler grid, CFG configuration, and ImageNet FID-50K protocol. Latency follows the single-A800, batch-one protocol in the main experiments. These measurements evaluate inference policies without retraining the student.

Static policies. Pure Student performs all 50 updates with the student and never calls the teacher. Random Steps independently selects a set of eight distinct integration steps per trajectory before sampling and replaces those student updates with teacher updates. Fixed Periodic uses the one-based integration-step indices 6, 12, 18, 24, 30, 36, 42, 48. Neither static policy executes a speculative student draft at a teacher-designated step. Both therefore execute exactly 42 student forwards and eight teacher updates.

Budget-constrained random decisions. Random Accept uses the same $K = 3$ draft-and-rollback structure as LTE, but substitutes a random accept decision with nominal probability $p = 0.636$. The policy enforces exactly eight teacher updates per trajectory. Once that budget is exhausted, subsequent drafts are accepted. A budget-feasibility override forces rejection when accepting a draft would leave too few integration steps to spend the remaining teacher budget. A rejection discards the draft, restores its starting state, and advances one teacher step. Consequently, the actual decisions are not independent Bernoulli draws throughout the trajectory, and $p$ is not a measured acceptance rate.

LTE policy. LTE uses the original confidence threshold $\tau= 0.80$ without a fixed per-trajectory teacher budget. Its teacher and student call counts depend on the trajectory. The previously reported 14 accepted and eight rejected events describe a reference execution, not a measured evaluation-set mean. Thus the random control and LTE share the execution framework and nearly match measured latency, but are not established to have identical average teacher usage.

LTE evaluations versus backbone calls. Let $A$ and $R$ denote accepted and rejected draft events. Each draft triggers exactly one LTE evaluation, regardless of whether it is accepted; only rejection triggers a teacher update. For the terminal-clipped $K = 3$ loop,

Here $m_j$ is the number of student steps executed in draft $j$. Only a terminal accepted draft can have fewer than three steps. Conditional on $R = 8$, the 42 committed student steps therefore consist of exactly $A = 14$ accepted drafts, and $N_{\mathrm{LTE}} = 14 + 8 = 22$. The event acceptance rate is $14/22 = 63.6\%$, whereas the fraction of committed integration steps executed by the student is $42/50 = 84\%$. These are different denominators. If all rejected drafts also have length three, $N_S = 66$; terminal clipping can reduce student work without changing the 22 routing events in this case. Thus eight teacher updates correspond to 22 LTE evaluations in the stated 50-step trajectory, not eight or 66 LTE evaluations. The budget-constrained random policy similarly has 22 decision events when $R = 8$, but uses random decisions rather than requiring LTE network scores. This conditional identity does not establish the mean teacher usage of unconstrained LTE over the evaluation set.

Derived student-forward counts. For the random control, the eight teacher updates leave 42 committed student steps. Executed student forwards additionally include every discarded draft:

where $m_j$ is the executed length of rejected draft $j$. This gives $N_S = 66$ when all eight rejected drafts have length three; terminal clipping can reduce the count. For the reference LTE execution, full-length drafts similarly give $N_S = 3(14 + 8) = 66$ and $N_T = 8$. These are conditional accounting values, not measured mean call counts or latency predictions.

Interpretation. The dynamic comparison gives an FID difference of 1.47 at a latency difference of 0.001 s, supporting the usefulness of learned routing at the measured operating point. The 0.001 s difference is not interpreted as a speed advantage. Static controls are faster (0.335–0.348 s) but have higher FID (3.45–3.72). These measurements do not establish that LTE identifies high-curvature regions, nor do they isolate decision quality at exactly matched teacher usage. The routing-control table reports point estimates; variability across random-policy seeds is not quantified here.

Additional Ablation Study

Table 10 extends the main ablation with randomized-horizon variants. Unless stated otherwise, rows use ImageNet $256 \times256$, $K = 3$, and $\tau= 0.80$.

Variant	Accept Rate % $\uparrow$	Speedup $\uparrow$	FID $\downarrow$	IS $\uparrow$
Full TamedFlow (default)	63.6	2.25$\times$	2.58	233.43
Module and loss ablations
w/o AlignNet	46.2	1.87$\times$	2.95	211.34
w/o VAH	39.3	1.63$\times$	3.23	205.71
w/o $L_{\mathrm{roll}}$	54.2	2.02$\times$	2.71	230.15
w/o $L_z$ warmup	46.2	1.81$\times$	3.29	203.50
w/o $L_z$	28.1	1.45$\times$	4.15	198.80
$K$ strategy ablations
Random $K \sim U(1, 3)$	75.0	2.14$\times$	2.53	233.22
Random $K \sim U(1, 5)$ (default)	63.6	2.25$\times$	2.58	233.43
Pure Student (no LTE, no routing)	–	5.80$\times$	5.56	195.07

The extended rows reinforce the main ablation: representation alignment, residual correction, rollout loss, and endpoint loss each improve the usable routed operating point. Randomizing training over $K \sim U(1, 3)$ yields a nearby but distinct point (FID 2.53 at 2.14×), whereas the wider default $U(1, 5)$ reaches FID 2.58 at 2.25×.

At fixed $K = 3$, the 75.0% point corresponds to 15 accepted and 5 rejected events (60 student and 5 teacher calls under full-length drafts), whereas the 63.6% point corresponds to 14 accepted and 8 rejected events (66 student and 8 teacher calls). Thus the call-count model predicts lower backbone work for the higher-acceptance point. Its measured 2.14$\times$ versus 2.25$\times$ ordering was obtained from separate checkpoint/runtime measurements, and the available component trace does not provide a matched per-call timing decomposition; we therefore do not interpret this ordering as a monotonic acceptance–latency law.

Under the common DDIM-50 diagnostic, directly attaching FoCa, TaylorSeer, or SpeCa to the compressed student degrades FID relative to dense student execution. This documents the Combination Gap for these implementations; it does not test whether the same methods remain fragile after trajectory training.

For the DPM-Solver++(2M) diagnostic, the multistep history is associated with the current accepted state. When a student draft is rejected, the tentative student states and derivative history are discarded together; the sampler rolls back, applies one teacher rescue update, and starts a fresh solver history at the rescued state. No student derivative is mixed with a teacher derivative across a rejection boundary, and the first post-handoff update uses the solver’s order-one startup rule before the two-step history is rebuilt. Thus Table 12 tests end-to-end robustness under an explicit reset policy; Proposition 3.1 continues to cover only the Euler analysis.

Solver	Method	Latency	Speedup	Accept	FID	IS
Euler	Teacher	1.044	1.00$\times$	–	2.35	237.62
Euler	TamedFlow	0.464	2.25$\times$	63.6%	2.58	233.43
DPM-Solver++(2M)	Teacher	1.089	1.00$\times$	–	2.25	244.12
DPM-Solver++(2M)	TamedFlow	0.455	2.39$\times$	75.0%	2.44	237.55

Figure 9 reports velocity and endpoint errors, not Jacobian alignment. Removing AlignNet or VAH changes the measured velocity or endpoint mismatch, while removing rollout supervision increases short-horizon drift.

Figure Figure 10 visualizes the impact of draft horizon $K$ and routing threshold $\tau$ on generation quality and inference efficiency. The four marginal panels show FID and speedup versus $\tau$ (top) and $K$ (bottom). These one-dimensional sweeps motivate the default operating point but do not establish a globally optimal Pareto frontier.

Limitations

While TamedFlow provides empirical gains across several settings, our findings are subject to several key limitations:

Theoretical scope of rollout analysis. The discrete Grönwall bound in Proposition 3.1 characterizes error accumulation under sequential Euler drafting to motivate multi-step trajectory supervision. It does not constitute a universal failure law for internal feature caching or forecasting methods, nor does it provide formal convergence or stability guarantees for higher-order ODE solvers such as DPM-Solver++.

Approximate nature of trajectory routing. The Learnable Trajectory Estimator (LTE) operates as an empirical regression model trained on offline consistency targets rather than an exact, distribution-preserving verification mechanism. Rejection decisions are heuristic; false rejections incur latency penalties through redundant teacher evaluations, whereas false acceptances may allow minor perceptual artifacts to propagate into the generated sample.

Deployment and infrastructure overhead. TamedFlow relies on a multi-stage offline training curriculum and maintains the teacher, student, VAH, and LTE models co-resident in GPU memory during inference ($\sim0.5$ GB VRAM overhead in our FP32 profile). As a result, it does not fully eliminate the teacher model from deployment. Furthermore, our reported speedups reflect batch-size-one latent generation on single GPUs; characterization under large-batch throughput, concurrent serving pipelines, and extreme memory-constrained edge environments remains an avenue for future work.

LLM Usage Statement

Large language models were used for language editing and consistency checks across the manuscript. Experimental results are author-provided; the authors are responsible for checking the final equations, measurements, citations, and implementation details.