Multi-turn image editing aims to modify an image according to a sequence of instructions, making it better aligned with human-AI collaborative creation than single-turn editing. However, constructing high-quality multi-turn training data remains challenging, as conventional sequential rollout accumulates errors and introduces visual-quality drift across editing turns. To address this challenge, we introduce MTEdit, a multi-turn image editing dataset built through a pipeline centered on packed trajectory canvas (PTC) generation. By jointly generating multiple editing states within a unified visual context, this pipeline reduces visual-quality drift across turns. Covering both step-wise and context-aware editing scenarios, MTEdit comprises 500K multi-turn image editing trajectories, with up to 8 turns and an average of 5.38 turns per trajectory, making it one of the most extensive datasets for multi-turn image editing. We further introduce MTEdit-Bench, a benchmark designed to evaluate both scenarios by assessing models' ability to follow editing instructions, maintain content consistency, resist visual-quality drift, and effectively use historical context across turns. Using MTEdit, we fine-tune Qwen-Image-Edit-Causal to obtain Qwen-Image-MTEdit. On MTEdit-Bench, we evaluate a broad range of closed-source and open-source image editing models, including Qwen-Image-MTEdit. Experimental results show that Qwen-Image-MTEdit achieves the best performance among the evaluated open-source models, demonstrating the effectiveness of MTEdit in improving models' multi-turn image editing capabilities.
Sam: Repeated image edits can quietly damage parts of the picture you never asked to change. This study finds that generating editing stages together produces cleaner training examples and helps an editor stay consistent.
Alex: So the intervention is in the training data, rather than just asking the editor to be more careful?
Sam: Yes. It’s a method paper and dataset release described in an arXiv preprint by Houyuan Chen, Fanzhou Wang, and colleagues, called MTEdit. They tackle multi-turn image editing: changing a picture through successive user instructions.
Alex: That matters for anyone building an editor people can revise, rather than use once. A successful change now is less useful if it damages the starting point for the next request.
Sam: And it matters for researchers generating synthetic training data. We’ll unpack the shared-generation idea, the comparison that tests it, and why longer editing sessions remain an open question.
Alex: Start with the existing approach. How does making training examples introduce the same problem the editor is supposed to avoid?
Sam: The common approach is sequential rollout. A powerful image editor makes a change, then its output becomes the input for the next change. Any unintended artifact can become part of the next starting image, so errors accumulate.
Alex: That sounds like a supervision problem as well as a generation problem. The training sequence can contain deterioration alongside the intended edits.
Sam: That is the concern behind this work. The authors describe declining visual quality and drifting content over successive turns. Earlier datasets also tend to have shorter sequences or cover only one kind of editing interaction.
Alex: What are the different interactions? Remembering the current picture sounds different from remembering what the user said earlier.
Sam: The authors make that distinction. Step-wise editing uses the previous image and the current instruction. Context-aware editing also uses earlier instructions and image states, including rules that should persist or references whose meaning comes from earlier requests.
Alex: So “make it longer” requires remembering what “it” refers to. And a material rule established earlier might still apply even when the latest request doesn’t repeat it.
Sam: The benchmark includes both. One example establishes shiny silver as a requirement for later changes, then asks for additions without repeating the material. Another progressively lengthens flower stems through increasingly brief requests.
Alex: How do the authors create cleaner sequences without abandoning the idea of cumulative edits?
Sam: They use what they call a packed trajectory canvas: one generated grid containing several cumulative editing states. Instead of making those states separately, a generator creates them together within a shared visual context.
Alex: Give me a sequence I can picture. What does the generator have to keep straight?
Sam: Take their ceramic plate example. First, increase the painted pinecones. Then change the plate’s lettering to “COZY WINTER.” After that, give the background wall a rough texture, and finally add a silver ring to the holder’s thumb.
Alex: The final image needs all those changes, not just the ring. Generating the states together gives the model a shared reference for the plate, the hand, and the scene.
Sam: The authors argue that shared context reduces visual drift. Their default grid holds four cumulative states. To extend a sequence, they use the last state as the source for another generation round.
Alex: Joint generation could also mix things up. How do they turn that grid into trustworthy training examples?
Sam: They first curate high-resolution source images with high aesthetic ratings. A vision-language model, which processes pictures and text, plans the edits. A closed-source image model generates the grid, and another checking stage rejects failed generations.
Alex: And the instructions need to match what actually appeared, not just what the planning model hoped would appear.
Sam: They derive the turn-level instructions from the retained images and source image. Then they separate the editing states and use feature matching and image warping to improve alignment. The resulting dataset contains half a million editing trajectories, covering both interaction types.
Alex: Scale is useful, but it doesn’t establish that joint generation is better. What is the cleanest comparison?
Sam: The controlled ablation is the strongest evidence for that specific claim. Each approach generates ten thousand training sequences using identical source images and per-turn requests. The authors then train the same base editor with matched training settings and budgets.
Alex: So that comparison changes how the training images are constructed, rather than comparing unrelated editors. What happens late in the sequence?
Sam: At the eighth edit, the jointly generated training data gives a Drift Robustness Score of about 4.2. Sequentially generated training data gives about 4.0. Higher means better visual quality under this measure.
Alex: Those scores are close. What is the measure, and does the advantage appear anywhere besides that final reading?
Sam: It averages two automated image-quality measures chosen for sensitivity to deterioration during repeated image generation. In the matched comparison, joint generation also improves instruction following after the initial edit and content consistency throughout. The authors show cleaner fine details in a qualitative example, too.
Alex: That supports a useful effect in this setup. How does the full trained model compare with the other available editors?
Sam: Their fine-tuned model, Qwen-Image-MTEdit, performs best among the evaluated open-source models on their benchmark. In step-wise editing, it improves over its base model across all reported metrics and turns. But the strongest closed-source models still lead it in instruction following and content preservation.
Alex: A benchmark can strongly influence that ranking. How demanding is this one, and how are failures counted?
Sam: Its step-wise test contains a hundred long editing sequences. Separate context-aware tests cover persistent rules, references, and short requests. Automated judges score instruction following and content consistency, while the image-quality measures track visual drift.
Alex: If an editor loses the scene halfway through, do later successful-looking changes still earn credit?
Sam: Not for instruction following or consistency. Once either score falls below the failure threshold, subsequent scores for both are set to zero. Image quality keeps its actual score, so a clean-looking but incorrect continuation does not erase the earlier failure.
Alex: Then late scores reflect surviving the whole chain, not just executing the latest request. Do those automated judgments resemble human assessments?
Sam: The authors compare model rankings from human evaluations with benchmark rankings and report strong positive agreement across the tasks. That supports relative model comparisons. It does not make the benchmark exhaustive, especially with its modest test set.
Alex: What limitation most changes how someone should use this method?
Sam: Don’t treat it as a solution to arbitrarily long editing sessions. The authors explicitly warn that substantially longer sequences may still drift. The pipeline also depends on closed-source generators, and interference between jointly generated states requires filtering.
Alex: So who should read the full document, and where would you send them first?
Sam: If you construct image-editing training data, start with the data-construction section and the matched comparison against sequential rollout. Those explain the intervention and its strongest test. If you design evaluations, read the benchmark’s failure rule and its comparison with human rankings.
Alex: And what should everyone else carry away?
Sam: An editor’s stability depends partly on how its training sequences were made. Generating editing stages together can reduce the deterioration that sequential generation passes along—but this study has not shown that the advantage lasts indefinitely.
Alex: Thanks for listening.