Source-linked AI summary
EditThinker: Unlocking Iterative Reasoning for Any Image Editor
Hongyu Li, Manyuan Zhang, Dian Zheng, Ziyu Guo, Yimeng Jia, Kaituo Feng, Hao Yu, Yexin Liu, Yan Feng, Peng Pei, Xunliang Cai, Linjiang Huang, Hongsheng Li, Si Liu
TL;DR
Instruction-based image editors achieve strong visual quality but remain limited in precise single-turn instruction following. EditThinker adds an MLLM-driven Think-while-Edit loop that critiques results, refines instructions, and repeats generation, with RL aligning its reasoning to editing outcomes. Across four benchmarks and multiple editors, the framework substantially improves instruction following without requiring editor fine-tuning.
Problem
Single-turn image editors cannot deliberate or self-correct effectively, limiting instruction following despite strong aesthetic quality.
Method
EditThinker is a reasoning-capable MLLM that iteratively critiques edits, refines instructions, and repeats generation, with RL aligning its reasoning to editing outcomes.
Results
Across four benchmarks, EditThinker significantly improves instruction following across diverse editing models and scenarios.
Takeaways & Limitations
The Think-while-Edit paradigm improves instruction following for different image editors without requiring their fine-tuning.
Abstract
from arXiv · showhide
Instruction-based image editing has emerged as a prominent research area, which, benefiting from image generation foundation models, have achieved high aesthetic quality, making instruction-following capability the primary challenge. Existing approaches improve instruction adherence via supervised or reinforcement learning, yet single-turn success rates remain limited due to inherent stochasticity and a lack of deliberation. In this work, we propose a deliberative editing framework to 'think' while they edit, which simulates the human cognitive loop by iteratively executing a Think-while-Edit cycle: Critiquing results and Refining instructions , followed by Repeating the generation until satisfactory. Specifically, we train a single MLLM, EditThinker, to act as the reasoning engine of this framework, which jointly produce the critique score, reasoning process, and refined instructions. We employ reinforcement learning to align the EditThinker's thinking with its editing, thereby generating more targeted instruction improvements. Extensive experiments on four benchmarks demonstrate that our approach significantly improves the instruction-following capability of any image editing model by a large margin. We will release our data construction framework, datasets, and models to benefit the community.
1. Introduction
Instruction-based image editing now produces aesthetically strong results, but precise instruction following remains limited because single-turn systems cannot self-correct. EditThinker addresses this gap with iterative critique, instruction refinement, and regeneration, improving diverse editors without fine-tuning them.
- Motivation: Single-turn editors struggle because they must understand instructions, plan visually, and generate content in one pass without self-correction.This can cause missing attributes and leaves current systems reactive rather than reflective.
- Approach: EditThinker equips any image editor with an MLLM that critiques results, refines instructions, and repeatedly regenerates until the editing goal is achieved.The approach is framed as a Think-while-Edit paradigm rather than modifying the editor itself.
- Results: GPT-4.1-driven iterative instruction refinement significantly improves Qwen-Image-Edit, Flux-Kontext, and Omnigen2 without fine-tuning the editing models.The framework is evaluated across several state-of-the-art editors and diverse editing scenarios.
- Approach: The method trains one MLLM to jointly produce critique scores, refined instructions, and reasoning, using SFT and RL to align planning with editor capabilities and failure modes.The training includes THINKEDIT-140k, a multi-round dataset with unified supervision for refinement and reasoning.
- Contributions: The work contributes a Think-while-Edit formulation, EditThinker, THINKEDIT-140k, and extensive evaluations across four benchmarks.The experiments also study reasoning turns, training strategy, the thinking paradigm, and expert-model choice.
2. Related Work
Prior image-editing methods improved precision or flexibility but faced computational, semantic, or feedback limitations. EditThinker responds by using structured MLLM reasoning to guide editing during execution rather than relying only on post-hoc evaluation.
- Image Editing: Image editing must modify attributes while preserving backgrounds, creating stricter constraints than text-to-image synthesis.Earlier inversion-based and spatial-control methods improved precision but could incur computational overhead or reduce semantic flexibility.
- Reward Models: MLLM-based reward models provide evaluations for generative tasks, but scalar or dense feedback can miss fine-grained image-editing nuances.The passage identifies translating holistic judgments into effective editing-training signals as non-trivial.
- Reward Models: Post-hoc rewards evaluate edited images after generation, whereas complex multi-step editing requires feedback that can correct intermediate reasoning.The paper therefore shifts toward using MLLMs as internal planners that guide editing during execution.
3. Think-while-Edit
Think-while-Edit turns single-pass image editing into an iterative Critique-Refine-Repeat process, using EditThinker to evaluate results, refine instructions, and guide any editor. Reinforcement learning grounds this reasoning in actual editing outcomes.
- 3.1. Overall Framework: The framework replaces single-turn editing with iterative critique, instruction refinement, and regeneration until the editing goal is achieved.A Thinker judges and reasons while an Editor executes each refined instruction.
- 3.2. Design of the EditThinker: At each iteration, EditThinker jointly produces an instruction-following score, refined instruction, and reasoning process from the source image, current result, and prior instruction.The Editor then applies the refined instruction to generate the updated result.
- 3.2. Design of the EditThinker: EditThinker performs evaluation and planning in one forward pass, explicitly generating reasoning before the refined instruction to ground planning in visual critique.This dual-role design combines the critic and refiner rather than using separate models.
- 3.3. Training: SFT teaches the structured output format and basic reasoning, while RL optimizes refinement using feedback from actual editor executions.The training strategy addresses the gap between ideal reasoning and the practical limitations of real editors.
- 3.3.2. Reinforcement Learning Tuning (RLT): The RL edit reward is positive only when a refined instruction produces a better image than the previous step, directly grounding planning in execution results.The critic reward separately penalizes disagreement between predicted and expert-assessed quality.
4. THINKEDIT Dataset
THINKEDIT-140k is built through automated multi-round editing trajectories that are filtered, converted into step-wise supervision, balanced, and partitioned for SFT and RL. The resulting datasets separate stable refinement examples from high-variance improvement trajectories.
- 4. THINKEDIT Dataset: The dataset pipeline uses trajectory generation, trajectory filtering, step-wise filtering, and data partitioning to construct THINKEDIT-140k.These stages simulate the Think-while-Edit cycle and prepare data for both training phases.
- Trajectory Generation: GPT-4.1 iteratively evaluates editing states, generates refined instructions and reasoning, and stops each trajectory with a ⟨stop⟩ token or iteration limit.The expert does not output scores during generation; it directly decides when to halt.
- Trajectory Filter: An edit scorer retains trajectories whose later step matches or exceeds the initial score and truncates each retained trajectory at its highest-scoring step.Trajectories failing the improvement criterion are discarded.
- Step-wise Filter: Each retained trajectory is unrolled into samples pairing the editing state and prior instruction with ground-truth reasoning and refined instruction, then balanced across task types and score levels.This creates step-wise supervision while preserving score metadata for filtering.
- Data Partition: The RL split contains 10k high-variance trajectories yielding 27k step-wise samples, while the SFT split uses low-variance or consistently high-quality refinement examples and totals 140k samples.RL emphasizes dynamic improvement; SFT emphasizes stable, reliable refinement behavior.
5. Experiments
Across four benchmarks, Think-while-Edit consistently improves diverse image editors, with gains from iterative reasoning, reinforcement learning, and stronger expert models.
- 5.2. Main Results: FLUX.1-Kontext [Dev] improves from 3.44 to 3.98 on ImgEdit-Bench and from 6.18 to 7.05 on GEdit-Bench-EN with EditThinker.OmniGen2 and Qwen-Image-Edit also improve on both general-editing benchmarks.
- 5.2. Main Results: FLUX.1-Kontext [Dev] rises from 5.8 to 14.4 on RISE-Bench, while OmniGen2 rises from 3.1 to 3.4 and Qwen-Image-Edit from 8.9 to 17.8.RISE-Bench tests complex spatial, causal, and temporal reasoning.
- Think Pattern Analysis: Think while Edit outperforms Think before Edit, while initializing the iterative framework with Think before Edit lowers performance from 7.19 to 7.06.The authors hypothesize that the initial step biases first-round reasoning and causes incomplete information transfer.
- Effectiveness of Thinking Rounds: The GEdit-Bench-EN G O score increases from 6.18 at one turn to 6.95 at two turns and peaks at 7.30 at eight turns.Intermediate scores are 7.13 at four turns and 7.16 at six turns.
- Training Stage: SFT raises the G O score from 6.18 to 6.93, while subsequent RL increases ImgEdit-Bench Overall from 3.57 to 3.95.The reported results associate SFT with foundational refinement capabilities and RL with optimizing judgment and decision-making.
- Expert Model: Replacing EditThinker-8B with GPT-4.1 raises the FLUX baseline from 6.00 to 7.19 G O, showing performance scales with expert capability.The expert-model comparison supports the framework’s scalability beyond the trained expert.
6. Conclusion
EditThinker reframes image editing as deliberative, iterative reasoning: it critiques results, refines instructions, and repeats generation to improve instruction following.
- EditThinker iteratively critiques edited results, refines instructions, and repeats generation until satisfactory outcomes are achieved.
- A single MLLM jointly produces critique scores, reasoning processes, and refined instructions, with reinforcement learning aligning its reasoning to editing outcomes.
A. Kris-Bench Result
On Kris-Bench, EditThinker consistently improves reasoning-driven editing performance across the evaluated editors.
- Overall Score rises from 61.81 to 69.53 for FLUX.1 Kontext [Dev], 50.52 to 53.09 for OmniGen2, and 64.43 to 71.91 for Qwen.These gains are reported on the reasoning-centric Kris-Bench editing task.
B. More Ablation Analysis
The ablation analysis describes EditThinker’s iterative reasoning setup, multimodal editing-state inputs, structured outputs, and multi-round behavior.
- Multi-round Reasoning for EditThinker: EditThinker’s performance rises from 6.18 at baseline to 7.03 by Turn 8, with the largest boost occurring at Turn 2, from 6.18 to 6.90.The multi-round evaluation reports continuous improvement across turns.
- B. More Ablation Analysis: GPT-4 supervises reasoning traces and refined instructions through a Critique–Revise cycle that evaluates fulfillment, diagnoses failures, and synthesizes corrections.The expert process uses a maximum of N = 5 editing iterations.
- C.2. Details of EditThinker: A unified prompt format keeps training and inference behavior aligned for evaluating results, reasoning about issues, and refining instructions.
- C.2. Details of EditThinker: At each iteration, EditThinker receives the source image, original instruction, previous edited result, and instruction that produced it.The process allows the model to evaluate the complete current editing state before refining the next instruction.
- C.2. Details of EditThinker: The model outputs an instruction-following score, reasoning trace, and refined instruction, using continuous semantic and quality scores instead of a binary stop flag.Continuous scoring supplies smoother supervision for nuanced failure patterns and more precise control.
D. Details of ThinkEdit-140K Dataset
ThinkEdit-140K combines 140K editing instances from three data sources and uses GPT-4.1 with three editors to construct training trajectories.
- The dataset contains 140K raw samples drawn from OpenGPT-4o-Image, ShareGPT-4o-Image, and Pico-Banana-400K.The sources contribute 40K, 40K, and 60K samples respectively, with editing categories sampled as evenly as possible.
- GPT-4.1 serves as the EditThinker-Expert, while OmniGen2, FLUX.1 Kontext [Dev], and Qwen-Image-Edit serve as editors.The samples are divided into three splits before trajectory filtering.
E. Visualization
The visualizations show EditThinker producing high-quality edits across multiple editors and iteratively improving instructions by critiquing intermediate results. Prompt and expert-instruction visualizations specify evaluation, reasoning, and refinement outputs at each iteration.
- EditThinker produces high-quality edits with FLUX.1 Kontext [Dev], OmniGen2, and Qwen-Image-Edit.
- The iterative visualizations show the Thinker evaluating intermediate outputs, identifying issues, and refining instructions over multiple rounds.
- At each iteration, the Expert observes the source image, previous edit, source instruction, and prior instruction before producing a stop flag, reasoning, and refined instruction.
- The displayed prompts require scoring edited images, assessing instruction fulfillment, and rewriting prompts when shortcomings remain.
- The unified Thinker prompt similarly produces semantic and quality scores, reasoning, and a refined instruction from the current editing context.