acceptodds
Under review as a conference paper at ICLR 2027

Test-Time Scaling for Reliable Image Editing via Contract-Guided Verification

Abstract

Test-time scaling has substantially improved instruction-guided image editing by generating and comparing multiple candidate edits. However, ranking candidates by a unified evaluation score may cause highly ranked outputs to omit requested changes or alter content that should remain unchanged. In this work, we propose Contract-Guided Test-Time Scaling (CG-TTS), a training-free approach that uses explicit edit requirements to guide generation, verification, and repair with in place image-editing models. Specifically, for each instruction requirement, CG-TTS first constructs a contract specifying the editing target, requested changes, allowed regions, and preserved content, together with checks used to verify the given requirements. Then, we generate diverse candidate edits using a frozen editor equipped with a source-memory routing mechanism, which routes cached source-image features according to the contract. A staged verifier is further used to check spatial changes and operation-specific requirements, accepting candidates only when all active mandatory checks pass. If no candidates pass the verifier, CG-TTS uses verifier feedback to obtain diagnosis types that guide failure-conditioned repair, and the repaired candidates are verified against the same contract. Finally, CG-TTS selects the highest-ranked passing candidate as the output, while if none passes, any permitted fallback retains a non-pass status. Experimental results demonstrate that our method consistently improves performance across strong baseline models and outperforms state-of-the-art methods under the same computational budget. Code is available at https://anonymous.4open.science/r/s-E968.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
Image Editing, Test-Time Scaling, Verifier-Guided Generation

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_8deLOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The paper proposes Contract-Guided Test-Time Scaling (CG-TTS), a training-free pipeline for instruction-guided image editing.

  • Contract construction. GPT-4o, LISA, and Grounding DINO build an explicit "edit contract" containing the target, requested change, allowed and protected regions, and mandatory checks.
  • Candidate generation. A frozen inpainting editor (BrushNet or SDXL-Inpainting) generates four candidates, with Source-Memory Routing (SMR) reusing cached source features.
  • Verification. A staged verifier accepts a candidate only if all mandatory spatial and semantic checks pass.
  • Repair. If no candidate passes, failure diagnosis (e.g., under-edit or over-edit) guides one repair round of four more candidates, so each input uses at most 8 editor calls.

On ReasonEdit and HumanEdit-core, CG-TTS improves background PSNR (e.g., 25.4→38.0 dB on ReasonEdit-U with BrushNet) and MLLM-judged instruction compliance over the base editors and over scalar Best-of-8 selection from the same candidate pool.

Critical strengths
  1. Explicit verification instead of a single scalar score. Replacing a scalar ranking score with requirement-level PASS/FAIL/UNCERTAIN checks is a sensible way to avoid candidates that look good overall but omit a requested change or alter protected content. Under the same candidate pool, it outperforms CLIP, VIEScore, and EditScore Best-of-8 selection (Tables 1-2).
  2. Budget-aware repair. Repair is triggered only on failure (32/131 ReasonEdit-U examples), giving 4.98 average editor calls, 37.8% fewer than uniform Best-of-8.
Critical weaknesses

W1. The method is a composition of existing components, and the framing as "test-time scaling" is not well justified.

  • Unclear "scaling". For editing, more computation does not by itself yield more reliable results, just as more NFE does not. Here, the gains come mainly from external tools: GPT-4o contracts, LISA and Grounding DINO masks, and an MLLM-assisted verifier. The extra editor calls themselves contribute comparatively little. The paper does not show a scaling behavior, i.e., performance that keeps improving with the budget, that would justify the TTS framing.
  • Limited novelty of components. Reusing cached source features of a frozen editor, as in SMR, is common in training-free editing (e.g., attention/feature injection in Prompt-to-Prompt, MasaCtrl, and inversion-based editors). It is not clear that this warrants "we introduce."
  • Overall assessment. The work reads as a compositional inference pipeline rather than a new method.
  • Fragile spatial contract. The spatial contract depends entirely on LISA and Grounding DINO, both 2024 models with known localization errors and biases. The paper does not analyze what happens when they mislocalize or miss the target, nor how often this occurs. Such errors propagate to every downstream stage, since the same contract is used for generation, verification, and repair.
  • Failure diagnosis assumes a single failure type. Each candidate is assigned one diagnosed failure type (Eq. 7). Real failures often co-occur, e.g., over-edit together with semantic mismatch, and some instructions are hard for the editor to realize at all, such as tail-distribution concepts. The paper does not explain how such cases are handled.
  • No measure of realism after repair. The paper does not examine whether repaired candidates, with changed masks, strengths, or prompts, drift away from the natural image manifold. The reported metrics do not capture realism.

W2. The evaluation does not adequately support the claimed reliability.

  • Pixel metrics favor no-op edits.
    • Preservation is measured with PSNR, SSIM, and LPIPS. With mask-based inpainting editors, these metrics mostly reward leaving pixels unchanged outside the mask, and a minimal or near-no-op edit can score highly.
    • The large PSNR gain (25.4→38.0 dB) therefore mainly reflects the masking design rather than edit quality.
  • No human evaluation. Instruction compliance is judged only by MLLMs (GPT-5, Gemini 2.5 Pro, and Qwen3-VL-Plus), and no human evaluation is reported. This is a notable omission for a paper whose central claim is reliability.
  • Missing frontier editors. There are no comparisons with modern editors such as Qwen-Image-Edit or FLUX.1 Kontext, which the paper itself mentions in the related work. The base editors (BrushNet and SDXL-Inpainting) are relatively old inpainting models.
  • Unequal budgets. The benchmark baselines use published results (Sec. 4) and receive no test-time scaling. CG-TTS uses up to 8 editor calls plus GPT-4o, LISA, Grounding DINO, and MLLM verification. Moreover, the "same editor-call budget" counts only editor calls.
