- Rating
- 2
- Confidence
- 4
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 1
Read review
Paper summary
The paper introduces FeedEdit, a feedback driven prompt refinement framework for instruction guided image editing. Instead of explicitly generating an eval of intermediate editing results at inference time, it learns when to stop and how to refine prompts using evaluator feedback during training, combining offline learning from causal feedback with online self distillation from hindsight feedback.
Critical strengths
- The paper is easy to follow and code release statement is available.
- The paper reports some gains of Flux-Klein-9B with FeedEdit on two image editing benchmarks over some existing prompt refinement frameworks.
Critical weaknesses
- I find novelty to be limited as compared to a closely related prior work: How to Train Your Advisor: Steering Black Box LLMs with Advisor Models (Asawa et al., 2026, ICML 2026). The core idea of FeedEdit appears closely related to this paper. Both methods train a separate policy to generate instance specific textual guidance for a frozen downstream model, use feedback from the downstream model's outputs to improve this policy and support iterative refinement and transfer across downstream models. Importantly, Advisor Models already considers settings where the advisor observes an initial model output before suggesting corrections, making the conceptual overlap particularly relevant. While FeedEdit introduces a different training strategy based on offline supervision and online self distillation, along with an explicit stopping mechanism for image editing, the paper does not sufficiently distinguish these contributions from the broader framework established by Advisor Models. The absence of a discussion or comparison with this closely related work makes it difficult to assess the methodological novelty of FeedEdit. A clearer comparison is needed to establish whether the proposed approach offers substantive advantages beyond adapting an existing feedback driven guidance framework to image editing. Perhaps using a similar setting to that of Advisor Model and adapting that as-is to the Image Editing use case could have given similar improvements. So, it's unclear since we do not see such comparison baselines.
- The proposed framework depends heavily on evaluator generated scores and textual feedback during both offline trajectory construction and online self distillation. These signals determine which refinement trajectories are retained, when the model should stop and how the policy is updated. However, the paper does not sufficiently investigate how inaccurate or inconsistent evaluator feedback affects the learned refinement behavior. This is particularly concerning because one of the main motivations is to avoid unreliable intermediate evaluations at inference time, while the training process still relies extensively on such judgments. Also, even though the authors emphasize inference efficiency by eliminating explicit evaluation generation, they do not provide a comprehensive comparison of actual inference latency, average editor calls or computational costs. As a consequence, the robustness of the learned policy and the practical efficiency advantages of the proposed framework remain insufficiently established. Finally, the authors used just one model Flux Klein 9B to report results and effectiveness of the approach which by itself is insufficient (see my question below for further details on this).
Questions for authors
- The improvement from the causal feedback SFT checkpoint to the full FeedEdit model is relatively small, increasing from 4.51 to 4.54 on ImgEdit-Bench and from 8.09 to 8.13 on GEdit-Bench. Could the authors provide statistical significance analysis to establish whether these improvements are consistent?
- As pointed out in the weaknesses, since both offline trajectory construction and online self distillation depend on evaluator generated scores and textual feedback, how sensitive is FeedEdit to inaccurate or inconsistent evaluator judgments? Could the authors evaluate the method using a different evaluator or controlled perturbations of the feedback to demonstrate robustness?
- The reported efficiency analysis mainly considers prompt length and whether evaluation text is generated. Could the authors provide actual inference latency, average number of editor calls and total computational cost per sample compared with EditThinker and other iterative refinement baselines?
- The idea of prompt rewriting or refinement makes more sense when the editing model is black-box. The authors used just one model variant Flux Klein 9B in this case. I feel the base model could have been updated since weights are open so the utility of the approach is not established well. How about black-box models like gpt-image-2, nanobanana where prompt refinement actually makes sense since we can't access their weights? Also, how does this approach works with smaller variants like Flux Klein 4B where editing performance can actually be improved with such prompt refinement strategies?
- The offline stopping targets are constructed using a fixed threshold on the sum of instruction compliance and content preservation scores. How sensitive is the learned stopping behavior to this threshold? Particularly, could the authors clarify whether the policy sometimes stops prematurely on edits that still contain significant instruction violations?
- FeedEdit achieves 4.09 on FLUX.1 Kontext dev compared with 4.08 for EditThinker. Given the very small difference, a more detailed analysis of cross editor transfer, including whether the improvement is consistent across editing categories is needed.
- In the main figure 1, I am not sure if the bird's fur color is changed to light brown from red, it seems yellow to me. Moreover, in Figure 3, first row, there's no reason to think that Qwen3-VL-8B Instruct output is bad, the instruction was to "Change the garden environment in the picture to a snowy landscape." and the foreground can very well change as well. Nothing in the prompt specified anything particular to the background and so background preservation may not be required on this example. Was there any human study conducted?
7 comments
Response (2/5): W2 + Q2 (Reliance on Evaluator Feedback and Robustness), Q5 (Stopping Threshold)
W2 (first part) + Q2. Training relies on evaluator feedback; sensitivity to inaccurate or inconsistent judgments
Training feedback is verified by executing every candidate; the online gain survives a different training evaluator, and a blind human study prefers FeedEdit.
Is training-time reliance inconsistent with our motivation? We believe not, because evaluation plays fundamentally different roles at inference and in training:
- At inference, an evaluate-then-refine policy acts on a single self-generated critique: one erroneous judgment directly misdirects the next edit, with no verification mechanism.
- In training, feedback is aggregated over many samples and is never trusted blindly. In offline construction, every candidate refinement is actually executed and is retained only if the total score improves by at least 2 points with no dimension decreasing, which filters out noisy scores and unhelpful critiques via observed outcomes. In online self-distillation, the feedback describes the outcome of an action that was actually executed rather than an unverified guess about the next edit.
Decoupling also lets us employ a stronger dedicated evaluator in training without incurring its latency or failure modes at deployment. Our training does not require every individual judgment to be accurate.
Robustness evidence:
- Alternative evaluator. (a) Replacing GPT-5.6-Luna with Qwen3-VL-235B as the online-training evaluator changes final scores by +0.001 (ImgEdit) and −0.026 (GEdit-EN), so the online stage still improves over the SFT checkpoint. (b) Re-scoring all five methods on the same editor (editor only, Qwen3-VL-8B, EditThinker, FeedEdit-SFT, and FeedEdit) with Qwen3-VL-235B as the benchmark judge yields rankings closely aligned with the official judges (Kendall's = 1.0, 95% CI [0.6, 1.0] on ImgEdit; = 0.8, 95% CI [0.4, 1.0] on GEdit-EN), with FeedEdit ranking first on both benchmarks under either judge.
- Controlled feedback perturbation. Swapping 50% of the hindsight textual feedback and scores with those of other samples during online training lowers GEdit-EN by 0.035, with ImgEdit at +0.001, so corrupted feedback does make the policy worse. Stopping behavior shifts less (ImgEdit / GEdit-EN): the stop rate by +0.0 / −2.2 pp, and the over-optimization rate (already satisfactory edits that the policy still refines) by +1.2 / +0.2 pp. This is consistent with noisy feedback primarily affecting the direction of prompt rewriting rather than the decision to continue or stop.
- Human validation. In a blind study of 600 pairwise comparisons, human annotators significantly prefer FeedEdit over all three baselines (Table 3), indicating that the gains are not an artifact of evaluator-specific preferences.
Q5. Sensitivity to the stopping threshold; does the policy stop prematurely?
With our threshold, premature stops occur on 11.8% of clearly failed first edits, against 27.5% and 76.5% with lower thresholds.
Threshold sensitivity. We trained FeedEdit-SFT with stop pairs constructed at lower thresholds and evaluated them on the ImgEdit subset where the first edit clearly failed (Turn-1 score < 3, n = 102):
| Stop threshold | Premature stops on failed first edits | Score change on these samples |
|---|---|---|
| S > 8 (ours) | 11.8% | — |
| S > 7 | 27.5% | −0.48 |
| S > 5 | 76.5% | −1.35 |
Lower thresholds teach the policy to terminate on edits with clear instruction violations, degrading final quality accordingly. With S > 8, premature stops occur on only 11.8% of failed first edits (vs. 27.5% at S > 7 and 76.5% at S > 5).
Why S > 8? With integer scores in 1–5, S = C + P > 8 requires both dimensions to be at least 4 and at least one to be 5; indeed, 70% of our stop targets (18,182 of 25,967) are perfect (5, 5) states. The only stricter choice is to require (5, 5) exclusively, so S > 8 enforces high quality while retaining enough stop pairs to balance the refinement pairs during training.
Stopping quality on benchmarks. Evaluated by the official benchmark judges (Tables 12–13 in the appendix), the edits on which FeedEdit chooses to stop are sharply separated in quality from those it chooses to refine, more so than for EditThinker on both benchmarks:
| Turn-1 score | Stop subset | Continue subset | FeedEdit gap | EditThinker gap |
|---|---|---|---|---|
| ImgEdit (/5) | 4.72 | 3.35 | +1.37 | +0.78 |
| GEdit-EN (/10) | 8.28 | 6.78 | +1.50 | +0.97 |
Response (3/5): W2 + Q3 (Latency, Editor Calls, Cost), Q1 (Statistical Significance)
W2 (second part) + Q3. Actual inference latency, editor calls, and computational cost
Versus EditThinker, FeedEdit generates 87–91% fewer tokens and is 1.8× / 4.3× faster end to end (ImgEdit / GEdit-EN), at higher quality.
We now report all three quantities (Table 2). Each cell: average editor calls / total generated tokens over all iterations / estimated latency (s), all with the FLUX.2-klein-9B editor. Bold marks the lower value between EditThinker and FeedEdit.
| Method | ImgEdit | GEdit-EN |
|---|---|---|
| Editor only | 1.00 / 0 / 1.79 | 1.00 / 0 / 0.46 |
| Qwen3-VL-8B-Instruct (untrained) | 1.26 / 25 / 2.69 | 1.78 / 48 / 1.26 |
| EditThinker | 1.57 / 363 / 5.64 | 1.89 / 437 / 3.97 |
| FeedEdit | 1.78 / 46 / 3.85 | 1.66 / 40 / 1.14 |
- Editor calls. FeedEdit averages fewer than two editor calls (1.78 / 1.66), well below the budget of 5. This is because FeedEdit can recognize when an edited result already satisfies the editing requirements.
- Generated tokens and computational cost. FeedEdit produces 87.3% / 90.8% fewer tokens than EditThinker, since it decodes no evaluation or reasoning text. This cuts the refiner's autoregressive decoding by roughly 8× / 11× relative to EditThinker.
- Latency. Estimated latency is 31.7% / 71.3% lower than EditThinker's.
- Wall-clock validation. Direct end-to-end latency measurements on 30 samples per benchmark show the same ordering, with an even larger gap: on ImgEdit, FeedEdit takes 5.33 ± 4.44 s vs. 9.44 ± 4.43 s for EditThinker (43.5% lower, 1.8× faster); on GEdit-EN, 1.14 ± 0.77 s vs. 4.88 ± 2.76 s (76.6% lower, 4.3× faster).
Estimates are for a single H800 GPU, obtained from each method's measured prefill time with its own prompts and images, a decoding speed of about 148 tokens/s, the time of one editor call, and per-sample call and token counts. FeedEdit therefore achieves higher quality than EditThinker (4.54 vs. 4.50; 8.13 vs. 8.07) at substantially lower cost. We have added these results to the main text (Table 2, Section 4.2), with details in Appendix A.5.
Q1. Statistical significance of the SFT → full FeedEdit improvement
Over three seeds, the gain is significant against both SFT () and matched-budget GRPO ().
We repeated the online stage with two additional seeds (three in total) for both FeedEdit and GRPO under the same setting. P-values are from per-setting paired permutation tests, combined with Stouffer's method (Table 11):
| Mean difference over 3 seeds | Klein / ImgEdit | Klein / GEdit-EN | Kontext / ImgEdit | Combined | Standardized [95% CI] |
|---|---|---|---|---|---|
| FeedEdit − FeedEdit-SFT | +0.015 | +0.047 | +0.044 | 0.021 | +0.030 SD [+0.004, +0.056] |
| FeedEdit − GRPO (matched budget) | +0.013 | +0.036 | +0.041 | 0.007 | +0.026 SD [+0.007, +0.045] |
Standardized is each setting's gain divided by the per-sample score SD, averaged over the three settings; its 95% CI is from 10,000 bootstrap resamples of the test items (the two ImgEdit settings resampled jointly).
On average over three seeds, FeedEdit outperforms both the SFT checkpoint and matched-budget GRPO across all three evaluation settings (combined and , respectively).
Interpreting the magnitude. The online stage starts from an already strong SFT policy on benchmarks with limited headroom: on ImgEdit, 55% of samples already receive the maximum score with the editor-only baseline (ceiling effect), and the offline SFT stage has already captured a large portion of the available room for improvement. Within the remaining headroom, online training adds no inference cost, requires no new large-scale offline trajectory construction, and under the same training budget achieves a significantly larger improvement than scalar-reward GRPO. We now report the multi-seed results (Appendix A.6, Table 11) and characterize the gain as modest in absolute magnitude yet statistically significant (Section 4.2).
Response (1/5): W1 (Relation to Advisor Models)
We thank the reviewer for the detailed review and for pointing us to Advisor Models. We now cite it in the related work (Section 5) and discuss it in Appendix A.4. Table, section, and appendix numbers refer to the revised PDF.
W1. Novelty relative to Advisor Models
FeedEdit shares the frozen-model steering setup but differs in decoupling, training signal, and learned stopping; Advisor Models adapted to our task is significantly below FeedEdit in all four variants.
What is shared. We agree that both works train a separate textual policy that steers a frozen downstream model, including settings where the policy observes an existing output before suggesting a correction. We do not claim this paradigm as our contribution; within image editing it is already instantiated by iterative refiners such as EditThinker.
What is different. While FeedEdit shares this setup, it differs from Advisor Models in three concrete ways:
Direct comparison: Advisor Models on our task. As suggested, we adapted Advisor Models (3-step) to image editing, with the same FLUX.2-klein-9B editor, test sets, and judges as our controlled comparison.
Adapting Advisor Models to image editing therefore does not yield similar improvements. Unlike an LLM that can flexibly interpret high-level textual hints, an image editor is conditioned directly on the exact wording of the prompt, making imprecise or over-specified advice prone to degrading the edited results.
In summary, FeedEdit shares the frozen-model steering setup with Advisor Models but contributes evaluation–refinement decoupling and a different learning mechanism, and the comparison above shows that these differences, rather than the shared setup, account for the gains. This discussion and the comparison are now in Appendix A.4 (Table 9).