Skip to content

Versatile Editing of Video Content, Actions, and Dynamics without Training

Conference: ECCV2026
Paper: ECCV 2026 official page
Area: Video Generation
Keywords: training-free video editing, inversion-free editing, flow matching, action and dynamics editing, noise correlation schedule

TL;DR

DynaEdit builds a noise-free editing trajectory from the source video straight to the edited video on a pretrained image-to-video flow model (WAN2.1 14B), pushes the starting timestep all the way to pure noise so that coarse spatio-temporal structure can actually be rewritten, and then fixes the two resulting failure modes with Similarity Guided Aggregation (SGA), which soft-selects the edit direction least divergent from the source video, and Annealed Noise Correlation (ANC), which suppresses high-frequency jitter -- thereby supporting object insertion/replacement, action rewriting and global dynamic effects with no training at all, matching the only trained commercial model, Runway Aleph.

Background & Motivation

Generative video models have reached the point where they reproduce physics, causality and complex dynamics convincingly enough to be regarded as "world models" with an inherent understanding of the physical world. This raises an obvious question: instead of generating a video from scratch, can we tap that knowledge to rewrite a real video -- turn a horse's circling into a jump over an obstacle, replace one object with another and let it genuinely interact with the scene, or impose a global effect such as a sandstorm or fireworks? Video editing has advanced rapidly, but the vast majority of methods perform structurally aligned edits: style, material and appearance change while the motion skeleton and object interactions stay put. Non-rigid dynamic rewriting -- changing the physical outcome of a video -- remains an open problem.

The difficulty lies in a tension built into the editing objective itself. The model needs enough freedom to rewrite motion and object interactions, yet must stay strictly faithful to the identity of the original objects and to the environmental context. The data-driven route is blocked here because non-rigid editing requires precisely paired source-target videos showing the same scene under different physical outcomes, which can neither be collected nor simulated at scale; consequently the only publicly available general-purpose trained model at the time of writing is Runway's Gen-4 Aleph, and it still struggles with complex non-rigid action edits. Training-free routes (FlowEdit, FlowAlign, FlowDirector, DynVFX and others) exploit the priors of a pretrained video flow model and sidestep the data problem, but they remain confined to structure-preserving editing: either attention maps or masks restrict the edit to a designated region, or the starting timestep is lowered to keep alignment -- at the cost of being unable to touch coarse spatio-temporal features, with inserted objects reacting one-sidedly to the scene but unable to change how the original video unfolds. In other words, the freedom to change motion and the fidelity to the source video are squeezed onto a single knob, and neither side will give.

This paper turns that knob all the way and then designs compensations for the side effects. The authors push the inversion-free editing trajectory to start from pure noise, giving the target prompt complete freedom to rewrite coarse structure, and then diagnose the two phenomena this necessarily produces -- low-frequency misalignment (gratuitous drift of camera motion and object trajectories) and high-frequency jitter (fuzzy, flickering edges of newly generated content) -- attributing them to "the initial noise realization directly determines the coarse spatio-temporal structure of the entire video" and "uncorrelated noise across consecutive timesteps accumulates into visible perturbation". Core idea: treat every step of the editing trajectory as a choice among candidate directions -- draw several noise samples to produce candidate edit directions and soft-select among them by how similar their projected end point is to the source video (SGA), then let the correlation between consecutive timesteps' noises grow as sampling proceeds, freezing the already-chosen direction (ANC).

Method

Overall Architecture

DynaEdit takes a source video \(x^{\text{src}}\), a source prompt \(c^{\text{src}}\) describing it, a target prompt \(c^{\text{tar}}\) describing the edit, and optionally an edited first frame \(f^{\text{tar}}\); it outputs an edited video. The whole method runs on a pretrained image-to-video (I2V) flow model whose weights stay frozen throughout.

