EditThinker: Unlocking Iterative Reasoning for Any Image Editor

TL;DR

EditThinker is an 8B multimodal LLM (Qwen3-VL-8B-Instruct base) that wraps any instruction-based image editor — Flux-Kontext, OmniGen2, Qwen-Image-Edit — in a Critique-Refine-Repeat loop: it scores the current edit, emits a refined instruction grounded in a written reasoning trace, and resubmits to the editor until satisfied. Trained with two-stage SFT (140k stable trajectories) + GRPO (10k high-variance trajectories) where the RL reward couples a critic term (alignment of EditThinker’s predicted scores with GPT-4.1’s evaluations of the resulting image) and a differential edit term (improvement of after-state over before-state per the same expert). On four editing benchmarks (ImgEdit-Bench, GEdit-Bench-EN, RISE-Bench, KRIS-Bench) it lifts Flux-Kontext, OmniGen2, and Qwen-Image-Edit by large margins — especially on reasoning-heavy edits (Flux-Kontext-Dev RISE-Bench Overall 5.8 → 14.4) — without touching the editor itself.

Key claims

Single-turn instruction-following is the dominant bottleneck for current SOTA editors; the editor is a “reactive executor” rather than a “reflective thinker,” and even RL-tuned editors fail because instruction understanding, visual planning, and content generation are coupled into one pass with no opportunity for intermediate self-correction [§1].
A frozen-editor multi-round refinement loop using GPT-4.1 as the Thinker already lifts performance across Qwen-Image-Edit, Flux-Kontext, and OmniGen2 without any fine-tuning of the editor — establishing the upper bound that EditThinker-8B then chases [§1, §5.2 +EditThinker-Expert-GPT4.1 rows of Table 1, Table 2].
EditThinker is a dual-role MLLM trained in a single forward pass to emit a structured trace <think>…</think><score>[s_iq, s_ic]</score><answer>refined prompt</answer>, where producing the critique before the refined prompt grounds instruction refinement in the visual evaluation [§3.2].
ThinkEdit-140k is constructed by an automated four-stage pipeline (Trajectory Generation with GPT-4.1 + STOP token, Trajectory Filter, Step-wise Filter, Data Partition) over an Edit Data Pool, with the score-aware Trajectory Filter discarding trajectories that never improved over step 1 and truncating retained ones at their best step [§4.1-4.4].
The SFT vs RL data split is principled by intra-trajectory score variance: 10k high-variance trajectories (≈27k step-wise samples) provide the rich reward signal for RL; 140k low-variance / consistently-high-quality steps provide stable supervised refinement examples for SFT cold-start [§4.4].
The RL reward is a sum of three terms with α + β = 1: a critic reward penalizing |GPT-4.1-score − predicted-score| for both perceptual quality s_iq and instruction-following s_ic, an edit reward that is positive only when the refined instruction T_t produces an image strictly better than I_{t-1} per GPT-4.1, and a basic format-reasoning reward [§3.3.2 Eqs. 3–5].
The edit reward is differential — R_e = E(I_t) − E(I_{t-1}) — so the policy is rewarded only for measurable improvement per step, not for absolute quality, directly grounding planning in the editor’s practical failure modes [§3.3.2 Eq. 4].
Multi-round reasoning monotonically improves outcomes up to at least 8 turns on Flux-Kontext + GEdit-Bench-EN (G_O 6.18 baseline → 6.95 at 2 turns → 7.13 at 4 → 7.16 at 6 → 7.30 at 8), evidence the framework genuinely uses added rounds [Table 4].
“Think while Edit” outperforms “Think before Edit,” and combining them regresses (G_O 7.19 → 7.06) — the authors hypothesize that the initial single-shot rewrite introduces a bias in the first-round reasoning that propagates downstream [§5.3 Table 3].
Framework gains scale with Thinker capability: on ImgEdit-Bench Flux-Kontext-Dev rises 3.52 → 3.98 with EditThinker-8B and to 4.13 with GPT-4.1-as-Thinker; pattern repeats on GEdit-Bench-EN and RISE-Bench [§5.2 Table 1, Table 2].

Method

EditThinker decouples the editing workflow into a Thinker (the trained MLLM, on which SFT+RL is performed) and an Editor (any frozen image editor — Qwen-Image-Edit, Flux-Kontext, OmniGen2 in their experiments). At iteration t the Thinker receives the multimodal tuple (I_src, T_s, I_{t-1}, T_{t-1}) and emits a structured trace (score [s_iq, s_ic], reasoning R_t, refined instruction T_t). The Editor then executes T_t on I_src to produce I_t. The loop repeats until <STOP> or a max-iteration cap.

Training is two-stage. SFT cold-start on the 140k step-wise samples teaches the structured I/O format and the GPT-4.1 reasoning style. GRPO on 10k high-variance trajectories (≈27k step samples) then bridges the gap between ideal reasoning and the practical failure modes of real editors. The reward is R = R_format + α·R_critic + β·R_edit with α + β = 1; the critic term aligns EditThinker’s predicted scores with GPT-4.1 evaluations of I_t for both perceptual quality and instruction-following, and the edit term gives positive signal only when T_t yields an image GPT-4.1 prefers over I_{t-1}.

