MoviEdit is a research model that edits long, multi-shot video from a text instruction or a single edited frame and keeps the edit consistent across every cut. It comes from authors at Adobe and KAIST (arXiv 2611.02737), trained on 87,000 automatically built paired videos. The team says it beats existing open-source editors and performs on par with industry frontier models. It handles clips up to 25 seconds, even though training used 15-second videos.
The part you can use today is the benchmark, not the model. The MoviEdit-Bench repository is public. We found no model weights in the sources we read, so treat this as a research result to watch, not a tool to install.
TL;DR: MoviEdit at a glance
| Question | Answer (source) |
|---|---|
| What does it do? | Applies one edit consistently across all shots of a clip (project page) |
| Inputs? | Text instruction, one edited frame, several edited frames, or a set of short videos |
| Max length? | 25 seconds; trained on videos up to 15 seconds (GitHub README) |
| Training data? | 87K paired editing videos built without manual annotation (paper page) |
| Architecture? | A bidirectional Draft Editor, then a causal autoregressive Render Editor |
| Output resolution? | Draft at 270p and 12 fps, then final at 540p and 24 fps (project page) |
| What is public? | MoviEdit-Bench: data, evaluation code, VLM judge, reference results |
| Weights? | None found in the linked sources |
| Compared with? | Open-source editors (beaten) and proprietary systems (on par, per the authors) |
Why is multi-shot editing hard?
Most AI video editors work on one continuous shot. Real films have cuts. When the camera switches angle, the same actor looks different, the background changes, and lighting shifts. An edit like "remove the man in a black tactical suit," which is an example prompt on the project page, has to find that person in every shot, remove him cleanly and leave everything else untouched. If the model treats each shot alone, the replacement can look different from one shot to the next.
The abstract names the problem as keeping an edit coherent "across abrupt changes in scene, viewpoint, and subject appearance" while processing a much longer visual context than a single-shot editor. The authors split the work into three parts: data, modeling and evaluation.
How does MoviEdit work?
Data: 87K paired videos without labeling
Editing models need pairs: a source video and the same video with the edit applied. Humans cannot label that at scale, so the team built three annotation-free pipelines, per the GitHub README:
- Multi-camera footage. Synchronized views of the same scene supply pixel-aligned pairs, so cross-shot editing and within-shot temporal propagation can be separated.
- Cinematic clips. Real multi-shot videos supply the structure of real cuts.
- Generated multi-shot videos. A multi-shot video generator is coupled across two generations to make semi-pixel-aligned pairs.
Together they yield 87K paired editing videos. The authors do not say which pipeline contributed the most, and we did not read the full paper, so we cannot say how clean the pairs are.
Model: draft first, render second
The architecture is a cascaded bidirectional-autoregressive design. A lightweight Draft Editor, bidirectional, works on a subsampled version of the video and settles a globally consistent edit. Then a chunk-wise causal Render Editor propagates the edit at full resolution. Per the README, one shared denoiser does both jobs, and the causal second stage "prevents long-horizon appearance drift."
The project page presents this as a workflow: every edit renders twice. A low-resolution draft (270p, 12 fps) appears first so you can check the edit, and the full-resolution version (540p, 24 fps) follows as the deliverable. That is a practical design choice for editors who iterate, because a bad edit is caught early.
Ways to direct an edit
The project page shows five modes:
- Say it. Describe the edit in words and it applies across every shot.
- Show it. Edit one frame in any shot and the change propagates to the whole clip.
- Show it, many times. Edit several frames, even from different shots.
- Go long. Clips up to 25 seconds, single-take or multi-shot.
- Edit a set of videos. Apply one edit consistently across several short videos.
What is MoviEdit-Bench?
A filmstrip with one frame turning green, showing how an edit in one frame propagates in MoviEdit
The benchmark is the most reusable piece. According to the README, it contains 64 generated multi-shot source videos (4 to 6 shots, 361 frames at 24 fps, about 15 seconds) and 128 editing scenarios. Tasks include text-guided editing (V2V) and edited-frame-guided propagation (IV2V), with first-frame and non-first-frame references. Edits are local (add, remove, appearance change, swap) or global (environment change, stylization).
It scores seven dimensions: non-subject preservation, edit localization, subject preservation, cross-shot edit consistency, edit-prompt alignment, video quality, and edited-frame fidelity for IV2V, plus an aggregate Overall Edit Success score. The repo ships the evaluation code and a VLM judge in locked environments, MoviEdit's edited videos, and the paper's per-scenario results. You can also run the reference videos through the evaluator and compare against the paper, which is a good reproducibility check.
A caution: the benchmark's source videos are generated, not filmed. A model can do well on generated multi-shot clips and still struggle with messy real footage. The project page does show edits on real-world footage, but the quantitative benchmark covers generated sources. A VLM judge is also a model, so its scores carry their own bias.
How does it compare with other video tools?
The authors report that MoviEdit "substantially outperforms existing open-source models and performs on par with industry frontier models." We could not see the per-model tables, so we cannot name which proprietary systems were tested or by how much it ties. Treat the claim as the authors' own, on their own benchmark.
For context, other recent explainx.ai coverage shows how the video-AI space is splitting:
- Adobe's own EditAgent for images takes the agent route, calling specialized tools and checking its work, while MoviEdit trains an end-to-end video model.
- Kino lets coding agents edit a shared timeline, an approach that cuts and arranges footage rather than re-rendering pixels.
- Lemo builds short films with a Claude Code skill and no video model at all.
- Runway's GWM Worlds 2 goes toward interactive world models, and a speculative sampling paper for interactive video targets generation speed.
MoviEdit's niche is different from all of these: pixel-level re-rendering of existing footage, across cuts, with a consistent edit.
How to use MoviEdit-Bench on your own editor
Even without the model, the benchmark gives a practical test plan. The README describes a flow in three steps, and we paraphrase it here rather than quoting commands, because we have not run it ourselves.
- Get the data. Download the 64 source videos, the 128 edit scenarios, the edit instructions and the edited reference frames.
- Run your model. Produce one edited video per scenario. For the IV2V tasks, feed in the edited reference frames, including the non-first-frame cases, which are the hardest because the model must work backwards and forwards from a middle shot.
- Score it. Use the shipped metric code and VLM judge in the locked environments, then compare your per-dimension scores with the reference results.
Before you trust your own numbers, run the reference videos through the evaluator and confirm you reproduce the paper's scores. That check tells you the environment is set up correctly. Then look at the dimensions separately. A model with a high video-quality score but a low cross-shot consistency score is making pretty frames that do not agree with each other, which is exactly the failure this benchmark was built to expose.
Limitations and open questions
- No weights. The Hugging Face page lists zero models, datasets and Spaces citing the paper. The README describes a public benchmark release only.
- License. The repo points to a LICENSE.md file, and we did not read its terms. Check it before reusing benchmark data.
- Short clips. 25 seconds is a long edit for a research model, but far short of a scene or a film.
- Resolution. The final output is 540p. Production use needs more.
- Self-reported comparison. The "on par with frontier models" claim is not independently tested.
- Safety and consent. Consistent object and person replacement in video is also what makes convincing fakes. Look for provenance labels whenever edited footage is shared.
- Early traction. The GitHub repo had 4 stars and 14 commits, and the paper page showed 28 upvotes and a #2 paper of the day rank when we checked.
What to do with this
If you build video tools, MoviEdit-Bench is worth running against your own editor, because cross-shot consistency is rarely measured. If you edit video, watch for an Adobe product integration, though neither the paper nor the repo announces one. If you only want to try an edit today, there is nothing to download yet.
Questions worth asking of any video-editing model: Does the edit survive a cut? Does it leave untouched regions alone? Can you preview cheaply before the full render? MoviEdit's benchmark metrics map directly onto those three questions.
Details are accurate as of November 4, 2026. This summarizes a preprint abstract, a project page and a repository README.
Related reading
- Adobe EditAgent: an image-editing agent that checks its work
- Kino: AI video editor for coding agents
- Lemo: short films with a Claude Code skill
- Runway GWM Worlds 2
- Speculative sampling for interactive video generation
- RoboColosseum robot evaluation
- Official: paper page, project page, MoviEdit-Bench on GitHub