The backbone follows the inversion-free editing paradigm of FlowEdit: rather than searching for the initial noise that reconstructs the source video, it directly constructs an ODE that carries the source video to the edited one while every intermediate quantity along the path remains noise-free. Writing the source- and target-conditioned velocity fields as \(V^{\text{src}}_t(x_t)=V(x_t,t,c^{\text{src}},f^{\text{src}})\) and \(V^{\text{tar}}_t(x_t)=V(x_t,t,c^{\text{tar}},f^{\text{tar}})\), the edit trajectory is driven by the difference of the two:

\[dZ^{\text{edit}}_t=\mathbb{E}\left[V^{\text{tar}}_t(Z^{\text{tar}}_t)-V^{\text{src}}_t(Z^{\text{src}}_t)\right]dt,\quad Z^{\text{src}}_t=(1-t)x^{\text{src}}+tW_t,\quad Z^{\text{tar}}_t=Z^{\text{edit}}_t+Z^{\text{src}}_t-x^{\text{src}}\]

where \(W_t\sim\mathcal{N}(0,I)\). Note that only the velocity difference is propagated: whatever motion the source prompt already explains is subtracted, leaving only the motion the edit asks to add, while the target sample is a translation of the source sample so that no net noise appears along the trajectory. The trajectory is initialized at \(t=1\) to the source video itself (\(Z^{\text{edit}}_1=x^{\text{src}}\)) and integrated backwards, with \(t\) decreasing, down to \(t=0\).

All three edit types become the same thing in this framework: they only change the right-hand side of that single ODE, that is, how the edit velocity field is estimated. Content-side changes (inserting an object, replacing a material, restyling) travel through the edited first frame channel -- an image editing model (Gemini 2.5 Flash Image, referred to in the paper as Nano-Banana Pro) produces one edited first frame that serves as \(f^{\text{tar}}\), and the I2V model's first-frame conditioning injects the new content and carries it through the video; action and global dynamics changes travel through the target prompt plus starting from pure noise channel, where the target velocity field re-decides the coarse spatio-temporal structure; the strength of both is tuned by the same inference-time knobs (the SGA temperature \(\tau\) and the classifier-free guidance scales). The model internals are never touched -- no masks, no attention-map interventions, no inversion, no fine-tuning. That is precisely what "versatile without training" means. The overall flow is shown below.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["source video + source/target prompts<br/>optional edited first frame"] --> B["edit trajectory starting from pure noise<br/>integrate backwards from t=N"]
    B --> C["Similarity Guided Aggregation<br/>project candidates to t=0<br/>soft-select by similarity to source"]
    C --> D["Annealed Noise Correlation<br/>noise correlation grows as t decreases"]
    D -->|t != 0, next timestep| C
    D -->|t = 0| E["edited video"]

Key Designs

1. Edit trajectory starting from pure noise: without a free enough starting point, motion and interaction cannot move