Questions for authors
  1. How does CG-TTS behave when LISA or Grounding DINO mislocalizes the target? How often does this happen on ReasonEdit, and what fraction of the remaining failures does it explain?
  2. How are candidates with multiple co-occurring failure types diagnosed and repaired?
  3. Can you report a human evaluation of instruction compliance and realism, and a comparison against frontier editors (e.g., Qwen-Image-Edit, FLUX.1 Kontext) given the same total compute, including the MLLM and grounding calls?
6 comments

Response to Reviewer 8deL (Part 1):

Thank you for your careful review and for recognizing the value of requirement-level verification and budget-aware repair. We also appreciate your suggestions to clarify the methodological contribution and scaling behavior, and to strengthen the failure analysis and evaluation. We provide the corresponding clarifications, analyses, and additional experimental results below. All revisions and additions to the main text are highlighted in red in the revised manuscript for ease of review.

W1.1: Unclear "scaling".

A1: Thank you for requesting clearer evidence of test-time scaling. CG-TTS scales test-time computation through candidate exploration and verification-guided repair, using verification feedback to determine whether additional generation is needed and how the generation configuration should be updated. The contract and acceptance criteria remain fixed.

Specifically, Figure 3 and Section 4.3 compare budget settings using the same editor and auxiliary components. With four initial candidates, allowing one conditional repair round increases the maximum editor-call budget from 4 to 8 and average usage from 4 to 4.98 on ReasonEdit-U. CLIPSim improves from 20.737 to 24.075, and PSNR from 37.587 to 37.964 dB. This comparison quantifies the incremental benefit of additional inference after the external tools are already in place.

W1.2–W1.3: Methodological novelty

A2: Thank you for asking us to clarify the methodological contribution. CG-TTS introduces a contract-defined inference policy: an explicit semantic–spatial contract specifies admissible information reuse, candidate acceptance, and failure-conditioned generation. The contributions are:

  • Contract-conditioned SMR. SMR builds on attention and feature reuse explored in Prompt-to-Prompt [1], MasaCtrl [2], and PnP [3]. Its contribution is using the editing operation and spatial contract to determine admissible memory sources, update regions, and reinforcement or suppression terms. For replacement, SMR can combine target-positive routing with suppression of source-exclusive features; protected-region features remain available as memory but receive no updates (Table 8). Removing SMR reduces CLIPSim from 24.075 to 22.118 and PSNR from 37.964 to 35.004 dB, quantifying its contribution within CG-TTS (Table 4).

  • Contract-defined acceptance and repair. The contract establishes explicit dependencies between generation constraints, acceptance decisions, and subsequent interventions. The same contract requires every mandatory check to pass before soft ranking. For example, a failed target-presence check cannot be compensated by a high preservation score. If no candidate passes, diagnosed failures guide repair while the original acceptance conditions remain fixed. With the same candidate pool, this acceptance policy reduces constraint violations from 49.6% to 21.4% (Table 2).

We make these methodological distinctions explicit in the contribution statement and Sections 3.3–3.4.

References:

[1] Amir Hertz, Ron Mokady, Jay Tenenbaum, Kfir Aberman, Yael Pritch, and Daniel Cohen-Or. Prompt-to-Prompt Image Editing with Cross-Attention Control. International Conference on Learning Representations (ICLR), 2023.

[2] Mingdeng Cao, Xintao Wang, Zhongang Qi, Ying Shan, Xiaohu Qie, and Yinqiang Zheng. MasaCtrl: Tuning-Free Mutual Self-Attention Control for Consistent Image Synthesis and Editing. Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), 2023, pp. 22560–22570.

[3] Narek Tumanyan, Michal Geyer, Shai Bagon, and Tali Dekel. Plug-and-Play Diffusion Features for Text-Driven Image-to-Image Translation. Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2023, pp. 1921–1930.

Response to Reviewer 8deL (Part 2):

W1.5, Q2: Co-occurring failures

A4: Thank you for asking how Eq. (7) handles co-occurring failures. CG-TTS handles such cases by prioritizing one failure for repair while retaining all mandatory verification requirements. If a candidate remains unsuccessful after exhausting the repair budget, any fallback retains its non-PASS status. The single label ϕj\phi_j in Eq. (7) identifies only the failure prioritized for the next repair action; other co-occurring failures are not discarded and remain subject to the original mandatory checks.

  • Multiple failures. CG-TTS determines the primary failure condition based on the results of individual checks: explicit failures of operation-critical checks are prioritized, followed by target-realization failures, while other failures are ranked according to their severity. The selected repair updates its generation configuration, while all original requirements remain active. The resulting candidate is then evaluated against the unchanged contract. For example, when over-editing and semantic mismatch occur simultaneously, even if repair improves preservation in the protected region, the candidate is still rejected as long as the semantic requirement remains unsatisfied.

  • Long-tail concepts. Repair provides a bounded search for a candidate satisfying the contract, using the same frozen editor. If the budget is exhausted without an all-PASS candidate, any fallback retains its non-PASS status; the acceptance criteria remain unchanged.

We clarify the distinction between repair selection and joint verification in Section 3.4 (line 277).

