EditThinker: Unlocking Iterative Reasoning for Any Image Editor

TL;DR

The paper tackles the challenge of instruction-following in image editing by introducing Think-while-Edit, a deliberative framework where a single EditThinker multimodal model critiques outputs, refines instructions, and repeats edits with editors. EditThinker is trained in two stages (SFT and RL) and paired with the ThinkEdit-140k dataset to ground multi-turn planning in real editing feedback. Across four benchmarks and multiple editors, the approach yields consistent, substantial improvements in both general editing and reasoning-intensive tasks, and its benefits scale with the expert Thinker quality. The work demonstrates the value of internal planning and iterative refinement for image editing and provides datasets and models to support future research in deliberative multimodal reasoning for vision-language tasks.

Abstract

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.

Figures (7)

• Figure 1: Overview of EditThinker. Subfigure (a) illustrates our multi-turn Think-while-Edit pipeline that iteratively Critiques, Refines, and Repeats the editing instruction, while subfigure (b) reports results on four image editing benchmarks, showing large gains for three existing editing methods and we use the dev version of FLUX.1 Kontext (denoted as FLUX.1 Kontext in the figure).
• Figure 2: The Pipeline of Think-while-Edit. EditThinker is a multi-round instruction iterative refinement framework. In the first round, the original image $I_{src}$ and instruction $T_s$ are fed into an editor to produce an initial edited image $I_{edit}^t$. This edited image, along with the original image and instruction, is then fed into EditThinker, which generates the edit score $S_t$, refined prompt $T_t$, and corresponding reasoning process $R_t$. If the score falls below a threshold, the framework proceeds to the next iteration with the refined prompt until a satisfactory result is achieved.
• Figure 3: Data construction pipeline of our ThinkEdit. We construct our dataset through four sequential steps: (1) Trajectory Generation: We use several image edit models and expert evaluator GPT-4.1 to iteratively edit image, evaluate it and generates refined instructions until issuing a $\langle\text{stop}\rangle$ token. (2) Trajectory Filter: An edit scorer assigns scores $S_t$ to each step, retaining only trajectories where $\max(S_{t>1}) \ge S_1$ and truncating them at the highest-scoring step $k$. (3) Step-wise Filter: We unroll trajectories into individual training samples pairing inputs ($I_{src}$, $I_{edit}^{t-1}$, $T_s$, $T_{t-1}$) with outputs ($R_t, T_t$), then balance the dataset across task types and score distributions. (4) Data Partition: The filtered data is split for SFT and RL training.
• Figure 4: Qualitative visualizations of EditThinker paired with different editors. Subfigures (a) and (b) show results with FLUX.1 Kontext [Dev], (c) and (d) use OmniGen2, and (e) and (f) use Qwen-Image-Edit.
• Figure 5: Visualization of EditThinker’s reasoning traces and intermediate editing results when paired with FLUX.1 Kontext [Dev]. The figure illustrates how the Thinker evaluates the current output, identifies issues, and iteratively refines the instruction over multiple rounds.