The FlowEdit family has one switch, \(n_{\max}\), which sets the timestep at which the trajectory starts integrating backwards and therefore how much noise is added to the source video -- equivalently, the coarsest scale the edit can touch. Structure-preserving edits are fine with \(n_{\max}=N-1\) or lower, since they never intend to move the skeleton; but the edits this paper targets (a horse jumping an obstacle, a billiard ball dropping into a pocket, a train hitting a paint bucket) require rewriting coarse spatio-temporal structure, and as long as \(n_{\max}<N\) the target velocity field simply has no freedom to touch it. The paper lays out the dilemma with a side-by-side comparison: at \(n_{\max}=N-1\) the horse never jumps, while at \(n_{\max}=N\) the prompt is obeyed but two degradations appear at once -- low-frequency misalignment (the horse's trajectory needlessly departs from the source motion and the camera motion changes) and high-frequency jitter (the inserted obstacle smears into a blur).

The paper's choice is to set \(n_{\max}=N\) outright so that editing starts from pure noise, and to move content-side changes out of the noise amplitude and into the model conditioning: edits that need an inserted object or a new material first obtain an edited first frame from an image editing model and feed it as \(f^{\text{tar}}\), while edits that need no first-frame change simply reuse the source first frame. This works because I2V first-frame conditioning keeps anchoring the scene, object identity and color palette even when spatio-temporal alignment is completely lost -- coarse structure is handed to the target prompt while identity and context are pinned by the first frame, so the two demands no longer compete for the same \(n_{\max}\). The price is that the two side effects released by this step must be handled, and they are exactly what the next two designs target.

2. Similarity Guided Aggregation (SGA): letting the source video soft-select among candidate edit directions

Once \(n_{\max}=N\), the first problem appears in the very first step: at \(t_N\) both \(Z^{\text{src}}_{t_N}\) and \(Z^{\text{tar}}_{t_N}\) are pure noise (both equal \(W_{t_N}\)), so the initial velocity difference has lost all connection to the source video beyond the first-frame conditioning. A bucket-swapping experiment demonstrates the consequence: changing only the noise realization at the initial timestep while keeping the noise of all later timesteps identical yields videos with completely different camera motion, train speed and bucket-explosion timing -- the initial step alone effectively determines the coarse spatio-temporal features of the whole video. Given how much that initial noise matters, it should not be drawn at random; it should be chosen, out of several candidates, as the one least divergent from the source video.

SGA draws \(n^{\text{SGA}}_i\) noise samples at each edit step, obtaining candidate edit directions \(V^{\Delta}_1,\dots,V^{\Delta}_{n^{\text{SGA}}_i}\), then uses a straight-line extrapolation to predict "where would we land if we followed this direction all the way to \(t=0\)", and weights the candidates by how similar those landings are to the source video:

\[z^{\text{edit-proj}}_j=z^{\text{edit}}-t_iV^{\Delta}_j,\qquad s_j=\mathrm{softmax}_j\!\left(\cos(x^{\text{src}},z^{\text{edit-proj}}_j)/\tau\right),\qquad \bar{V}^{\Delta}=\Big(z^{\text{edit}}-\textstyle\sum_j s_j z^{\text{edit-proj}}_j\Big)\Big/t_i\]

That is, each candidate's projected end point is compared with the source video by cosine similarity, the similarities are normalized into weights by a softmax, the projections are combined by those weights, and the result is converted back into a single velocity. This differs fundamentally from FlowEdit's plain averaging of candidate velocities: naive averaging superimposes mutually contradictory directions (say a leftward and a rightward camera motion) into a blurry compromise -- the \(n_{\text{avg}}=100\) row in the paper is exactly that smear -- whereas SGA first judges, at the level of the end point, which route ends up looking most like the source video and then leans toward it, so what gets averaged away is noise rather than structure. The temperature \(\tau\) is the soft/hard knob: a very small \(\tau\) collapses the softmax into hard selection, keeping only the edit path best matching the source video and thus enforcing stronger alignment, while a large \(\tau\) flattens the weights and allows larger edits. Computationally there is no need to keep multiple candidates at every step -- coarse structure is settled within the first few steps -- so the paper uses \(n^{\text{SGA}}_i=5\) for the first three timesteps and falls back to 1 afterwards.

3. Annealed Noise Correlation (ANC): letting noise correlation grow as sampling proceeds

The second problem of starting from pure noise is high-frequency jitter. When the noise used at consecutive timesteps is mutually independent, the edit velocity computed at each step points in a different direction, and these random perturbations accumulate through the integration, showing up as fuzzy edges on inserted objects and as dissolving or flickering newly generated content such as paint splashes and flags. The paper verifies this hypothesis: sharing a single noise realization across all timesteps does remove the jitter, but low-frequency alignment gets worse instead (the inserted bucket levitates and interactions look unnatural). The reason ties directly back to design 2 -- SGA needs a set of mutually different noise samples to provide its candidates, and once the noise degenerates to a single realization that choice disappears. What is needed, then, is noise that is diverse early and consistent late, not a choice between the two extremes.

ANC realizes this with a noise state \(\tilde{w}_j\) maintained across timesteps: each step draws an i.i.d. batch \(w_j\) and updates the state by "keep the old value and inject new noise",

\[\tilde{w}_j\leftarrow\sqrt{a_{t_i}}\,\tilde{w}_j+\sqrt{1-a_{t_i}}\,w_j\]

where \(a_t\) is a schedule that increases monotonically as \(t\) decreases, with \(a_{t_N}=0\) and \(a_{t_1}=1\). The paper lets \(a_t\) rise linearly from 0, reaching 1 at \(t=0.25\) and staying there. Hence the early phase of sampling (\(t\) large, coarse structure undecided) uses fully independent noise and SGA has ample diversity to choose from; the late phase (\(t\) small, high-frequency detail being generated) pushes correlation toward 1, freezing the noise into a fixed realization so that the previously chosen edit direction is no longer perturbed and the jitter disappears. It hands "independent noise explores structure, fixed noise stabilizes detail" to the two phases of the same trajectory, instead of forcing a single choice for the whole run as prior work does.

A Worked Example

Take the "train passing through the forest -> train hitting a yellow paint bucket" example from the paper's Fig. 3. The source video supplies \(c^{\text{src}}\), the target prompt adds "hitting a yellow paint bucket"; because the inserted object changes the first frame, an image editing model first produces a first frame containing the bucket as \(f^{\text{tar}}\) (edits that leave the first frame alone simply reuse the source first frame). The trajectory starts at \(t_N=1\), where \(Z^{\text{src}}\) and \(Z^{\text{tar}}\) are both pure noise. Over the first three timesteps SGA draws 5 noise samples each, yielding 5 candidate edit directions; each is extrapolated in a straight line to \(t=0\) and compared with the source video by cosine similarity, then weighted with \(\tau\). A candidate whose extrapolation "pans the camera while the target prompt drags the scene away" scores low, whereas one whose extrapolation "keeps the camera motion and the train position essentially intact and merely adds the bucket" scores high, so the velocity difference is dominated by that route. Meanwhile ANC barely retains any history in this early phase (\(a_t\approx 0\)), which is what keeps those 5 candidates genuinely different from one another. After three timesteps \(n^{\text{SGA}}\) returns to 1 and multi-candidate selection stops, but ANC keeps accumulating correlation: by \(t=0.25\) the noise is fully frozen, so the bucket's contour and the paint droplets are generated from the same noise at every subsequent step and no longer flicker. With ANC switched off in favour of i.i.d. noise, the same candidate selection still happens, but the bucket and the paint smear into jittering color blobs.

Loss & Training

There is no loss function and no training in this paper -- no fine-tuning of the base model, no per-video test-time optimization, and no auxiliary network is trained. The entire "strategy" lives at inference time and consists of the following: the base model is WAN2.1 14B 480p I2V (qualitative results with Hunyuan 1.5 I2V are given in the appendix); the SGA candidate count is 5 for the first three timesteps and 1 afterwards (\(n^{\text{SGA}}_i=5,\ i>N-3\)); the ANC schedule \(a_t\) rises linearly from 0 to 1 and stays at 1 from \(t=0.25\) to \(t=0\); the source and target velocity fields each use classifier-free guidance (CFG), with the paper experimenting with the pairs \((4.5,8.5)\) and \((2.5,4.5)\); and the SGA temperature is either \(\tau=0.01\) or \(\tau=1\). Crossing these yields four configurations, all of which are evaluated quantitatively; in the user study the configuration is chosen per edit according to how large the modification is -- the higher CFG configuration for changes covering a larger part of the scene, and the higher \(\tau\) configuration for edits requiring stronger motion changes.

Key Experimental Results

Main Results

The evaluation set was curated by the authors: source videos selected from Pexels, paired with source prompts, target prompts and edited first frames, for a total of 71 tuples across four categories -- (a) insertion of objects requiring two-sided interaction with the original content, (b) swapping of objects with implications for the outcome of events, (c) modification of object motion and action, and (d) global spatio-temporal effects -- with at least 15 edits per category. Videos are 49-81 frames long at 832x480 and 16fps, matching what the WAN model expects. Baselines include the training-free FlowEdit, FlowAlign, ODE inversion, plain I2V sampling and SDEdit, plus the trained Runway Aleph; FlowDirector and DynVFX support only object swapping or insertion, so they are compared only on the relevant categories. All compared methods receive the same edited first frame.

Evaluation runs along two tracks: VLM scoring (Gemini 3 Pro rates adherence to the source video, adherence to the target text, and overall visual quality on a 1-5 scale; Qwen3-VL results are in the appendix) and a user study (32 participants, over 2,400 responses; each question shows a source video, an edit prompt and two results -- one of them DynaEdit's -- and asks which better preserves source content, better adheres to the target text, and has better visual quality). The table below summarizes both tracks; the VLM column is reported by the paper as a scatter plot, so the ordering stated in the paper's text is filled in.

Method Type VLM content preservation VLM text adherence VLM visual quality User study: preference for DynaEdit over it (visual quality / content preservation / text adherence)
DynaEdit (Ours) Training-free Best Comparable to Aleph Comparable to Aleph --
Runway Aleph (Gen-4) Trained Below Ours (smallest gap) Comparable to Ours Comparable to Ours 59.2% / 56.4% / 58.3%
FlowEdit Training-free Below Ours Below Ours Below Ours 79.9% / 80.2% / 77.2%
Plain I2V sampling Training-free Below Ours Below Ours Below Ours 77.7% / 82.1% / 73.4%
FlowAlign Training-free Below Ours Below Ours Below Ours Not in the user study
ODE inversion Training-free Below Ours Below Ours Below Ours Not in the user study
SDEdit Training-free Below Ours Below Ours Below Ours Not in the user study

Note: the three user-study columns are the share of responses in which DynaEdit was selected, read following the paper's Fig. 7(b) legend order (Vs. Aleph / Vs. I2V Sample / Vs. FlowEdit) against the column headers (visual quality / content preservation / text adherence); if the figure's layout differs from this reading, refer to the original paper. The VLM columns are given by the paper only as an ordering plus a scatter plot (with a per-category breakdown in the appendix) and no citable scores in the main text, so no numbers are filled in here. DynaEdit significantly outperforms the training-free baselines in all four edit categories and is typically at least comparable to the trained Aleph model.

Ablation Study

The component ablations in the paper are mainly qualitative, built on the failure analysis (quantitative ablations appear in the appendix, which is not part of this cache). The table below puts the practices that cause each problem side by side with the mechanism that fixes it, which amounts to a component-by-component ablation.

Config Phenomenon Note
FlowEdit, \(n_{\max}=N-1\) Horse fails to jump the obstacle The starting step is too conservative; coarse spatio-temporal structure has no freedom to change
FlowEdit, \(n_{\max}=N\) Prompt adherence improves, but trajectories/camera motion drift needlessly and the obstacle jitters The initial velocity difference is decoupled from the source video; uncorrelated noise across steps accumulates
FlowEdit, \(n_{\text{avg}}=100\) Blurry edits Candidate directions that contradict each other are simply averaged
Same noise across timesteps High-frequency jitter disappears, but low-frequency alignment worsens (the inserted bucket levitates) The noise degenerates to a single realization and SGA loses the diversity it selects from
Ours w/o SGA (FlowEdit averaging instead) The turtle's motion and the camera motion drift from the source Without similarity-based soft selection, aggregation degenerates to blind averaging
Ours w/o ANC (i.i.d. noise instead) High-frequency artifacts: jittery paint splashes, dissolving flag Directions disagree across consecutive timesteps and the perturbation accumulates through the integration
Ours (full) All three edit types work, with content preservation and text adherence simultaneously in play SGA supplies diversity in the first three timesteps; ANC freezes the direction afterwards

Key Findings

  • The two mechanisms address problems at two different levels, and neither suffices alone: SGA decides whether the low frequencies (camera motion, object trajectories, event timing) stay faithful to the source video, while ANC decides whether the high frequencies (texture and contours of newly generated objects) are stable. The qualitative ablations give evidence for each -- dropping SGA makes the turtle's motion and the camera motion drift, dropping ANC makes the paint and the flag jitter and dissolve.
  • The two are complementary in time: SGA needs several mutually independent noise samples to select from, while suppressing high-frequency jitter requires the noise to converge later. ANC's annealing schedule cuts this conflict along the time axis and only tightens correlation late, so it avoids the loss of low-frequency alignment that "one noise for all timesteps" suffers.
  • Freedom has to be granted before fidelity can be discussed: pushing \(n_{\max}\) from \(N-1\) to \(N\) is a precondition for this class of edits rather than a tunable detail, and without it the other mechanisms have nothing to work on.
  • Edited content is controlled through two channels at once, first-frame conditioning and text conditioning: insertion and material changes enter mainly through the edited first frame, while pure action and dynamics changes rely on the target prompt plus starting from pure noise. The paper also verifies that the exact phrasing of the prompts does not affect performance (appendix 3.7).
  • In cases that require rewriting a physical process -- "two strawberries falling into water, replace the right one with a feather" -- DynaEdit is the only compared method to produce a plausible result: the feather slowly descends, then floats on the water, while the left strawberry's dynamics remain untouched. Other methods either make the left strawberry disappear/fade (Aleph, FlowAlign) or change its velocity (FlowEdit, I2V sampling).

Highlights & Insights

  • Decoupling "how much can change" from the noise amplitude onto model conditioning: existing inversion-free methods let a single \(n_{\max}\) carry both "how coarse a feature may change" and "how faithful the result stays", which forces a compromise. This paper instead hands coarse structure to the target prompt and identity/scene to the edited first frame, giving each demand its own channel -- only then is it possible to change motion without losing identity.
  • Judging in the "end point" space rather than the velocity space: SGA's clever move is to turn each candidate direction into a hypothetical video via a one-step straight-line extrapolation, and then compare those hypothetical end points with the source video. Averaging in velocity space is a geometric compromise that blurs; comparing in end-point space is semantic. This is a way of pulling selection out of optimization, and it transfers to any training-free editing setting where several candidate guidance directions must be chosen among (image editing, 3D editing, and so on).
  • Using temporal noise correlation for frequency-band control: ANC reduces jitter to the lack of correlation between noises at consecutive timesteps, so a single scalar schedule \(a_t\) can allocate randomness across frequency levels -- loose early, tight late. This is orthogonal to the usual noise schedules in diffusion sampling and belongs to the general family of "giving randomness a temporal structure".
  • Failure analysis driving the design: instead of stacking modules, the paper first attributes each degradation using three controlled experiments (changing the initial noise, sharing noise across steps, raising \(n_{\text{avg}}\)) and then designs the compensations against those attributions. The style itself -- give reproducible evidence of failure first, then act -- is worth imitating.
  • Every mechanism acts only on how the velocity field is estimated and never touches model internals, so in principle the method transfers to other flow models (the appendix gives qualitative results with Hunyuan 1.5 I2V).

Limitations & Future Work

  • The authors acknowledge that the method inherits the capability ceiling of the base I2V model: when the model itself is weak on physics, the edit fails with it, and there is a tension between making very large spatio-temporal modifications and simultaneously preserving regions that should not be affected.
  • Content edits depend on an external image editing model (Gemini 2.5 Flash Image here), so the quality ceiling of content-type edits is set by that front-end module, and an error in the first frame is amplified across the whole video by the I2V model.
  • The evaluation set is 71 tuples hand-picked from Pexels by the authors, which is modest and skewed toward natural scenes; with at least 15 examples per category, per-subcategory conclusions rest on few samples. VLM scoring uses Gemini 3 Pro (Qwen3-VL in the appendix) and the user study has 32 participants and over 2,400 responses -- enough for relative ordering, but not an absolute performance scale.
  • Inference is expensive: the base model is a 14B I2V model, and the first three timesteps evaluate both source and target velocity fields for 5 noise samples each, roughly ten times the cost of a single edit path over those steps; together with the two CFG passes, the overall cost is clearly above plain sampling.
  • Directions for improvement: replace SGA's one-step straight-line extrapolation with a more accurate few-step extrapolation or a cheaper proxy criterion; make the ANC schedule \(a_t\) content-adaptive (for instance, deciding when to freeze based on the area of newly generated content); and jointly optimize first-frame editing and trajectory editing instead of decoupling them serially as is done now.
  • vs FlowEdit: FlowEdit introduced the inversion-free editing paradigm, constructing a noise-free trajectory from the difference between source and target velocities, controlling edit strength via \(n_{\max}\), and averaging over noise samples at each step. It excels at structure-preserving edits, but at \(n_{\max}=N\) both low-frequency misalignment and high-frequency jitter appear. This paper keeps its trajectory framework and replaces two things -- how directions are aggregated (averaging to similarity-based soft selection over end points) and how noise is drawn (i.i.d. to annealed correlation) -- which is what enables structurally unrestricted editing.
  • vs FlowAlign: FlowAlign is also inversion-free and improves edit quality through trajectory regularization, which is effective in the video domain as well. Its regularization acts on how well-behaved the trajectory is and still presupposes structural alignment; this paper explicitly drops that presupposition and recovers fidelity by selecting among candidate directions, so it is better suited to edits that rewrite motion, though not necessarily superior for purely structure-preserving edits.
  • vs FlowDirector / DynVFX: both use attention maps or masks to confine the edit to a designated region and support only object swapping or object insertion. Their insertion is one-sided -- the new object can be affected by the scene but cannot change how the scene unfolds. The two-sided interaction demonstrated here (an inserted obstacle making the horse jump, an inserted toy making the cat run off) is the direct answer to that limitation.
  • vs trained methods (Runway Gen-4 Aleph): Aleph is the only publicly available general-purpose instruction-based video editing model and the only compared method that can also change actions and dynamics, but it is closed-source and still fails on complex non-rigid edits. Without any training this paper narrows the gap substantially: better content preservation on the three VLM criteria with the other two comparable, and preferred in all three aspects in the user study (preference over Aleph sits at 56%-59%, the closest of the three rivals).
  • Transferable lesson: neither mechanism depends on a specific model; both act only on the edit velocity field as an intermediate quantity. Any training-free editing built on flow/diffusion models (images, video, 3D) that faces the same two problems -- several candidate guidance directions to choose among, and cross-step randomness causing artifacts -- can adopt SGA's "project to the end point, then compare similarity" and ANC's "correlation annealing" as they are.

Rating

  • Novelty: ⭐⭐⭐⭐ The first training-free method to push inversion-free editing into structurally unrestricted territory, with two mechanisms each matched to a clearly attributed failure mode; the problem statement and the solution are both clean. However, the trajectory framework itself is inherited from FlowEdit, making this a key-component swap on an existing paradigm.
  • Experimental Thoroughness: ⭐⭐⭐⭐ A self-curated 71-tuple, four-category evaluation set, VLM scoring plus a 32-participant user study, and a direct comparison against a trained model, with all four hyperparameter configurations evaluated; but the quantitative ablations sit in the appendix, the evaluation set and per-category samples are limited, and quantitative results across base models are missing.
  • Writing Quality: ⭐⭐⭐⭐ The failure-analysis chain (phenomenon -> attribution -> mechanism) is very clear, and three controlled experiments make the motivation credible; the price is a high density of symbols and equations in the Method, and figures 3 and 4 carry a lot of information.
  • Value: ⭐⭐⭐⭐ Training-free, never touching model internals, and matching a trained commercial model -- attractive for anyone who cannot afford to collect training data; the main constraints are the inference cost of a 14B base model and the dependence on a first-frame editing model.