W1.6: Realism after repair

A1.6: Thank you for this helpful suggestion. Our additional qualitative comparisons demonstrate that repair can improve target realization and visual details, enhance photographic realism, and maintain the visual consistency of the original scene. Specifically, we have extended our evaluation beyond preservation metrics by adding human assessments of both photographic realism and instruction compliance, together with qualitative before-and-after comparisons of representative repair results.

The individual human assessment scores are reported in Section 4.1 (Tables 1 and 3), and the corresponding qualitative comparisons are provided in Appendix B.2 (Fig. 5). For example, in the sunglasses replacement case, the initial candidate exhibits excessive facial smoothing and an altered head pose. After repair, the sunglasses frames become clearer and the facial details more natural, while the subject's original pose and appearance are largely preserved. Similarly, the clothing and mask replacement cases show improved realization of the requested edits, while the wolf replacement case demonstrates better target realization while largely preserving the right cat and the surrounding scene.

W2.1: Preservation metrics and edit quality

A2.1: Thank you for your comments regarding the evaluation of editing quality. Our evaluation jointly considers content preservation and editing effectiveness through complementary metrics and controlled comparisons. Specifically:

  • Complementary evaluation. We separately assess non-target content preservation and editing effectiveness. Following SmartEdit [1], we use PSNR, SSIM, and LPIPS to measure non-target content preservation. The PSNR improvement from 25.393 to 37.964 dB reflects this aspect. Editing effectiveness is evaluated separately through instruction–crop alignment (CLIPSim), independent MLLM-based IC assessments, and the newly added human evaluation.

  • Evaluation masks and edit validity. Preservation alone is insufficient for candidate acceptance; candidates must also satisfy the required editing operations. For CG-TTS, benchmark-provided GT masks are used only for post-hoc metric computation; inference uses LISA-predicted masks. Candidate acceptance additionally requires actual image changes, sufficient change coverage, and satisfaction of operation-specific semantic requirements.

  • Controlled comparisons. Under shared localization and candidate-generation conditions, contract-guided selection provides additional gains in both CLIPSim and instruction compliance. Table 1 compares CG-TTS with CLIP Best-of-8 using the same localization and candidate pool. On ReasonEdit-U, CLIPSim improves from 21.594 to 24.075, while GPT-5/Gemini IC improves from 0.744/0.669 to 0.794/0.694.

Reference:

[1] Huang, Y., et al. SmartEdit: Exploring Complex Instruction-based Image Editing with Multimodal Large Language Models. CVPR, 2024.

Response to Reviewer 8deL (Part 3):

W2.2: Human evaluation.

A2.2: Thank you for highlighting the importance of human evaluation. Our human evaluation shows that CG-TTS (BrushNet) achieves the highest human composite scores on ReasonEdit, while the SDXL Inpainting variant scores highest on HumanEdit-core (Table R4). These assessments provide an independent human perspective on editing quality, complementing our MLLM-based evaluation. Specifically, we conducted human assessments on 25 Understanding and 25 Reasoning tasks from ReasonEdit, and 50 eligible tasks from HumanEdit-core. For ReasonEdit, we sampled five tasks from each of its five editing categories in the Understanding subset, and randomly sampled 25 tasks from the Reasoning subset. For HumanEdit-core, we used stratified sampling approximately proportional to the distribution of editing types. The evaluation involved 12 human raters, with each output independently assessed by two different raters. Each rater scored instruction compliance and photographic realism, and the normalized scores were averaged across the two dimensions to obtain the composite Human score. The normalized composite scores are reported in Table R4.

On ReasonEdit, CG-TTS (BrushNet) achieves 0.857/0.877 (U/R), compared with 0.623/0.510 for VIEScore Best-of-8, the strongest scalar-based selection baseline in this human evaluation. On HumanEdit-core, CG-TTS (SDXL Inpainting) achieves 0.813, compared with 0.711 for ADE-CoT and 0.682 for the SDXLInpainting baseline.

The resulting Human scores are reported in the last columns of Table 1 and Table 3. The corresponding experimental analysis is presented in Section 4.1 (lines 365 and 376), while the evaluation metrics and score computation are detailed in Section 4 (line 296) of the revised manuscript.

Table R4: Results with human evaluation.

MethodHumanEdit-core Human ↑ReasonEdit (U/R) Human ↑
InstructPix2Pix0.3890.437/0.369
MGIE0.2840.304/0.386
HIVE0.4390.358/0.443
MagicBrush0.4950.250/0.487
Qwen-Image-Edit0.7320.450/0.630
FLUX.1 Kontext-dev0.7180.473/0.677
SmartFreeEdit0.4780.303/0.503
BrushNet0.4970.533/0.493
SDXL Inpainting0.6820.457/0.543
ADE-CoT0.7110.667/0.713
ELECT0.5040.400/0.437
CLIP Best-of-80.4510.587/0.483
VIEScore Best-of-80.4190.623/0.510
EditScore Best-of-80.4090.587/0.470
CG-TTS (BrushNet)0.5520.857/0.877
Gain vs. BrushNet+0.055+0.323/+0.383
CG-TTS (SDXL Inpainting)0.8130.659/0.583
Gain vs. SDXL Inpainting+0.131+0.203/+0.040

W2.3: Frontier editors