ThinkEdit-140k construction starts from a pool of (I_src, T_s) pairs. GPT-4.1 runs the Critique-Refine-Repeat loop without producing scores — it only decides when to <STOP>. An edit-scorer is then applied post-hoc to every step. Trajectory Filter: keep trajectories where some later step exceeds the step-1 score, then truncate at the highest-scoring step. Step-wise Filter: unroll into step-wise samples, balance across task types (object removal, color modification, adding items, etc.) and across score levels. SFT/RL split: high intra-trajectory variance → RL (10k); low variance / consistent high quality → SFT (140k).

The base MLLM is Qwen3-VL-8B-Instruct. Hyperparameters: SFT LR 1e-5, batch size 32, 1 epoch; RL LR 1e-6, global batch 128, rollout N=8, KL coefficient 1e-3, MAX_PIXELS 1024×1024. Training: 8 H800 GPUs × ~48 hours total.

Results

General editing — ImgEdit-Bench Overall (with EditThinker-8B vs base): Flux-Kontext-Dev 3.52 → 3.98; OmniGen2 3.44 → 3.52; Qwen-Image-Edit 4.36 → 4.40. Self-reported baselines (3.44 / 3.41 / 4.36) used; with GPT-4.1 expert as Thinker, the same models reach 4.13 / 3.81 / 4.49 [Table 1].
General editing — GEdit-Bench-EN G_O: Flux-Kontext-Dev 6.18 → 7.02; OmniGen2 6.03 → 6.28; Qwen-Image-Edit 7.49 → 7.73. With GPT-4.1 expert: 7.19 / 6.78 / 7.90 [Table 1].
Reasoning editing — RISE-Bench Overall (more striking lift): Flux-Kontext-Dev 5.8 → 14.4 with EditThinker-8B (20.6 with GPT-4.1 expert); OmniGen2 3.1 → 3.4 (9.2 with expert); Qwen-Image-Edit 8.9 → 17.8 (27.5 with expert) [Table 2]. Qwen-Image-Edit + EditThinker-8B at 17.8 surpasses the BAGEL (w/ CoT) reference (11.9) and approaches GPT-Image-1 (28.9) [Table 2 Open-source rows vs Proprietary].
Turn-count scaling on Flux-Kontext-Dev + GEdit-Bench-EN G_O: 1 (baseline) → 2 → 4 → 6 → 8 = 6.18 → 6.95 → 7.13 → 7.16 → 7.30 — monotone over the tested range [Table 4].
Think pattern ablation (Flux-Kontext-Dev on GEdit-Bench-EN G_O): Think before Edit 6.82; Think while Edit 7.19; Think before + while Edit 7.06 — combining them is worse than Think while Edit alone [Table 3].

Why it’s interesting

EditThinker is the cleanest filed example of the Reasoning RL recipe ported to image editing: the same GRPO + multi-component shaped-reward pattern (critic + differential edit + format) that the concept page already tracks for tool-use (Close the Loop: Synthesizing Infinite Tool-Use Data via Multi-Agent Role-Playing), VLM perception (Video-Thinker: Sparking "Thinking with Videos" via Reinforcement Learning, vlm-gym: RL gym for vision language models (JAX)), and video diffusion policies (Human detectors are surprisingly powerful reward models), now applied to a Thinker that orchestrates a separate frozen generator. The “differential edit reward” — positive only when the refined instruction produces a strict improvement per GPT-4.1 — is the same primitive HuDA uses with worst-window detector confidence, but here the reward expert is itself an LLM, which makes the recipe transferable to any task with an LLM-judgeable success criterion.

The Think-while-Edit pattern is also the natural editing analogue of the Thinking with Modalities axis: where Video-Thinker invokes tagged perception inside its own CoT and DiffThinker uses the diffusion trajectory itself as the reasoning substrate, EditThinker keeps the reasoning text-token but invokes a separate pixel-space generator as an external action in a Critique-Refine-Repeat loop — closer in spirit to Gemini 3 Flash Agentic Vision’s Think-Act-Observe loop than to either pure-text CoT or to in-substrate visual reasoning. The ablation showing Think-before + Think-while is worse than Think-while alone (G_O 7.06 vs 7.19) is a useful negative result: pre-committing to an initial rewrite biases the first-round critique. That falsifies the obvious “more thinking is always better” intuition.

For VLM-as-Evaluator, the framework is a sibling to EditReward: A Human-Aligned Reward Model for Instruction-Guided Image Editing (EditReward — human-aligned scalar reward for edit quality) but with two differences: (a) the VLM judge here is internal to the policy being trained (EditThinker is both judge and refiner in a single forward pass), and (b) the supervision signal for that judge is a stronger external VLM (GPT-4.1) rather than human preferences. The “evaluation then planning” justification — that effective planning requires deep evaluation, so produce the critique before the refined instruction — is a structural claim that complements the static-rubric / dynamic-rubric split the concept page already tracks. And the variance-aware SFT/RL data split — 140k low-variance trajectories for SFT, 10k high-variance for RL — is a concrete recipe for the broader Synthetic Training Data thesis that what you train each stage on matters as much as the gate.