A2.3: Thank you for this helpful suggestion. On ReasonEdit, CG-TTS (BrushNet) achieves higher instruction-compliance scores than the two frontier editors. On HumanEdit-core, CG-TTS (SDXL Inpainting) achieves a higher human composite score and better image-fidelity metrics. As requested, we have expanded our comparisons to include Qwen-Image-Edit and FLUX.1 Kontext-dev on both ReasonEdit and HumanEdit-core, as reported in Table R5 and Table R6. All methods are evaluated under the same maximum budget of eight editor calls per input. For both frontier editors, we evaluate Best-of-8 results by generating eight candidates per input and selecting the final output based on CLIP scores, following the corresponding benchmark evaluation protocol. CG-TTS starts with four candidates and allocates additional editor calls to on-demand repair, subject to the same eight-call budget.

Table R5: Comparison with frontier image editors on ReasonEdit (U/R).

MethodPSNR ↑LPIPS ↓SSIM ↑CLIPSim ↑GPT-5 IC ↑Gemini 2.5 Pro IC ↑Human ↑
FLUX.1 Kontext-dev (Best-of-8)13.616/12.17926.32/25.600.372/0.24717.662/17.5150.247/0.5290.255/0.5240.446/0.621
Qwen-Image-Edit (Best-of-8)12.682/11.99332.62/27.270.409/0.33622.378/19.6640.587/0.7640.681/0.5920.487/0.630
CG-TTS (BrushNet)37.964/36.56210.59/11.100.986/0.98624.075/20.8290.794/0.8690.694/0.7810.857/0.877
CG-TTS (SDXL Inpainting)40.882/42.3768.42/4.060.989/0.99322.579/19.8990.525/0.3330.419/0.3500.659/0.583

Table R6: Comparison with frontier image editors on HumanEdit-core.

MethodL1 ↓L2 ↓CLIP-I ↑DINO ↑CLIP-T ↑GPT-5 IC ↑Gemini 2.5 Pro IC ↑Human ↑
FLUX.1 Kontext-dev (Best-of-8)0.12310.04190.89540.75520.19350.6630.4030.618
Qwen-Image-Edit (Best-of-8)0.13590.04740.92320.83000.18000.8010.6970.632
CG-TTS (BrushNet)0.04670.01690.89040.81050.21590.4420.2330.552
CG-TTS (SDXL Inpainting)0.03950.01340.94120.90340.21570.6150.4890.813
Reviewer_HqLnOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes Contract-Guided Test-Time Scaling (CG-TTS), a training-free inference framework for instruction-based image editing on top of frozen diffusion editors (evaluated on BrushNet and SDXL-Inpainting). Given a source image and an editing instruction, CG-TTS first employs a frozen MLLM (and deterministic post-processing) coupled with a frozen reasoning segmentation model (LISA) to construct a structured semantic-spatial contract C=(S,M)C = (\mathcal{S}, \mathcal{M}). The spatial component partitions the image into four functional masks: must-edit (Medit\mathcal{M}_{\text{edit}}), context (Mcontext\mathcal{M}_{\text{context}}), allowed-change (Mallow\mathcal{M}_{\text{allow}}), and protected (Mprotect\mathcal{M}_{\text{protect}}). This shared contract guides three stages: (1) candidate generation with Source-Memory Routing (SMR), which injects non-parametric kNN-retrieved VAE mid-block features into the conditioning path using operation-specific positive/negative residual updates; (2) staged conjunctive verification combining low-level spatial change metrics (Change Localization Precision CLP, Target Change Recall TCR, Protected Preservation Score PPS) with semantic checks; and (3) a single failure-conditioned repair round that deterministically adjusts generation parameters if no initial candidate passes all mandatory checks. Experiments on ReasonEdit (191 samples) and HumanEdit-core (400 samples) show improvements in both edited-region alignment and background preservation over single-pass editing and scalar Best-of-NN baselines.

Critical strengths
  1. Formulating test-time scaling around conjunctive verification rather than compensatory scalar rewards: A major failure mode of Best-of-NN selection in image editing is that a single scalar reward (e.g., CLIPScore or holistic VLM score) allows strong semantic edits to mask background corruption or unchanged images to score high on preservation. Decoupling hard, clause-level conjunctive constraints (CLP, TCR, PPS, and target presence) from post-acceptance soft ranking is a principled and practical design for reliable editing.
  2. Unified use of the semantic-spatial contract across generation, verification, and repair: Rather than treating test-time scaling purely as post-hoc filtering, CG-TTS reuses the localized contract masks to modulate conditioning features via training-free Source-Memory Routing (SMR) and to trigger targeted parameter repair only when initial candidates fail, reducing average editor calls by 37.8% compared to uniform Best-of-8.
Critical weaknesses
  1. Unfair/incomplete accounting of end-to-end test-time compute and latency: The paper defines the test-time budget solely in terms of diffusion "editor calls" (B=N(1+R)B = N(1+R), averaging 4.98 calls), explicitly excluding MLLM contract construction, LISA reasoning segmentation, SMR feature retrieval, and multi-detector/VLM semantic verification from the budget (Appendix A.1). In practice, invoking LISA + MLLM + semantic verifiers incurs substantial wall-clock latency and GPU memory overhead compared to lightweight early-timestep pruning baselines (e.g., ESelect, AdaEdit) or single-pass editors. Without wall-clock latency and total FLOPs/VRAM comparisons, the efficiency claims of CG-TTS are incomplete.
  2. Heavy reliance on a hand-engineered rule system and localization bottleneck: While presented as a general framework, the actual implementation relies on an intricate set of hand-tuned thresholds, morphological operations, operation-specific routing coefficients (λ∈{0.08,0.10,0.12,0.16,0.18,0.65}\lambda \in \{0.08, 0.10, 0.12, 0.16, 0.18, 0.65\} in Table 6), area-dependent TCR thresholds (Table 7), and even backend-specific gates (e.g., PPS≥0.97\text{PPS} \ge 0.97 added specifically for SDXL-Inpainting in Appendix A.2). Furthermore, both generation backbones (BrushNet and SDXL-Inpainting) are explicit mask-conditioned inpainting models that depend directly on LISA's mask; it is unclear how much of the gain over mask-free baselines stems simply from giving a strong inpainting model a LISA segmentation mask, or whether CG-TTS generalizes to modern mask-free DiT editors (e.g., FLUX.1 Kontext, Step1X-Edit, Qwen-Image-Edit).
Questions for authors
  1. Wall-clock latency and total compute (Clarification): Can the authors report the average end-to-end wall-clock runtime (broken down into MLLM contract parsing, LISA localization, diffusion generation with SMR, and staged verification) and peak GPU memory usage per sample compared to Best-of-NN, ESelect, and AdaEdit?
  2. Backend-specific threshold tuning (Clarification): Appendix A.2 notes that an extra hard preservation gate (PPS≥0.97\text{PPS} \ge 0.97) is enabled for SDXL-Inpainting but not for BrushNet. How were the numerous hyperparameters in Tables 6 and 7 tuned, and were they tuned directly on the ReasonEdit / HumanEdit test splits (which have no separate validation splits)?
  3. Applicability to mask-free modern editors (Clarification / Scope): Both BrushNet and SDXL-Inpainting require an explicit spatial mask as input. Can CG-TTS and SMR be applied to state-of-the-art mask-free flow/DiT editors (such as FLUX.1 Kontext or OmniGen2), or is the framework restricted to mask-guided inpainting backbones?
4 comments

Response to Reviewer HqLn (Part 1):

Thank you for your careful review and for recognizing the importance of conjunctive verification and the shared contract underlying generation, verification, and repair. We also appreciate your suggestions to clarify full-pipeline costs, hyperparameter calibration, and applicability to mask-free editors. Below, we provide the corresponding clarifications and additional results. All revisions and additions to the main text are highlighted in red in the revised manuscript for ease of review.

W1, Q1: End-to-end computational cost

A1: Thank you for this suggestion. CG-TTS can achieve higher instruction compliance with fewer editor calls on ReasonEdit-U. As requested, we have added measurements of end-to-end runtime, peak allocated GPU memory, and local FLOPs on a 100-sample subset drawn from HumanEdit-core. All measurements were conducted on a single NVIDIA RTX PRO 6000 Blackwell Server Edition GPU. Each method was evaluated using its respective input resolution. For CG-TTS, we set the shorter side of each input image to 640 pixels and scaled the longer side proportionally. The results are summarized in Table R1 (Table 5, line 432).

Table R1: End-to-end computational cost on 100 HumanEdit-core samples.

MethodLatency (s/image)Peak allocated GPU memory (GiB)FLOPs (TFLOPs)Human
CLIP Best-of-840.5118.901791.380.426
VIEScore Best-of-860.5629.581970.780.430
EditScore Best-of-863.4029.592,031.530.386
SmartFreeEdit11.5212.07219.200.488
BrushNet7.5018.89259.500.517
SDXL Inpainting8.7220.11942.130.654
ADE-CoT236.5950.8719494.400.701
ELECT8.122.59942.130.523
CG-TTS (SDXL Inpainting)110.3319.001622.470.822

Table R2: End-to-end runtime breakdown of CG-TTS (SDXL Inpainting) on 100 HumanEdit-core samples.

StageTime (s/image)
Contract Construction9.458
Localization3.954
Candidate Generation25.309
Candidate Verification70.342
Other Processing1.263
Total Runtime110.326
  • About budget scope. CG-TTS averages 4.98 editor calls versus eight for CLIP Best-of-8, a reduction of 37.8%, while improving GPT-5/Gemini IC from 0.744/0.669 to 0.794/0.694 on ReasonEdit-U (Table 1). These counts measure frozen-editor invocations. Blind human evaluations on 50 eligible HumanEdit samples further show that CG-TTS achieves the highest composite Human score of 0.822, outperforming all compared methods.

  • About runtime breakdown. The additional verification and repair contribute to the gains in instruction compliance and constraint satisfaction reported in **Table 1 (Table 5, line 432) and Table 2( Table 6, line 442) **. On HumanEdit, the complete pipeline averages 110.33 s/image, including 43.24 s (39.2%) of remote API waiting. Table R2 presents the runtime breakdown.

  • About baseline comparisons. CG-TTS uses 9.4%–20.1% fewer local FLOPs than the three Best-of-8 controls, with peak allocated GPU memory comparable to CLIP Best-of-8 (19.00 versus 18.90 GiB). Local FLOPs exclude computation performed by remote APIs.

We have incorporated these additional experimental results and corresponding analyses into the main text of the revised manuscript (Section 4.4, line 475).

Response to Reviewer HqLn (Part 1):

W2, Q2: Threshold selection

A2: Thank you for this question. Our configurations were fixed before benchmark evaluation, without test-set tuning. Although calibrated on a set of 200 CC12M examples, the resulting configurations are designed to be transferable beyond the calibration samples. We apply them across ReasonEdit and HumanEdit-core, which cover diverse editing tasks and differ in dataset composition, without dataset-specific retuning.

  • Backend-specific thresholds. SDXL-Inpainting adds PPS ≥ 0.97 to the common base PPS criterion, while BrushNet retains the base criterion. These settings were selected on the same independent calibration set of 200 CC12M examples, considering background preservation and the retention of instruction-compliant candidates. The same numerical cutoff need not retain the same proportion of valid candidates across editors, motivating backend-specific calibration. The general use of preservation and verification signals for candidate selection follows prior work [1, 2].

  • Hyperparameter calibration. We use fixed operation-conditioned configurations, including predefined area-dependent TCR rules, without per-image optimization. The routing coefficients and verification thresholds in Table 6 and Table 7 were calibrated on the same 200 CC12M examples; CC12M is also used in prior image-editing studies [3–5]. Morphological post-processing uses 3×3 opening, 5×5 closing, and small-component removal to suppress isolated noise and fill small gaps in the binary change map. These morphological settings are shared across operations and datasets.

  • Test-set independence. Neither ReasonEdit nor HumanEdit-core was used for hyperparameter selection. All operation-conditioned configurations and backend-specific settings were fixed before final evaluation and applied unchanged to both benchmarks, without dataset-specific retuning.

References:

[1] From Scale to Speed: Adaptive Test-Time Scaling for Image Editing, CVPR 2026, pp. 23272–23282.

[2] Early Timestep Zero-Shot Candidate Selection for Instruction-Guided Image Editing, ICCV 2025, pp. 18844–18854.

[3] SmartEdit: Exploring Complex Instruction-based Image Editing with Multimodal Large Language Models, CVPR 2024, pp. 8362–8371.

[4] FireEdit: Fine-grained Instruction-based Image Editing via Region-aware Vision Language Model, CVPR 2025, pp. 13093–13103.

[5] UIP2P: Unsupervised Instruction-based Image Editing via Edit Reversibility Constraint, ICCV 2025, pp. 18895–18905.

W2, Q3: Mask-free editors

A3: Thank you for this question. We have adapted both CG-TTS and SMR to the mask-free editor FLUX.1 Kontext-dev. The results demonstrate that our method can be effectively applied to mask-free editing. Compared with the original FLUX.1 Kontext-dev baseline, CG-TTS improves GPT-5 IC from 0.658 to 0.690, while reducing L1 and L2 errors by 36.1% and 40.2%, respectively. CLIP-I and CLIP-T also show marginal improvements. These results provide initial evidence of the applicability of CG-TTS to mask-free editors. We will further investigate its effectiveness and generalizability across a broader range of advanced mask-free image editors. We evaluated this implementation on HumanEdit-core, with results reported in Table R3.

Table R3: FLUX.1 Kontext-dev on HumanEdit-core.

MethodCLIP-I ↑DINO ↑CLIP-T ↑GPT-5 IC ↑L1 ↓L2 ↓
FLUX.1 Kontext-dev0.91760.84590.21280.6580.09610.0346
CG-TTS (FLUX.1 Kontext-dev)0.91870.84320.21330.6900.06140.0207
  • Contribution beyond localization. Contract-guided verification and selection provide benefits beyond the localization masks. Table 1 and Table 2 hold localization and the candidate pool fixed. On ReasonEdit-U, GPT-5/Gemini IC improves from 0.744/0.669 to 0.794/0.694 over CLIP Best-of-8, while mandatory constraint violations decrease from 49.6% to 21.4%.

  • CG-TTS applicability. Contract-guided verification and selection do not require an explicit mask input to the editor (Section 3.4). FLUX.1 Kontext-dev generates candidates through its native image–instruction interface. Repair updates the prompt or supported inference parameters, and the resulting candidates are verified against the unchanged contract.

  • SMR adaptation. SMR performs retrieval and residual updates on source-image conditioning features (Section 3.3; Appendix A.1). For FLUX.1 Kontext-dev, we map contract-defined regions to spatial positions in these features and apply the routing updates at this interface, without relying on U-Net-specific denoising layers.

Reviewer_HqLnOpenReview ↗

Response to the authors

Thank you to the authors for the detailed responses and for running the additional latency breakdown and FLUX.1 Kontext-dev experiments.

While I appreciate the authors' effort in providing the new tables, the newly reported empirical numbers reinforce several of my core concerns:

  1. End-to-end latency and remote API compute: Table R1 and Table R2 show that CG-TTS requires 110.33 s/image (with verification alone taking 70.34 s), which is 2.7x slower than CLIP Best-of-8 (40.51 s) and nearly 2x slower than VIEScore Best-of-8 (60.56 s). Moreover, claiming that CG-TTS uses "9.4% fewer local FLOPs" while excluding 43.24 s of remote MLLM API computation from the FLOPs count does not reflect the true total computational cost of the pipeline.
  2. Marginal gains on mask-free modern editors: In Table R3 (FLUX.1 Kontext-dev on HumanEdit-core), adding CG-TTS + SMR yields virtually unchanged CLIP-I (0.9176 vs. 0.9187) and CLIP-T (0.2128 vs. 0.2133), while DINO similarity slightly decreases (0.8459 vs. 0.8432). Furthermore, in Table R6 (in response to Reviewer 8deL), a simple Best-of-8 on Qwen-Image-Edit achieves substantially higher instruction compliance (0.801 GPT-5 IC / 0.697 Gemini IC) than both CG-TTS (BrushNet) (0.442 / 0.233) and CG-TTS (SDXL Inpainting) (0.615 / 0.489).

Overall, the rebuttal clarifies the calibration procedure on CC12M, which I appreciate, but the heavy reliance on external MLLM/grounding calls, high wall-clock latency, and limited effectiveness on modern mask-free editors remain significant limitations. I will therefore maintain my current score.

Thank you for taking the time to respond so thoughtfully and to examine our additional experiments in detail. We appreciate your careful assessment and would like to clarify two points.

1. End-to-end cost. The primary focus of this work is the overall design of the CG-TTS pipeline, including contract construction, candidate generation, verification, and failure-conditioned repair, with dedicated optimization of verification efficiency are currently outside the scope of this study. The 110.33 s/image includes remote API waiting, while the 9.4% reduction refers specifically to local FLOPs. We report these measurements to provide a transparent account of the current pipeline's computational cost.

2. Comparison with modern editors. We agree that the results with modern editors are important for understanding the scope of CG-TTS. However, comparing their absolute performance directly does not isolate the contribution of our method, as the underlying editors differ substantially in architecture and editing capabilities. BrushNet is a frozen, mask-guided inpainting model designed to fill specified regions, whereas Qwen-Image-Edit combines a 20B-parameter diffusion backbone with Qwen2.5-VL for visual-semantic control. Thus, Best-of-8 controls the number of generated candidates but does not eliminate the substantial difference in the underlying editing models. We are currently conducting additional experiments using Qwen-Image-Edit as the base editor to further evaluate CG-TTS, and will share the results if they are available before the discussion deadline.

A more direct assessment of CG-TTS comes from holding the underlying editor fixed. On ReasonEdit's reasoning tasks, CG-TTS improves BrushNet's GPT-5 IC from 0.217 to 0.869, demonstrating that contract-guided verification and repair substantially strengthen instruction following even with a frozen inpainting backbone. The BrushNet baseline comparison in Table 1 and the Qwen-Image-Edit Best-of-8 comparison in Table R5 provide complementary references for evaluating the contribution of CG-TTS, without conflating improvements from the underlying editor with those introduced by CG-TTS.

We sincerely appreciate your careful consideration of our work and the opportunity to clarify these points. We hope that our additional explanations and experimental evidence help address your remaining concerns and clarify the scope and contributions of CG-TTS. We would be very happy to discuss any remaining questions further.

Reviewer_bdbSOpenReview ↗
Rating
3
Confidence
1
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

Existing test-time scaling methods improve image editing by generating and comparing multiple candidates, but ranking candidates using a single scalar score can obscure violations of individual requirements. Strong performance on some criteria may compensate for failures on others, allowing highly ranked outputs to omit requested changes or modify protected content.

The paper proposes CG-TTS, a training-free framework that requires candidates to pass every mandatory contract clause before acceptance. It consists of three stages.

First, a frozen GPT-4o model and the visual grounding models LISA and Grounding DINO convert instructions into operation types, target states, and three mutually exclusive spatial masks: a required edit region, an allowed context region, and a protected region.

Second, source-memory routing retrieves and blends source-image features at the VAE encoder bottleneck of frozen editors such as BrushNet and SDXL-Inpainting. This supports diverse candidate generation without introducing trainable parameters.

Third, a staged verifier checks actual spatial changes and operation-specific semantic requirements, then ranks passing candidates using soft metrics. If no candidate passes all mandatory checks, diagnostic feedback guides a single round of repair within the remaining budget, followed by verification against the same contract.

Critical strengths
  1. The three-region spatial partition provides finer control than a binary foreground–background mask. The context region accommodates changes around object boundaries, shadows, and reflections, while set subtraction explicitly assigns non-target instances detected by Grounding DINO to the protected region. This helps prevent mask dilation from inadvertently affecting nearby instances of the same category.
  2. The source-memory routing mechanism is computationally lightweight. It performs a single retrieval and interpolation operation on the VAE encoder’s mid_block features during conditioning-image encoding, using cosine similarity and a spatial Euclidean distance penalty to select the top matching features. The resulting conditioning latent is reused throughout the subsequent 50 denoising steps. This improves background texture continuity for removal and replacement operations at little additional computational cost.
Critical weaknesses
  1. The paper reports state-of-the-art performance under an equal editor-call budget. Please also provide end-to-end comparisons at matched latency or computational cost to substantiate the efficiency claim. In particular, how much additional inference latency does the full pipeline introduce?
  2. The scores in Table 1 and Appendix Table 9 appear inconsistent. Table 1 reports GPT-5 and Gemini IC scores of 0.869 and 0.781 for CG-TTS with BrushNet, whereas Table 9 reports IC scores of 0.4585 and 0.3410. Please clarify how these two experiments differ and what accounts for the discrepancy.
Questions for authors

I used ChatGPT only to polish my original review. I did not use AI to evaluate the paper or formulate any review judgments.

3 comments

Response to Reviewer bdbS (Part 1):

Thank you for your careful review and for recognizing the fine-grained spatial control and lightweight SMR design. We also appreciate your questions about end-to-end inference cost and the IC scores across the two tables. To address these concerns, we provide additional end-to-end computational measurements, including peak allocated GPU memory, local FLOPs, and a stage-wise runtime breakdown, and clarify the distinct IC scoring protocols, as detailed below. All revisions and additions to the main text are highlighted in red in the revised manuscript for ease of review.


W1: End-to-end computational cost and latency

A1: Thank you for requesting a fuller assessment of inference efficiency. CG-TTS uses 9.4% fewer local FLOPs than CLIP Best-of-8, while introducing additional end-to-end inference latency. To provide a more comprehensive comparison, we have added end-to-end latency and local FLOPs measurements on a 100-sample subset drawn from HumanEdit-core (HumanEdit-100) in Table R1 (Table 5, line 432). All measurements were conducted on a single NVIDIA RTX PRO 6000 Blackwell Server Edition GPU. Each method was evaluated using its respective input resolution. For CG-TTS, we set the shorter side of each input image to 640 pixels and scaled the longer side proportionally.

Table R1: End-to-end computational cost on 100 HumanEdit-core samples.

MethodLatency (s/image)Peak allocated GPU memory (GiB)Local FLOPs (TFLOPs)Human
CLIP Best-of-840.5118.901791.380.426
VIEScore Best-of-860.5629.581970.780.430
EditScore Best-of-863.4029.592,031.530.386
SmartFreeEdit11.5212.07219.200.488
BrushNet7.5018.89259.500.517
SDXL Inpainting8.7220.11942.130.654
ADE-CoT236.5950.8719494.400.701
ELECT8.122.59942.130.523
CG-TTS (SDXL Inpainting)110.3319.001622.470.822

Table R2: End-to-end runtime breakdown of CG-TTS (SDXL Inpainting) on 100 HumanEdit-core samples.

StageTime (s/image)
Contract Construction9.458
Localization3.954
Candidate Generation25.309
Candidate Verification70.342
Other Processing1.263
Total Runtime110.326

CG-TTS averages 110.33 s/image, introducing 69.82 s of additional inference latency over CLIP Best-of-8, while using 9.4% fewer local FLOPs. The additional latency primarily reflects the overhead of contract construction, localization, SMR, generation, and verification, including 43.24 s (39.2%) of remote API waiting. To further characterize the computational overhead, we also report peak allocated GPU memory and provide a stage-wise runtime breakdown in Table R2 (Table 6, line 432). CG-TTS has a peak allocated GPU memory of 19.00 GiB, comparable to 18.90 GiB for CLIP Best-of-8. Local FLOPs exclude computation performed by remote APIs.

We have incorporated these additional experimental results and corresponding analyses into the main text of the revised manuscript (Section 4.4, line 475).

Response to Reviewer bdbS (Part 2):

W2: IC scoring protocols

A2: Thank you for bringing this to our attention. To ensure consistency and fairness in the evaluation, we have re-evaluated the results using a unified scoring protocol, updated the corresponding scores in Table 9 (now Table 11, line 972), and clarified the evaluation settings (Appendix B.1).

Table 9 (now Table 11, line 972): Blind MLLM-judge evaluation on ReasonEdit.

JudgeMethodTC ↑WTC ↓NTP ↑AS ↓IC ↑
Understanding (U), N=80
Gemini 2.5 ProCG-TTS (BrushNet)0.61250.25000.71900.58150.694
Gemini 2.5 ProCG-TTS (SDXL Inpainting)0.44400.26250.68750.72500.419
Gemini 2.5 ProSmartFreeEdit0.26250.26250.70650.72500.475
GPT-5CG-TTS (BrushNet)0.80650.06900.95000.46250.794
GPT-5CG-TTS (SDXL Inpainting)0.52500.15000.85000.75000.525
GPT-5SmartFreeEdit0.21250.43750.68150.78150.425
Qwen3 VL-PlusCG-TTS (BrushNet)0.85000.05650.94400.54400.812
Qwen3 VL-PlusCG-TTS (SDXL Inpainting)0.50650.26900.76900.79400.487
Qwen3 VL-PlusSmartFreeEdit0.18150.60650.46250.89400.162
Reasoning (R), N=60
Gemini 2.5 ProCG-TTS (BrushNet)0.38350.23750.75000.70000.781
Gemini 2.5 ProCG-TTS (SDXL Inpainting)0.39150.25850.71650.72500.350
Gemini 2.5 ProSmartFreeEdit0.38350.34150.65000.62500.683
GPT-5CG-TTS (BrushNet)0.47100.17100.85000.77500.869
GPT-5CG-TTS (SDXL Inpainting)0.34150.25850.86650.59150.333
GPT-5SmartFreeEdit0.27500.34150.84150.58350.550

On the Understanding subset, CG-TTS (BrushNet) achieves the highest TC, NTP, and IC scores across all three judges, demonstrating consistent target realization and non-target preservation. On the Reasoning subset, it also obtains the highest IC scores under GPT-5 and Gemini 2.5 Pro (0.869 and 0.781).

We have accordingly updated the reported results and corresponding discussions throughout the manuscript, and added the unified evaluation details in Appendix B.1.

Thanks for your answers. Your rebuttal has addressed my concerns and I'll keep my positive score.

Comments on the paper

2 comments
AuthorsOpenReview ↗

Reply to All Reviewers

We are grateful for the positive feedback and constructive suggestions from the reviewers. For each item, we have provided detailed responses and supplemented necessary experiments. If you have any further questions, please feel free to let us know. We are more than willing to have more discussions. Thanks.

-Authors of paper 17261

AuthorsOpenReview ↗

Reply to All Reviewers

Dear Reviewers,

We have provided our responses to all of your questions and comments on the paper. As the rebuttal period is drawing to a close, please let us know if there is anything further you would like us to clarify, we would be happy to provide any additional details.

Sincerely,

-The authors of paper 17261

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.