ArXiv: 2605.23897

🎯 Pitch

Off-the-shelf image editors fail catastrophically as reasoning assistants because edit quality plummets with task depth—maze path accuracy drops from near-perfect to near zero as length grows from 1 to 10. ETCHR fixes both this generation-side collapse and a language-side gap where editors cannot infer needed visual transformations from abstract questions, delivering +4.6 to +5.5 Pass@1 gains across five reasoning tasks when plugged into any MLLM without retraining it.

1. Executive Summary

This paper introduces ETCHR (Editing To Clarify and Harness Reasoning), a question-conditioned image editor that provides intermediate visual evidence for "think with images" reasoning, decoupled from the downstream understanding MLLM so it plugs into different open- and closed-source models without fine-tuning. The approach is motivated by a diagnosis of two complementary gaps in off-the-shelf editors—a language-side gap where editors trained as passive instruction-followers cannot map abstract questions to appropriate visual transformations (e.g., inferring that "Is the trash can on the left or right side of the black chair?" requires drawing a bounding box around the trash can), and a generation-side gap where edit correctness degrades as reasoning depth grows (e.g., maze path accuracy dropping from near-perfect at path length 1 to near-zero at length 10)—and addresses them through a two-stage training recipe: Reasoning Imitation via supervised fine-tuning on question-conditioned edit trajectories, followed by Reasoning Enhancement via reinforcement learning with VLM-derived rewards for both edit correctness and downstream reasoning accuracy, plus an Edit-Verify-Reason inference procedure that lets the understanding model reject unreliable edits. Across five task families (fine-grained perception, chart understanding, logic reasoning, jigsaw restoration, and 3D understanding), ETCHR raises average Pass@1 from 55.95 to 60.77 (+4.82) with Qwen3-VL-8B, from 65.08 to 70.55 (+5.47) with Gemini-3.1-Flash-Lite, and from 76.55 to 81.16 (+4.61) with the 1T-parameter MoE model Kimi K2.5, establishing that a dedicated specialist editor can serve as a general visual reasoning assistant without retraining the downstream model, though end-to-end performance remains capped by the understanding model's own reasoning ceiling even with optimally edited intermediates.

2. Context and Motivation

The Core Problem: When Questions Demand More Than Words

The central challenge this paper addresses is subtle but pervasive in multimodal reasoning: some visual questions cannot be answered well by looking at the original image alone, even with a sophisticated chain-of-thought. Consider two categories of failure. First, a question might ask about a tiny detail in a high-resolution photograph—"Is the beer bottle silver?"—where the referent occupies only a few pixels, and the model's visual encoder, optimized for global scene understanding, simply doesn't allocate enough representational resolution to that region. The model knows the bottle exists somewhere in the scene but cannot reliably extract its color. Second, a question might require imagining how a scene would look from a different vantage point—"From the perspective of this woman dressed in green, where is the woman dressed in red located?"—where the answer depends on a spatial transformation the model must simulate internally. In both cases, a purely textual chain-of-thought forces the model to verbalize visual states it cannot draw, and small descriptive errors compound across reasoning steps.

This is not a niche edge case. Fine-grained perception benchmarks like V*Bench (Wu & Xie, 2024) and HRBench (Wang et al., 2025) systematically expose this limitation: even strong MLLMs like Qwen3-VL-8B, which achieves roughly 85% on V*Bench overall, still miss questions that require localizing a specific object among dozens of similar distractors. Similarly, on 3D perspective-taking tasks like ViewSpatial-Bench (Li et al., 2025), models must perform what amounts to mental rotation—translating an egocentric view into an allocentric frame—and regularly fail because they lack the geometric reasoning precision to maintain consistent spatial relations across viewpoint changes.

The insight that unifies these failures is that the bottleneck is not knowledge or high-level reasoning strategy, but access to the right visual evidence at the right moment. The model possesses the capability to answer the question—given the beer bottle highlighted with a bounding box, or given a second image showing the scene from behind, it succeeds—but that capability remains latent because the raw input doesn't surface the necessary information in a form the model can exploit. This is fundamentally a representation problem, not a reasoning problem.

Why This Matters: The Broader Stakes of "Thinking with Images"

The practical implications extend well beyond benchmark scores. In deployment scenarios ranging from medical image analysis (where a radiologist asks "Is there a micronodule in the upper right lobe?") to autonomous driving (where a planner asks "Is the pedestrian at the crosswalk looking at the approaching vehicle?") to accessibility applications (where a visually impaired user asks "What's the price on the top shelf?"), the ability to answer a question often hinges on visually transforming the input to make the answer legible—zooming into a region, highlighting a specific object, or re-rendering from a different angle. A system that answers correctly 85% of the time but fails on the 15% that require targeted visual attention is not merely slightly worse; it fails precisely when the question is hardest to verify by other means, since these are the cases where the answer isn't obvious from a casual glance.

There is also a theoretical stake. The "think with images" paradigm sits at the intersection of two fundamental tensions in multimodal AI: the understanding-generation tradeoff and the specialization-flexibility tradeoff. The understanding-generation tradeoff refers to the observation that models optimized jointly for both capabilities—generating images and answering questions about them—tend to underperform specialist models on each axis individually. This is the finding documented by UniG2U-Bench (Wen et al., 2026) and visible in the performance gap between unified models like ThinkMorph-7B (44.05 average Pass@1 in Table 1) and specialist understanding models like Qwen3-VL-8B (55.95 average). The specialization-flexibility tradeoff refers to the tension between building a system that can execute a wide range of visual transformations (flexibility) versus one that executes a specific set of transformations with high fidelity (specialization). Tool-based methods like DeepEyesV2 (Hong et al., 2025) and Thyme (Zhang et al., 2025) achieve high fidelity on supported operations (drawing bounding boxes, cropping regions) but cannot perform transformations outside their predefined action space (tracing a maze path, re-rendering a 3D viewpoint). Unified models like Zebra-CoT (Li et al., 2025) achieve flexibility but sacrifice fidelity—their intermediate images often inject noise rather than guidance.

Resolving these tensions is not merely an engineering exercise. It bears on the deeper question of whether visual reasoning should be implemented as an end-to-end capability of a single model or as a composition of specialized modules. The end-to-end approach, dominant in the "unified model" paradigm, appeals to the scaling hypothesis—the belief that larger models trained on more data will eventually subsume all sub-capabilities. The compositional approach, which ETCHR adopts, appeals to the modularity hypothesis—the belief that some functions (generating faithful images, answering questions about those images) are best performed by separate, optimized components that communicate through clean interfaces. This paper provides evidence for the modularity hypothesis in a specific, empirically grounded form: it shows that a dedicated editor, trained with reasoning-aware objectives but architecturally decoupled from the understanding model, can serve as a general-purpose visual reasoning assistant across diverse task families without retraining the downstream model. If this finding generalizes, it suggests that the path to robust multimodal reasoning may involve fewer unified super-models and more carefully designed pipelines of specialist components.

Where Prior Approaches Fall Short

The paper identifies three families of prior work and systematically diagnoses their failure modes.

Tool-Based Methods: Fixed Action Spaces, Task-Specific Fine-Tuning

Tool-based methods couple an understanding MLLM with a deterministic external renderer. The MLLM emits structured actions—bounding box coordinates, crop/zoom commands, or executable code snippets—and the renderer executes them on the input image. Visual Sketchpad (Hu et al., 2024) pioneered this approach for geometric reasoning, prompting the MLLM to draw auxiliary lines and spatial annotations. V* (Wu & Xie, 2024) and DeepEyes (Zheng et al., 2025) specialized it for fine-grained visual search, emitting bounding-box commands that progressively localize the queried region. Thyme (Zhang et al., 2025) and DeepEyesV2 (Hong et al., 2025) extended the action space to executable code for chart parsing.

The strength of these methods is controllability: the renderer deterministically executes exactly what the MLLM specifies, so intermediate outputs are interpretable and reproducible. The weaknesses are structural. First, the action space is fixed at design time. The renderer can draw boxes, crop regions, and overlay annotations, but it cannot trace a path through a maze, restore a shuffled jigsaw puzzle, or re-render a scene from a different camera angle. These transformations require generative capabilities—understanding the maze topology, inferring the correct tile arrangement, synthesizing a novel view—that a deterministic renderer simply does not possess. The paper marks these out-of-scope tasks with † in Table 1, making clear that the failure is not poor performance but fundamental inapplicability.

Second, each new family of actions typically requires task-specific fine-tuning of the understanding model. The MLLM must learn to emit the action tokens in the correct format, which means it must be trained on task-specific data. This has two consequences: the fine-tuning process can erode the model's general competence through catastrophic forgetting (Kirkpatrick et al., 2017), and a separate model variant must be maintained per deployment scenario. You cannot take a Thyme-fine-tuned model designed for chart reasoning and deploy it for maze solving; you would need to fine-tune a separate variant. This violates the desideratum of a general-purpose visual reasoning assistant that works across tasks without per-task adaptation.

Unified Multimodal Models: Weaker Generation and Understanding

Unified models pursue the opposite extreme: a single backbone natively interleaves text and image tokens, removing the external renderer entirely. Chameleon (Team, 2024) and Show-o (Xie et al., 2024) demonstrated joint autoregressive and diffusion modeling over a shared token space. Janus (Wu et al., 2025) improved on this by decoupling the visual encoder for understanding from the one used for generation, relieving the optimization tension between the two objectives. More recently, ThinkMorph (Gu et al., 2025) and Zebra-CoT (Li et al., 2025) fine-tuned unified models on interleaved reasoning traces, showing emergent adaptive modality switching where the model decides when to generate an intermediate image versus when to reason textually.

The appeal is flexibility: because generation and understanding share a representation space, the model can in principle produce any visual transformation that aids reasoning, unconstrained by a predefined action vocabulary. The reality, however, is that the jointly optimized generative head trails specialist image editors in fidelity. UniG2U-Bench (Wen et al., 2026) quantified this: intermediate images from unified models frequently inject noise rather than evidence. The paper's Table 1 corroborates this quantitatively: ThinkMorph-7B achieves 44.05 average Pass@1 versus 55.95 for the unaided specialist model Qwen3-VL-8B, meaning the unified model performs worse with its own generated intermediates than the specialist model does with no intermediates at all. This is the central pathology: the generative head is asked to produce images that serve as evidence for reasoning, but those images are themselves unreliable, creating a feedback loop where noisy intermediates degrade reasoning rather than enhancing it.

The concurrent issue is that the unified backbone lags specialist understanding models on pure perception tasks. Show-o and Janus, despite architectural innovations to decouple understanding and generation pathways, still underperform same-scale models optimized solely for understanding. This reflects a deep optimization tension: the features that make a good image generator (fine-grained texture, high-frequency detail, precise spatial layout) are not the same features that make a good image understander (semantic abstraction, invariance to nuisance variation, relational structure). Joint optimization forces a compromise that leaves both capabilities suboptimal.

Off-the-Shelf Image Editors: The Question-to-Edit Gap

A third, less explored option is to use a dedicated image-to-image editor as the intermediate-image generator. Modern editors like FLUX.2-klein-base-9B (Black Forest Labs, 2025) and Qwen-Image-Edit (Wu et al., 2025) have replaced the shallow CLIP-style text encoders (Radford et al., 2021) of earlier editors with MLLM-style encoders, giving them enough language-side capacity to parse complex instructions. InstructPix2Pix (Brooks et al., 2023) fine-tuned a latent diffusion model on synthetic before/after pairs, and MagicBrush (Zhang et al., 2023) improved edit faithfulness with human-annotated real-image edits.

Architecturally, this option is promising: a specialist editor expresses a far broader transformation space than tool-based methods, preserves higher fidelity than the generative head of a unified model, and decouples edit quality from the understanding model so the latter need not be retrained. The paper's diagnosis in Section 2, however, identifies two complementary gaps that prevent off-the-shelf editors from serving as effective reasoning assistants.

The language-side gap (Fig. 2a) is that editors are trained as passive instruction-followers. They expect an explicit edit prompt—"draw a red box around the trash can"—and optimize for faithfully rendering that instruction. When handed an abstract question—"Is the trash can on the left or right side of the black chair?"—the editor has no training signal for inferring that the useful transformation is to localize the trash can with a bounding box. The question-to-edit mapping must be learned; it is not a capability that emerges from instruction-following training. The paper quantifies this by comparing editor performance when given a concrete instruction (derived by a prompt enhancer that converts the question to an edit command) versus the raw question: the concrete-instruction condition significantly outperforms the abstract-question condition, confirming that the base editor lacks a reliable question-to-edit mapping.

The generation-side gap (Fig. 2b) is that even when the instruction is perfectly specified, edit correctness degrades as the transformation requires deeper reasoning during the diffusion process. Using maze-solving and frozen-lake tasks where the ground-truth path is provided as a text prompt, the paper measures edit correctness as a function of path length. At path length 1 (a single-step move), accuracy is near-perfect. As path length grows to 10, accuracy approaches zero. This indicates that current editing models lack the capacity for multi-hop reasoning during the DiT decoding phase—even when the diffusion model is told exactly what to draw, it cannot maintain spatial consistency over long, multi-step trajectories. This is not a language-side failure (the instruction is perfectly clear) but a generation-side failure: the model's internal representations cannot sustain the algorithmic inference needed to trace a long path without errors.

Critically, these two gaps are complementary. The language-side gap means the editor cannot infer what to draw; the generation-side gap means it cannot draw it correctly even when told. Addressing only one would leave the other as a bottleneck. This analysis directly motivates ETCHR's two-stage training design: Stage I (Reasoning Imitation) addresses the language-side gap by fine-tuning the editor on question-conditioned edit trajectories so it learns the question-to-edit mapping, and Stage II (Reasoning Enhancement) addresses the generation-side gap by optimizing for reasoning-aware rewards that push the editor toward edits that are both correct in isolation and useful for downstream reasoning.

How ETCHR Positions Itself Relative to Existing Work

ETCHR occupies a deliberate third point in the design space, distinct from both tool-based methods and unified models.

Versus tool-based methods: ETCHR replaces the deterministic renderer with a question-conditioned image editor whose transformation space is continuous rather than discrete. This means ETCHR is not confined to drawing boxes and cropping regions; it can trace paths, restore shuffled images, and synthesize novel viewpoints—transformations that lie outside the action vocabulary of any renderer. The paper's results bear this out: on Logic, Jigsaw, and 3D tasks where tool-based methods are marked inapplicable (†), ETCHR achieves substantial improvements over the unaided baseline (+11.0 on Maze with Qwen3-VL-8B, +16.1 on Jigsaw, +8.2 on 3D in Table 1). Conversely, ETCHR keeps the understanding model frozen—the editor is trained independently and plugged in at inference without any fine-tuning of the downstream MLLM. This means a single trained editor can serve any open- or closed-source understanding model, avoiding the per-task model variants that tool-based methods require.

Versus unified models: ETCHR keeps understanding and generation in separate specialist models, sidestepping the optimization tension that degrades both capabilities. The editor is trained on reasoning-aware objectives without touching the understanding MLLM, and edit fidelity is preserved because the editor is not asked to also serve as the answer producer. The quantitative evidence is the consistent improvement over unaided baselines across all three understanding backbones tested (+4.82 with Qwen3-VL-8B, +5.47 with Gemini-3.1-Flash-Lite, +4.61 with Kimi K2.5 in Table 1), contrasting with unified models that often perform worse than the unaided baseline (e.g., Bagel-Zebra-CoT at 38.27 vs. Qwen3-VL-8B at 55.95).

Versus off-the-shelf editors augmented with prompt enhancement: The paper explicitly tests this ablation. Table 2 compares ETCHR against Nano Banana 2 (a closed-source frontier editor) used as the visual-thought provider with the same prompt-enhancement strategy. Both editors improve over the no-edit baseline, confirming that question-conditioned edits are useful even from a generic editor. However, ETCHR shows larger margins on Logic, Jigsaw, and 3D—tasks where edits must encode task structure rather than simply re-render local regions. This validates the hypothesis that reasoning-aware training, not editor scale, drives guidance quality on structural tasks.

A novel addition: edit verification. Going beyond all three prior paradigms, ETCHR incorporates a reflective inference step—Edit-Verify-Reason—that lets the understanding model reject unreliable edits before they enter the reasoning trajectory. This addresses a blind spot the paper identifies across all prior "think with images" work: neither tool-based methods, nor unified models, nor off-the-shelf editors verify whether the intermediate edit is actually correct before reasoning forward from it. An erroneous edit (a mis-localized bounding box, a corrupted maze path, an implausible novel view) can silently mislead the downstream model, as documented by Huang et al. (2023) in the text-only self-correction setting. The verification step is asymmetric in its cost-benefit profile: a correct edit gives decisive visual guidance, while an incorrect one introduces structured confounders that MLLMs struggle to override. ETCHR's verification mechanism absorbs this asymmetry by falling back to the original image when verification fails, ensuring that the system is at least no worse than the unaided baseline on any individual question.

The Conceptual Framework: Two Gaps as a Unifying Diagnosis

The paper's contribution is not merely the ETCHR system but the diagnostic framework that motivates it. By decomposing reasoning-aware editing into a language-side capability (inferring the transformation from the question) and a generation-side capability (rendering it faithfully), the paper provides a vocabulary for analyzing why prior approaches fail and what a solution must achieve. The language-side gap explains why tool-based methods are task-specific (each task requires learning a different mapping from questions to actions) and why unified models underperform (the mapping is learned implicitly through interleaved training, without explicit supervision on the question-to-edit correspondence). The generation-side gap explains why unified models produce noisy intermediates (their generative heads lack specialist fidelity) and why off-the-shelf editors fail on structured tasks (their DiT decoders cannot sustain multi-step spatial reasoning). ETCHR's two-stage design—imitation followed by enhancement—directly targets each gap, and the ablations in Section 4.2 confirm that both stages contribute and that neither alone suffices.

This diagnostic framework is significant beyond the specific ETCHR instantiation because it suggests a general template for building reasoning-aware generation modules: (1) identify the language-side and generation-side capability gaps through targeted probes, (2) close the language-side gap through supervised imitation on question-conditioned trajectories, (3) close the generation-side gap through reinforcement learning with task-aware rewards that go beyond visual plausibility, and (4) add a verification step that prevents low-quality outputs from contaminating downstream reasoning. Whether this template generalizes to other modalities (audio, video, 3D) or other reasoning tasks (mathematical diagram generation, scientific figure annotation) is an open question that the paper does not address but that its framework naturally suggests.

3. Technical Approach

3.1 Reader Orientation

This is primarily a systems-building paper that constructs ETCHR, a question-conditioned image editor fine-tuned to produce intermediate visual aids that help downstream MLLMs answer questions they would otherwise get wrong. The core idea is that a dedicated specialist editor, trained with reasoning-aware objectives and decoupled from the understanding model, can serve as a general-purpose visual reasoning assistant across diverse tasks—fine-grained perception, chart reading, maze solving, jigsaw restoration, and 3D viewpoint transformation—without ever touching the downstream model's weights.

3.2 Big-Picture Architecture (Diagram in Words)

The system has four major components operating in two phases (training and inference):

  1. Base Image Editor (FLUX.2-klein-base-9B) — a large diffusion transformer (DiT) that takes an input image and a text prompt, and produces an edited output image. Initially pretrained as an instruction-following tool (it expects explicit commands like "draw a red box around the trash can"), it serves as the raw generative engine that ETCHR repurposes.

  2. Task-Level Meta-Prompts — short fixed strings (e.g., "Draw a red box to mark the important regions for this question in the figure") prepended to each question at both training and inference time. They act as soft task routers that partition the editor's latent space into task-specific manifolds, suppressing gradient conflicts across families during multi-task fine-tuning.

  3. Understanding MLLM (Qwen3-VL-8B, Gemini-3.1-Flash-Lite, or Kimi K2.5) — a frozen, off-the-shelf multimodal model that serves triple duty: (a) during RL training, it provides the Editing Guidance Reward by answering questions given the edited image; (b) it serves as a VLM-as-Judge to provide the Editing Correctness Reward by assessing whether an edit contains the needed visual information; (c) at inference, it performs the Edit-Verify-Reason pipeline—verifying edit reliability, then reasoning from the verified (or original) image to produce the final answer.

  4. Training Data — a curated corpus of $\{i, i_{gt}, q, a\}$ tuples spanning five reasoning families, where $i$ is the original image, $i_{gt}$ is a ground-truth edited image that surfaces the evidence needed to answer $q$, and $a$ is the ground-truth answer. This corpus provides the supervised signal for Stage I and the filtered subset for Stage II.

Information flow at training: Training data is organized by task family → a task-level meta-prompt is prepended to the question → the DiT is fine-tuned with LoRA to map $(i, q)$ to $i_{gt}$ (Stage I) → the resulting checkpoint generates candidate edits for RL → the frozen understanding MLLM scores each edit with two rewards (guidance: does it lead to the correct answer? correctness: does it contain the right visual information?) → Pref-GRPO updates the DiT to prefer edits with higher combined reward (Stage II).

Information flow at inference: A question arrives → the task-level meta-prompt is prepended → the trained editor produces $i_{edit}$ → the understanding MLLM verifies whether $i_{edit}$ reliably contains the needed visual information → if yes, the MLLM conditions on both $i$ and $i_{edit}$ to produce the answer; if no, it falls back to $i$ alone.

3.3 Roadmap for the Deep Dive

  • First, the formal problem statement (Section 3.1 of the paper): what exactly is being learned, what are the inputs and outputs, and what defines success. This establishes the mathematical scaffolding for everything that follows.
  • Second, the training data construction (Section 3.2): how the five-family corpus is built, why task diversity matters, and how the ground-truth edited images $i_{gt}$ are synthesized. Data is the foundation of the imitation stage, so understanding what the model is imitating is prerequisite.
  • Third, Stage I—Reasoning Imitation via SFT (Section 3.2): how the base editor is converted from an instruction-follower to a question-conditioned editor, including the LoRA configuration, the task-level prompt enhancement mechanism, and what the model actually learns.
  • Fourth, Stage II—Reasoning Enhancement via RL (Section 3.3): the two reward signals (Editing Guidance and Editing Correctness), why each alone is insufficient, how they are combined, the Pref-GRPO optimization procedure, and the filter $\mathcal{C}$ that selects which training instances enter the RL phase.
  • Fifth, the Edit-Verify-Reason inference procedure (Section 3.4): the three-step pipeline, the verification prompt design, the fallback mechanism, and why verification is asymmetric in its cost-benefit profile.

3.4 Detailed, Sentence-Based Technical Breakdown

This is a training-recipe paper whose core idea is that a specialist image editor can be repurposed as a general visual reasoning assistant through two targeted training stages: supervised fine-tuning to teach question-to-edit mapping (closing the language-side gap), followed by reinforcement learning with reasoning-aware rewards to improve edit quality under increasing reasoning depth (closing the generation-side gap). The editor is architecturally decoupled from the understanding model, so a single trained editor plugs into any MLLM at inference without further fine-tuning.

Formal Problem Statement: Reasoning-Aware Editing as Question-Conditioned Image-to-Image Translation

The paper casts the entire system as learning a function $\mathcal{E}$ that maps an input image $i$ and a natural-language question $q$ to an edited image $i_{edit}$:

iedit=E(i,q)i_{edit} = \mathcal{E}(i, q)

where $i$ is the original input image (a photograph, chart, maze grid, shuffled jigsaw, or scene frame), $q$ is a natural-language question about that image (e.g., "Is the beer bottle silver?", "What was the unemployment rate in New Hampshire in 2020?", "Find the shortest path from start to goal"), and $i_{edit}$ is the edited output image that surfaces the visual evidence needed to answer $q$.

What this function computes: given a raw image and an abstract question, $\mathcal{E}$ must perform two sub-computations that the paper's Section 2 analysis shows off-the-shelf editors lack. First, it must infer what visual transformation would help answer the question—this is the language-side reasoning: mapping "Is the beer bottle silver?" to "draw a bounding box around the beer bottle," or mapping a maze navigation question to "trace the shortest path in blue." Second, it must render that transformation faithfully—this is the generation-side reasoning: actually drawing the bounding box at the correct coordinates, or tracing a continuous path through the maze without crossing walls. The output $i_{edit}$ is therefore not merely a visually plausible image but a task-specific visual aid whose quality is measured by whether it enables a downstream model $\mathcal{M}$ to answer correctly.

What defines success: a useful edit is one that flips the downstream model's answer from incorrect to correct. Formally, given a frozen understanding model $\mathcal{M}$ and ground-truth answer $a$, an edit $i_{edit}$ is useful if:

M(i,q)≠abutM(i,iedit,q)=a\mathcal{M}(i, q) \neq a \quad \text{but} \quad \mathcal{M}(i, i_{edit}, q) = a

In words: the model gets the question wrong when shown only the original image, but gets it right when shown both the original and the edited image. This asymmetry—the edit must enable correctness that was previously unattainable—is what makes the task challenging. The editor is not asked to produce a visually pleasing image; it is asked to produce an image that changes the downstream model's answer, which means it must understand both what evidence the model needs and how to render that evidence in a form the model can exploit.

What alternatives would have been wrong: a weaker definition of success would be $\mathcal{M}(i, i_{edit}, q) = a$ without the precondition $\mathcal{M}(i, q) \neq a$. This would admit edits that are redundant—if the model can already answer correctly from the original image, then any edit, even a meaningless one, would satisfy the condition. The precondition filters out such cases, ensuring that the editor is trained and evaluated only on instances where the edit genuinely adds value. This is formalized as the filter $\mathcal{C}$ in Equation (1), which the paper uses to select instances for the RL stage.

The role of ground-truth edits: each training instance also includes a ground-truth edited image $i_{gt}$ that serves as the target for supervised fine-tuning. For fine-grained perception tasks, $i_{gt}$ is $i$ with bounding boxes overlaid on the relevant referents (synthesized from annotated bounding box coordinates). For chart understanding, the same overlay procedure is applied to chart regions containing the answer. For logic reasoning, $i_{gt}$ overlays the correct traversal path on the maze or frozen lake grid. For jigsaw reasoning, $i_{gt}$ is the correctly restored image. For 3D understanding, $i_{gt}$ is a frame from the same video captured from a different camera pose (the one that makes the spatial relation in $q$ visually apparent). These ground-truth edits provide the supervised signal in Stage I and serve as the upper-bound reference for defining useful edits in the RL filter.

Training Data Construction: Five Reasoning Families with Synthesized Ground-Truth Edits

The supervised fine-tuning corpus is not a single homogeneous dataset but a deliberate union of five reasoning families, each exercising a distinct class of visual transformations. The paper argues that this diversity is essential: if the editor were trained only on, say, bounding-box overlay tasks, it would collapse onto a single edit template and fail to acquire the meta-capability of inferring which kind of transformation each question demands. The five families and their data sources are:

Fine-grained perception uses the V* training dataset (Wu & Xie, 2024), covering both V*-GQA and V*-COCO subsets, where each question asks about a specific small or easily missed object in a high-resolution natural image (e.g., "Is the beer bottle silver?", "What color is the umbrella on the left?"). The ground-truth edited image $i_{gt}$ is synthesized by rendering the annotated bounding boxes directly onto $i$—the relevant object is literally boxed in red. This teaches the editor to perform localization: given a question about a specific referent, draw a box around that referent.

Chart understanding draws from RefChartQA (Vogel et al., 2025), a dataset of chart images paired with questions that require reading specific data points, comparing values across categories, or identifying trends. The ground-truth edit applies the same bounding-box overlay procedure to the chart region containing the answer—for example, boxing the bar corresponding to "New Hampshire, 2020" when asked about the unemployment rate that year. This teaches information grounding: given a question about a structured visual display, highlight the specific visual element that encodes the answer.

Logic reasoning uses an in-house maze corpus where $i$ shows the maze topology (walls as black obstacles, start as a green square, goal as a red square, traversable cells as white) and $i_{gt}$ overlays the correct traversal path in blue. A companion Frozen Lake corpus follows the same template with ice tiles and holes. This teaches algorithmic path-tracing: given a grid with obstacles and start/goal markers, compute and render the valid connecting path. Unlike localization, which requires identifying a static region, path-tracing requires multi-step spatial inference—the editor must understand connectivity, avoid obstacles, and maintain a continuous trajectory. The paper's Section 2 analysis shows this is precisely where off-the-shelf editors fail: even when given the exact path as a text prompt, edit correctness degrades with path length (Fig. 2b).

Jigsaw reasoning samples from Spatial-SSRL (Liu et al., 2025), taking $i$ as a spatially shuffled image (tiles permuted according to a known shuffling strategy) and $i_{gt}$ as its correctly restored version. This teaches global geometric reorganization: given a scrambled image, recover the coherent spatial arrangement. This is qualitatively different from localization or path-tracing because the transformation is holistic—every pixel must move—rather than additive (overlaying annotations on an otherwise unchanged image).

3D understanding uses DL3DV-10K (Ling et al., 2024), which contains videos of real-world 3D scenes together with per-frame camera poses. The paper samples $i$ and $i_{gt}$ from the same video but different viewpoints, and synthesizes $q$ and $a$ from the camera extrinsics. For example, $i$ might show a street scene from a front-facing view, $i_{gt}$ shows the same scene from behind, and $q$ asks "From the perspective of the woman in green, where is the woman in red located?" This teaches viewpoint transformation: given a question that requires reasoning about spatial relations from a different perspective, render that perspective. This is the most ambitious transformation class because it requires the editor to synthesize genuinely novel visual content—pixels that were not present in the original image—while maintaining 3D consistency.

Scale and curation: the paper does not report the exact number of training instances per family, but states that the SFT corpus is "large-scale" and partitioned across the five families. For the RL stage, the paper curates a more selective set by sampling 2,000 instances from each family in the SFT corpus, yielding 10,000 total pairs, and then applying the filter $\mathcal{C}$ (Equation 1) to retain only those where the understanding model fails on the raw image but succeeds with the ground-truth edit. The paper does not report what fraction of the 10,000 survive this filter, but the logic is clear: instances where the model already succeeds on the raw image provide no training signal (the editor's output would be redundant), and instances where even the ground-truth edit doesn't help provide no verifiable upper bound (the reward landscape would be flat). The filter ensures that every retained instance has a nonzero reward ceiling, yielding a denser reward landscape and lower-variance policy gradients during RL.

Task-Level Prompt Enhancement: Soft Task Routing Without Architectural Cost

A critical design choice is how the editor knows which kind of edit to perform for a given question. The naive approach—feeding the raw question $q$ alone as the prompt—causes severe cross-task interference. The editor's latent space, shaped by explicit instruction-following pretraining, lacks the priors to disambiguate whether "Is the beer bottle silver?" demands a bounding box (perception), a chart region highlight (if $i$ were a chart—it isn't, but the model doesn't know that a priori), a path trace, or a viewpoint change. The paper describes this as the editor being unable to "disambiguate whether a question demands localization, path-tracing, rearrangement, or viewpoint transformation" without additional conditioning.

The solution is a task-level meta-prompt $p_{task}$ prepended to every question. The specific prompts (provided in Appendix A) are:

  • Fine-grained Perception: "Draw a red box to mark the important regions for this question in the figure."
  • Chart Understanding: "Draw a red box to mark the important regions for this question in the figure." (identical wording, reflecting that both tasks use the same visual operation—bounding box overlay—but on different image types)
  • Logic (Maze/Frozen Lake): "Draw the shortest path of the maze in blue."
  • Jigsaw: "Draw the original image after restoring this jigsaw puzzle task."
  • 3D Understanding: "Imagine a new perspective of the original image that helps answer the question."

What this mechanism does: at training time, $p_{task}$ acts as a soft task router. When the DiT processes the concatenated prompt $[p_{task}, q]$, the task-level prefix evokes the editing modality appropriate to that family. The LoRA weights, fine-tuned on all five families simultaneously, learn to partition their update space so that gradients from perception tasks (which teach "draw a box around the referent") do not interfere with gradients from jigsaw tasks (which teach "rearrange the tiles into the correct configuration"). The paper frames this as "suppressing gradient conflicts across families." Concretely, the first few tokens of the prompt (the task-level prefix) push the DiT's internal representations into a task-specific manifold—a region of the latent space where the model's behavior is specialized for that transformation class—before the question-specific tokens begin influencing the output.

What this mechanism does NOT do: importantly, $p_{task}$ is not per-instance or model-specific. It is a fixed string chosen once per task family. This means the editor needs no access to the understanding model's internal representations, no per-instance instructions, and no runtime communication with the downstream MLLM. This is what enables the training-free plug-and-play deployment: at inference, the same $p_{task}$ is prepended to the question regardless of which understanding model (Qwen3-VL-8B, Gemini-3.1-Flash-Lite, Kimi K2.5) will consume the output. The editor operates autonomously, conditioned only on the question and the task-level prefix.

Why this design over alternatives: an alternative would be to train the editor without task-level prompts, relying on the question text alone to implicitly convey the task type. This is what the paper's Section 2 analysis tests and finds insufficient: off-the-shelf editors fed raw questions perform significantly worse than when fed concrete instructions (Fig. 2a). Another alternative would be to have the understanding model generate per-instance edit instructions (as in tool-based methods), but this would require the understanding model to be fine-tuned for instruction generation—violating the decoupling desideratum—and would introduce a serial dependency where the editor's output quality is bounded by the understanding model's instruction quality. The task-level prompt is a compromise: it provides enough task disambiguation to prevent gradient conflict during multi-task training, while remaining simple enough that it adds no architectural cost and requires no per-instance communication between modules.

Stage I: Reasoning Imitation via Supervised Fine-Tuning (SFT)

Stage I converts the base editor from a passive instruction-follower into a question-conditioned editor. The objective is straightforward: given a training tuple $\{i, i_{gt}, q, a\}$, the DiT is fine-tuned to map $(i, q)$ to $i_{gt}$ using a standard image reconstruction loss.

The loss function is the mean squared error (MSE) between the ground-truth edited image and the model's output, applied in the latent space of the VAE:

LSFT=E(i,igt,q)∼DSFT[∥VAE(igt)−DiT(VAE(i),Enc([ptask,q]))∥22]\mathcal{L}_{SFT} = \mathbb{E}_{(i, i_{gt}, q) \sim \mathcal{D}_{SFT}} \left[ \| \text{VAE}(i_{gt}) - \text{DiT}(\text{VAE}(i), \text{Enc}([p_{task}, q])) \|_2^2 \right]

where $\text{VAE}(\cdot)$ denotes the frozen variational autoencoder that compresses images into a lower-dimensional latent representation, $\text{DiT}(\cdot, \cdot)$ is the diffusion transformer that takes a noisy latent and a text conditioning signal to predict the clean latent, and $\text{Enc}(\cdot)$ is the frozen text encoder (the MLLM-style encoder of FLUX.2-klein-base-9B) that embeds the concatenated task-prompt and question into a conditioning vector.

What this loss computes: at each training step, the input image $i$ is encoded into a latent representation by the frozen VAE. Gaussian noise is added to this latent at a randomly sampled timestep in the diffusion process. The DiT receives the noisy latent and the text embedding of $[p_{task}, q]$, and predicts the noise that was added. The MSE between the predicted noise and the actual added noise is the training signal. This is the standard diffusion denoising objective, identical to how the base FLUX.2-klein-base-9B was originally trained, but with the text conditioning changed from explicit edit instructions to question-conditioned task prompts.

What the model learns: by minimizing this loss across the five-family corpus, the editor learns a mapping from abstract questions to concrete visual transformations. Crucially, it learns this without ever being given explicit edit instructions at training time—the only input is $[p_{task}, q]$, never "draw a red box around the beer bottle." The ground-truth image $i_{gt}$ provides the supervisory signal for what the output should look like, and the model must infer the implicit mapping from question semantics to visual operations. For example, after seeing thousands of perception instances where questions about specific objects are paired with ground-truth images showing those objects boxed, the model learns that the phrase "Is the X Y?" in a perception context implies "draw a box around X so its color/attribute can be verified."

LoRA configuration: the paper uses Low-Rank Adaptation (LoRA) rather than full fine-tuning. This is a practical choice driven by the scale of the base model (FLUX.2-klein-base-9B has 9 billion parameters in its DiT alone). LoRA freezes all pre-trained weights and inserts trainable low-rank decomposition matrices into each linear layer. The key hyperparameter is the rank $r$, which controls the capacity of the adaptation. The paper uses a notably large rank:

"We apply a large LoRA rank ($r = 768$) to all linear layers in the DiT blocks to provide sufficient capacity for multi-task learning."

A rank of 768 is substantially larger than typical LoRA configurations (which often use $r = 8$ to $r = 64$). The justification is multi-task capacity: the model must learn five qualitatively different transformation classes simultaneously (localization, path-tracing, rearrangement, viewpoint synthesis), and a small rank would create a bottleneck where different task-specific update directions compete for the same limited subspace. The large rank provides enough degrees of freedom for each task family to occupy a distinct region of the update space, reducing interference.

Other training hyperparameters: the SFT runs for 1 epoch with learning rate $lr = 1 \times 10^{-4}$, classifier-free guidance scale $= 1$, and inference steps $= 30$ (relevant for evaluation, not training). The framework is built on DiffSynth-Studio. The VAE and text encoder are kept frozen throughout—only the DiT weights (via LoRA) are updated. This preserves the base model's generative fidelity while adapting its conditioning interface.

Why supervised fine-tuning, not RL from scratch: Stage I uses imitation learning rather than jumping directly to RL for two reasons. First, the language-side gap (Fig. 2a) is fundamentally about learning what to do—the editor needs to acquire the question-to-edit mapping, which is a supervised learning problem with clear targets ($i_{gt}$). RL would be inefficient for this because the reward signal is sparse (the model would need to randomly produce a correct edit to receive positive feedback), and the exploration space of possible image edits is astronomically large. Second, SFT provides a strong initialization for RL: the model enters Stage II already knowing what kind of edit to produce for each task, and RL only needs to refine the quality of those edits. This two-stage curriculum—imitation for capability acquisition, RL for capability refinement—is a standard recipe in LLM training (e.g., SFT followed by RLHF) that the paper adapts to the image editing domain.

A note on what Stage I does NOT solve: the SFT checkpoint can produce question-conditioned edits across all five families, but those edits still suffer from the generation-side gap (Fig. 2b). When the question requires multi-step reasoning during the diffusion process—tracing a long maze path, restoring a complex jigsaw, synthesizing a geometrically consistent novel view—the SFT model's edits may be approximately correct but contain errors (disconnected path segments, misaligned tiles, implausible perspective projections). These errors, even if small, can mislead the downstream understanding model. This is the motivation for Stage II.

Stage II: Reasoning Enhancement via Reinforcement Learning

Stage II refines the SFT checkpoint using reinforcement learning with rewards that directly measure reasoning utility rather than visual plausibility. The core insight is that an edit can look correct (a path appears to connect start to goal, a jigsaw looks coherent) while still being reasoning-useless (the path crosses a wall at one cell, a jigsaw tile is in the wrong position but the local texture blends in). Standard image quality metrics (FID, LPIPS, CLIP score) cannot distinguish these cases because they measure perceptual similarity, not task-specific correctness. The RL stage therefore uses VLM-derived rewards that probe two complementary aspects of edit quality: downstream answer accuracy and isolated edit correctness.

The RL Data Filter: Selecting Instances with Nonzero Improvement Potential

Before training, the paper filters the RL dataset to retain only instances where the editor has room to provide value. The filter $\mathcal{C}$ is defined as:

C(i,igt,q,a)=1[M(i,q)≠a∧M(i,igt,q)=a]\mathcal{C}(i, i_{gt}, q, a) = \mathbf{1}[\mathcal{M}(i, q) \neq a \land \mathcal{M}(i, i_{gt}, q) = a]

where $\mathcal{M}$ is the frozen understanding model (Qwen3-VL-8B for the main experiments), $i$ is the original image, $i_{gt}$ is the ground-truth edited image, $q$ is the question, $a$ is the ground-truth answer, and $\mathbf{1}[\cdot]$ is the indicator function returning 1 if the condition holds and 0 otherwise.

What this filter computes: for each candidate instance in the RL set, it checks two conditions. The first clause, $\mathcal{M}(i, q) \neq a$, verifies that the understanding model cannot answer the question from the original image alone. If the model already answers correctly, the instance is discarded—any edit, even a perfect one, would provide zero marginal value (the answer wouldn't change), so gradients from this instance would be noise. The second clause, $\mathcal{M}(i, i_{gt}, q) = a$, verifies that the ground-truth edit would enable a correct answer. If even the ground-truth doesn't help, the instance is discarded—there is no verifiable upper bound, meaning the reward landscape has no positive signal, and policy gradients would have high variance with no direction.

Why this filter matters: the filter $\mathcal{C}$ ensures two properties of the RL training data. First, non-redundancy: every instance has a positive reward ceiling (the ground-truth edit achieves $r_{guide} = 1$), so the model has a clear target. Second, non-triviality: every instance requires the model to produce an edit that is better than having no edit at all, since the baseline $\mathcal{M}(i, q)$ performance is zero (incorrect). This eliminates the "easy instance" problem where the reward is 1 regardless of edit quality because the model would have answered correctly anyway. The paper curates the RL set by sampling 2,000 instances from each of the five SFT families and then applying $\mathcal{C}$, though the survival rate is not reported.

Reward Design: Two Complementary VLM-Derived Signals

The central challenge of Stage II is that edit quality admits no direct scalar metric. There is no ground-truth function that, given $i_{edit}$, outputs a number representing "how useful this edit is for reasoning." The paper therefore infers edit quality through two proxy rewards, each with distinct strengths and blind spots, combined so they compensate for each other.

Editing Guidance Reward ($r_{guide}$): this reward measures whether the edit actually helps the downstream model answer correctly. It is defined as:

rguide(i,iedit,q,a)=1[M(i,iedit,q)=a]r_{guide}(i, i_{edit}, q, a) = \mathbf{1}[\mathcal{M}(i, i_{edit}, q) = a]

where $\mathcal{M}$ is the same frozen understanding model used in the filter $\mathcal{C}$, $i$ is the original image, $i_{edit}$ is the editor's output, $q$ is the question, and $a$ is the ground-truth answer.

What this reward computes: it is 1 if the understanding model, when shown both the original image and the edited image, produces the correct answer; 0 otherwise. In operational terms, the editor generates $i_{edit}$, the understanding model is queried with $(i, i_{edit}, q)$, and the output string is compared against $a$ using the task's grading function. This is the most faithful reward because it directly optimizes the end-to-end objective: produce edits that cause correct answers.

The blind spot of $r_{guide}$: its fidelity is bounded by $\mathcal{M}$'s capability ceiling. On easy questions, $\mathcal{M}$ might answer correctly even with a partially erroneous edit (e.g., a bounding box that is slightly misaligned but still covers the right object), giving a reward of 1 when the edit quality is suboptimal. This creates a "reward hack" where the model learns to produce edits that are just good enough to trigger a correct answer from a lenient judge, rather than edits that are genuinely correct. On hard questions, $\mathcal{M}$ might fail even with a perfect edit (e.g., the edit correctly traces the maze path but $\mathcal{M}$ cannot parse the path coordinates), giving a reward of 0 when the edit is actually flawless. This creates a "false negative" where good edits are penalized because the downstream model is the bottleneck, not the editor.

Editing Correctness Reward ($r_{correct}$): this reward addresses the capability ceiling problem by evaluating the edit in isolation, decoupled from the downstream reasoning task. It is defined as:

rcorrect(i,iedit,q)=1[J(i,iedit,q)=1]r_{correct}(i, i_{edit}, q) = \mathbf{1}[\mathcal{J}(i, i_{edit}, q) = 1]

where $\mathcal{J}$ is a VLM-as-Judge (also Qwen3-VL-8B, the same architecture as $\mathcal{M}$ but prompted differently) that assesses whether $i_{edit}$ contains the visual information needed to answer $q$, without actually solving the task.

What this reward computes: the judge VLM is shown the original image, the edited image, and the question, and asked a binary verification question (the specific prompts are in Appendix A). For perception tasks: "Please judge whether the information relevant to solving this problem is marked with a red box in the picture. If the red box contains valid information, reply with 1; if there is no red box in the picture, or the area enclosed by the red box does not contain valid information, reply with 0." For maze tasks: "Please determine whether the following image contains a valid maze path: the middle path (blue) connects the starting point (green) to the destination (red), is continuous in four directions (up, down, left, right) with no diagonal movement allowed, and no black obstacles or white path tiles have been altered..." For 3D tasks: "Please judge whether you can see the objects mentioned in the question from the perspective of the second image." The judge's role is to verify that the edit surfaces the right evidence, not to determine whether that evidence leads to the right answer.

The blind spot of $r_{correct}$: the judge is itself imperfect. It may accept a plausible-but-uninformative edit—for example, a bounding box that covers a large region containing the target object along with several distractors, which the judge deems "contains valid information" but which is too coarse to help $\mathcal{M}$ pinpoint the answer. This is the "judge noise" problem: $\mathcal{J}$ can be fooled by edits that look helpful but aren't. Conversely, $\mathcal{J}$ may reject a correct edit due to superficial visual differences—for example, a maze path that is technically continuous but rendered with a slightly different shade of blue than expected, causing the judge to flag it as invalid.

Why the two rewards are complementary: $r_{guide}$ is faithful (it measures the actual downstream outcome) but ceiling-bound (it cannot distinguish good edits from perfect edits when $\mathcal{M}$ is already correct, nor good edits from bad edits when $\mathcal{M}$ is hopelessly wrong). $r_{correct}$ is ceiling-lifting (it can recognize a correct edit even when $\mathcal{M}$ cannot solve the task, and can reject a flawed edit even when $\mathcal{M}$ guesses correctly) but judge-noisy (it introduces its own errors). The combination means that when $r_{guide}$ is unreliable (because $\mathcal{M}$ is either too lenient or too strict), $r_{correct}$ provides a stabilizing signal, and vice versa. This is the classic bias-variance tradeoff in reward design: combining a low-bias, high-variance signal ($r_{guide}$, which directly measures the objective but is noisy due to $\mathcal{M}$'s inconsistency) with a higher-bias, lower-variance signal ($r_{correct}$, which measures a proxy but with different noise characteristics) yields a composite reward with better overall properties than either alone.

Reward Combination and Variance Reduction

The two rewards are combined as a convex sum:

R(i,iedit,q,a)=α⋅rguide+β⋅rcorrect\mathcal{R}(i, i_{edit}, q, a) = \alpha \cdot r_{guide} + \beta \cdot r_{correct}

with $\alpha = \beta = 0.5$ by default, meaning equal weight to both signals.

What this combined reward computes: a scalar between 0 and 1 representing the overall quality of $i_{edit}$. If both rewards are 1, the edit is both correct in isolation and useful for downstream reasoning—the ideal case. If both are 0, the edit is neither correct nor useful—the worst case. The mixed cases (1,0) and (0,1) correspond to edits that satisfy one criterion but not the other: (1,0) means the edit looks correct to the judge but doesn't help $\mathcal{M}$, suggesting the judge was too lenient or $\mathcal{M}$ has a capability gap; (0,1) means the edit helps $\mathcal{M}$ answer correctly but the judge deems it flawed, suggesting the judge was too strict or $\mathcal{M}$ is answering correctly for the wrong reason. The equal weighting means the model receives partial credit for edits that satisfy one criterion, providing gradient signal even when one reward is noisy on a particular instance.

Variance reduction through stochastic decoding: to reduce variance, the paper softens both indicator rewards into empirical probabilities. Instead of querying $\mathcal{M}$ and $\mathcal{J}$ once per edit, the paper queries each with $K$ stochastic decodings (the value of $K$ is not explicitly stated in the main text, but the RL framework uses $G = 8$ rollouts per group—the relationship between $K$ and $G$ is not fully specified). The soft rewards become:

rguide=1K∑k=1K1[Mk(i,iedit,q)=a]andrcorrect=1K∑k=1K1[Jk(i,iedit,q)=1]r_{guide} = \frac{1}{K} \sum_{k=1}^{K} \mathbf{1}[\mathcal{M}_k(i, i_{edit}, q) = a] \quad \text{and} \quad r_{correct} = \frac{1}{K} \sum_{k=1}^{K} \mathbf{1}[\mathcal{J}_k(i, i_{edit}, q) = 1]

where $\mathcal{M}_k$ and $\mathcal{J}_k$ denote the $k$-th stochastic decoding (presumably at nonzero temperature, though the temperature is not specified). This converts binary 0/1 signals into continuous values between 0 and 1, which reduces the variance of the reward estimates and provides finer-grained training signal—an edit that leads to a correct answer in 6 out of 8 decodings receives $r_{guide} = 0.75$, distinguishing it from an edit that succeeds in 1 out of 8 ($r_{guide} = 0.125$), even though both would receive $r_{guide} = 1$ and $r_{guide} = 0$ respectively under hard decoding.

Why this weighting scheme: the paper does not ablate different $\alpha, \beta$ values, so the choice of 0.5/0.5 is a reasonable default rather than an empirically optimized hyperparameter. The ablation in Table 5 tests the extremes—$\alpha = 1, \beta = 0$ (Guidance only) and $\alpha = 0, \beta = 1$ (Correctness only)—and shows that the combined reward matches or exceeds either alone across all task families, validating that the two signals are indeed complementary and that equal weighting is at least not harmful. An interesting open question is whether task-specific weighting (e.g., higher $\alpha$ on Logic where $\mathcal{M}$ has capacity and $r_{guide}$ is reliable, higher $\beta$ on 3D where $\mathcal{M}$ is bottlenecked and $r_{guide}$ is noisy) would yield further gains.

Optimization: Pref-GRPO with Pairwise Preference Rewards

The RL stage uses Pref-GRPO (Wang et al., 2025), a pairwise-preference extension of Group Relative Policy Optimization (GRPO; Shao et al., 2024). Standard GRPO computes advantages within a group of rollouts by normalizing rewards relative to the group mean, which amplifies reward variance. Pref-GRPO replaces absolute rewards with pairwise win rates, which the paper argues further absorbs reward noise and stabilizes training.

Rollout group construction: for each training instance $(i, q, a)$, the editor generates a group of $G = 8$ candidate edited images $\{i^j_{edit}\}_{j=1}^{G}$ by sampling from the SFT checkpoint (with stochastic noise from the diffusion process). These 8 images represent different possible edits for the same $(i, q)$ pair—they may vary in where the bounding box is placed, how the path is traced, or what viewpoint is synthesized.

Pairwise win rate computation: for each image $m$ in the group, its win rate $w_m$ is the fraction of pairwise comparisons against other group members where it has a higher combined reward:

wm=1G−1∑n≠m1[R(i,ieditm,q,a)>R(i,ieditn,q,a)]w_m = \frac{1}{G - 1} \sum_{n \neq m} \mathbf{1}[\mathcal{R}(i, i^m_{edit}, q, a) > \mathcal{R}(i, i^n_{edit}, q, a)]

where $\mathcal{R}$ is the combined reward from Equation (4).

What this computes: for image $m$, the win rate is the proportion of the other 7 images in the group that it "beats" under the combined reward. If image $m$ has the highest reward among all 8, its win rate is 1.0 (it beats all 7 others). If it has the lowest reward, its win rate is 0.0. If it's in the middle, it beats some and loses to others, yielding a fractional win rate. This converts absolute reward values (which may be noisy due to VLM inconsistency) into relative rankings (which are more stable, since systematic judge biases—e.g., always rating perception edits higher than chart edits—affect all images in the group equally and cancel out in the pairwise comparison).

Advantage normalization: the win rates are then normalized within the group to produce the advantage $\hat{A}_m$:

A^m=wm−mean({wj}j=1G)std({wj}j=1G)\hat{A}_m = \frac{w_m - \text{mean}(\{w_j\}_{j=1}^G)}{\text{std}(\{w_j\}_{j=1}^G)}

where $\text{mean}(\{w_j\})$ is the average win rate across the 8 images and $\text{std}(\{w_j\})$ is the standard deviation.

What this computes: the advantage represents how much better (or worse) image $m$ is compared to the average image in its rollout group, in units of standard deviation. A positive advantage means the image is above average; a negative advantage means below average. This is a standard reinforcement learning trick (analogous to advantage normalization in PPO) that reduces variance by removing the baseline—the absolute level of reward across the group is factored out, leaving only the relative differences that carry gradient information.

Why Pref-GRPO over standard GRPO: the paper argues that "replacing absolute reward with pairwise preference... amplifies reward variance and absorbs reward noise." Standard GRPO would compute advantages directly from the absolute rewards $\mathcal{R}(i, i^j_{edit}, q, a)$, normalizing them within the group. The problem is that if the reward scale is inconsistent across instances—for example, perception tasks might have average $\mathcal{R} \approx 0.7$ while 3D tasks have average $\mathcal{R} \approx 0.3$—then a reward of 0.5 is "good" on 3D but "bad" on perception, and the policy gradient would receive inconsistent signal. The pairwise ranking is invariant to such shifts: a reward of 0.5 beats a reward of 0.3 regardless of the task's absolute scale. Additionally, if both rewards $r_{guide}$ and $r_{correct}$ are systematically inflated (e.g., the judge is lenient on a particular image type), the pairwise comparison still correctly identifies relative quality differences within the group.

LoRA configuration for RL: the RL stage uses a separate LoRA adaptation with rank $r = 128$ and alpha $\alpha = 128$ (alpha is the LoRA scaling factor, distinct from the reward weight $\alpha$ in Equation 4), applied to the DiT weights. The learning rate is $lr = 1 \times 10^{-4}$ and the group size $G = 8$. Note that the rank is smaller than the SFT stage's $r = 768$, suggesting the RL fine-tuning requires less capacity—it is refining an already-capable model rather than learning new capabilities from scratch.

What the RL stage optimizes: the policy gradient pushes the DiT to prefer edits that score highly on the combined reward $\mathcal{R}$. Concretely, edits that lead to correct downstream answers AND are judged as visually correct receive high win rates, and the model's weights are updated to increase the probability of generating such edits. Edits that fail both criteria receive low win rates, and the model is updated to avoid them. The key insight is that this optimization goes beyond visual plausibility—the reward is explicitly reasoning-aware, so the model learns to produce edits that are not just visually coherent but genuinely useful for answering questions.

What the paper reports about RL effectiveness: the ablation in Table 4 shows that Stage II RL adds relatively small gains over Stage I SFT alone. With Qwen3-VL-8B as the understanding model, the SFT checkpoint achieves 51.98 average Pass@1, and the RL checkpoint achieves 52.56—a gain of only +0.58 points. The gains are concentrated in Perception (+1.2) and Chart (+0.9), with essentially flat performance on Logic, Jigsaw, and 3D. The paper attributes this to "the sampling granularity of GRPO: Perception and Chart involve localized edits whose group-sampled variants are spatially distinguishable by the reward, whereas Jigsaw and 3D require structural edits, which group sampling appears less able to produce." In other words, for structural tasks, the 8 candidate edits produced by the SFT checkpoint may be too similar to each other (all incorrect in roughly the same way) for the pairwise comparison to provide meaningful ranking signal. This is a significant limitation that the paper acknowledges openly.

Edit-Verify-Reason: Reflective Inference with Fallback

Even after two-stage training, the editor can produce misleading intermediates. The paper therefore adds a reflective inference procedure that verifies edit reliability before use, with a fallback mechanism that ensures the system is at least no worse than the unaided baseline on any individual question.

The three-step pipeline:

Step 1 — Edit: The editor takes the concatenated prompt $[p_{task}, q]$ (the same task-level prefix used during training) together with the input image $i$, and produces a candidate edited image $i_{edit}$. This is a single forward pass through the fine-tuned DiT with the diffusion denoising procedure (30 inference steps, classifier-free guidance scale = 1).

Step 2 — Verify: The understanding model $\mathcal{M}$ performs a binary check on whether $i_{edit}$ contains the visual information needed to answer $q$. Critically, this verification step does NOT produce the answer itself—it only assesses edit reliability. The specific verification prompts are provided in Appendix A, and they mirror the judge prompts used for $r_{correct}$ in the RL stage. For example, for perception tasks: "Please judge whether the information relevant to solving this problem is marked with a red box in the picture. If the red box contains valid information, reply with 1; if there is no red box in the picture, or the area enclosed by the red box does not contain valid information, reply with 0." The understanding model acts as its own verifier, using the same architecture and weights but a different prompt.

Step 3 — Reason: If verification passes (the model outputs 1), $\mathcal{M}$ conditions on both $i$ and $i_{edit}$ to produce the answer:

a=M(i,iedit,q)a = \mathcal{M}(i, i_{edit}, q)

using a task-specific "reason prompt" (Appendix A) that directs the model's attention to the edited image. For perception: "Answer the question based on the two images above. The first image is the original one corresponding to the question, while the second one uses a red box to mark the area containing the key information for the question in the image. Please first focus on the boxed part in the second image, and answer the question based on the corresponding information in the two images." If verification fails (the model outputs 0), the system falls back to the original image alone:

a=M(i,q)a = \mathcal{M}(i, q)

using the standard reasoning prompt without reference to any edited image.

Why verification is critical: the paper argues that "edit errors are asymmetric in cost: a correct edit gives decisive visual guidance, while an incorrect one introduces structured confounders that MLLMs struggle to override." A mis-localized bounding box (covering the wrong object) is worse than no bounding box at all because the model may anchor on the highlighted region and ignore the correct referent elsewhere in the image. An incorrect maze path (crossing a wall) is worse than no path because the model may trust the visual hint and output invalid coordinates. A corrupted jigsaw restoration is worse than the shuffled original because the model loses the ability to reason about which tiles are correct versus incorrect. The verification step absorbs this asymmetry by acting as a gate: only reliably correct edits enter the reasoning trajectory; unreliable edits are discarded in favor of the original image, which at least contains uncorrupted evidence.

The fallback guarantee: because verification failure triggers a fallback to $\mathcal{M}(i, q)$, the system's worst-case performance on any individual question is bounded below by the unaided baseline. It can never be worse than not using ETCHR at all (assuming perfect verification—if verification incorrectly rejects a correct edit, the system misses an opportunity but doesn't introduce errors; if verification incorrectly accepts an incorrect edit, the system may perform worse than baseline). This is an important robustness property that distinguishes ETCHR from unified models and off-the-shelf editors, which have no such fallback and can degrade performance on instances where their edits are harmful.

Ablation results for verification (Table 3): the paper tests the impact of the verification step by comparing "with reflection" versus "without reflection" (where every $i_{edit}$ is passed directly to the reasoning step). With Qwen3-VL-8B, reflection yields consistent gains on Perception (+1.6 points: 79.3 to 80.9) and Chart (+1.8 points: 73.2 to 75.0), where the verifier can reliably flag mis-localized edits and where baseline accuracy is already high (~80%). The gains are smaller on Logic (+0.5 points: 25.5 to 26.0), absent on Jigsaw (13.0 in both conditions), and slightly negative on 3D (−0.3 points: 68.2 to 67.9). The paper's interpretation: on tasks where baseline accuracy is low (Logic, Jigsaw), even imperfect edits are more useful as hints than no edit at all, so verification that rejects some of them reduces the number of useful hints the model receives. This suggests "reflection should be applied selectively, gated by backbone confidence or task family rather than uniformly."

Why verification uses the same model as reasoning: the paper uses $\mathcal{M}$ for both verification and reasoning, just with different prompts. This is a deliberate design choice that avoids introducing a separate verifier model. The cost is that verification is limited by $\mathcal{M}$'s own capability—if $\mathcal{M}$ cannot reliably distinguish correct from incorrect edits (which is likely on hard tasks where it also cannot answer the question), verification provides no benefit. The alternative—training or using a separate, specialized verifier—would add architectural complexity and potentially better verification accuracy, but the paper does not explore this tradeoff.

The complete inference pipeline in operational terms: given a new question $q$ and image $i$ at test time, the system first identifies the task family (this must be known in advance to select $p_{task}$—the paper assumes task labels are available at inference, which is realistic for benchmark evaluation but an open question for deployment). The task-level prefix is prepended to $q$, the editor generates $i_{edit}$ (one forward pass, ~30 diffusion steps), the understanding model verifies $i_{edit}$ (one forward pass with verification prompt), and then either reasons from $(i, i_{edit})$ (if verification passes) or from $i$ alone (if verification fails)—another forward pass. Total inference cost: 1 diffusion generation + 2 LLM forward passes (or 1 if verification fails? No—verification always runs, so it's always at least 2: 1 verification + 1 reasoning). The paper acknowledges the "additional time cost" in the Limitations section, noting that "Image editing incurs a higher temporal cost compared to text-based reasoning; consequently, ETCHR increases the time overhead for samples requiring only a short CoT."

Summary of Design Choices and Their Justifications

  • Dedicated specialist editor over unified model: preserves generative fidelity by keeping understanding and generation in separate models, avoiding the optimization tension documented by UniG2U-Bench. The cost is the need to train and maintain a separate editing model, plus the serial latency of editor → verifier → reasoner.

  • Five-family multi-task training over single-task specialists: forces the editor to acquire a meta-capability of inferring which transformation each question demands, rather than collapsing onto a single edit template. The paper argues this is essential for generalization, though it does not test a single-task baseline to quantify the benefit of multi-task training.

  • Task-level meta-prompts over per-instance instructions: provides enough task disambiguation to suppress gradient conflicts during multi-task training while remaining simple enough to enable plug-and-play deployment with frozen understanding models. The cost is that task family must be known at inference time—the system cannot autonomously determine whether a given question is a perception, chart, logic, jigsaw, or 3D task.

  • Two-stage training (SFT → RL) over end-to-end RL: SFT efficiently closes the language-side gap (learning what to do) using dense supervised signal from $i_{gt}$; RL refines the generation-side gap (learning to do it well) using sparse but reasoning-aware reward. The cost is the complexity of a two-stage pipeline, and the RL stage shows limited gains on structural tasks due to GRPO sampling granularity.

  • Dual-reward design over single reward: combining $r_{guide}$ (faithful but ceiling-bound) and $r_{correct}$ (ceiling-lifting but judge-noisy) compensates for each signal's blind spots. The cost is doubled VLM query cost during RL training (both $\mathcal{M}$ and $\mathcal{J}$ must be run for each candidate edit).

  • Verification with fallback over unconditional edit use: ensures the system is at least no worse than the unaided baseline on any individual question, absorbing the asymmetric cost of edit errors. The cost is potentially discarding useful but imperfect edits on hard tasks where the verifier is unreliable, as the ablation in Table 3 suggests occurs on Logic and 3D.

  • Large LoRA rank ($r = 768$ for SFT, $r = 128$ for RL): provides sufficient capacity for multi-task learning in SFT while using a smaller rank for the more targeted RL refinement. The specific values are empirically chosen; no rank ablation is reported.

  • FLUX.2-klein-base-9B as the base editor: chosen for its MLLM-style text encoder, which provides enough language-side capacity to parse complex questions and support cross-task visual transformations within a single model. The paper does not compare against other base editors (e.g., Qwen-Image-Edit, InstructPix2Pix), so the sensitivity of results to the base model choice is unknown.

4. Key Insights and Innovations

Innovation 1: Diagnosing Two Complementary Gaps as a Unifying Framework for Why "Thinking with Images" Fails

Prior work on "thinking with images" proceeded by proposing new systems—tool-based pipelines (Visual Sketchpad, DeepEyes, Thyme), unified multimodal models (Chameleon, Show-o, ThinkMorph, Zebra-CoT)—and evaluating whether they improved downstream accuracy. The dominant assumption was that the challenge was primarily architectural: if you could just give the model a way to generate intermediate images, reasoning would improve. The field lacked a diagnostic vocabulary for why one approach succeeded where another failed, leading to contradictory results (unified models sometimes underperform unaided baselines; tool-based methods work on some tasks but are inapplicable to others) with no systematic explanation.

This paper's most fundamental intellectual contribution is the decomposition of reasoning-aware editing into two independent capability gaps—a language-side gap and a generation-side gap—each revealed through targeted probes that cleanly isolate one failure mode from the other.

The language-side gap (Fig. 2a) is the observation that off-the-shelf editors, trained as passive instruction-followers, cannot map an abstract question to the visual transformation that would help answer it. The probe is elegantly minimal: take an editor, give it the raw question ("Is the trash can on the left or right side of the black chair?"), then give it the instruction that the question implies ("draw a red box around the trash can"), and measure the performance gap. The concrete-instruction condition significantly outperforms, confirming that the failure is not in the editor's ability to execute transformations but in its ability to infer which transformation is needed from an underspecified query. This is a language-side failure because it concerns the mapping from natural-language semantics to visual operations—a capability that instruction-following training does not impart, since instruction-following assumes the user already specifies the operation.

The generation-side gap (Fig. 2b) is the observation that even when the transformation is perfectly specified—the exact maze path is provided as a text prompt—edit correctness degrades sharply as the path length grows, from near-perfect at length 1 to near-zero at length 10. This is a generation-side failure because the editor has the right instruction but cannot sustain the multi-step spatial reasoning needed to render it faithfully during the DiT decoding process. The probe isolates this gap by controlling the instruction quality: since the instruction is maximally precise (the ground-truth path in text form), any failure must originate in the generation process itself, not in the language understanding.

What makes this decomposition significant beyond the specific ETCHR system is threefold:

First, it explains the conflicting results in prior work. Tool-based methods succeed on perception and chart tasks (where the language-side gap is small—the mapping from question to action is simple and can be learned through task-specific fine-tuning) but fail on logic, jigsaw, and 3D tasks (where the action space is too constrained to express the needed transformation, exposing a generation-side gap that the deterministic renderer cannot address). Unified models attempt to close both gaps simultaneously with a single backbone but inherit a weaker generative head, so their intermediate images are noisy (generation-side gap) and their question-to-edit mapping is learned implicitly without explicit supervision (language-side gap). Off-the-shelf editors succeed when given explicit instructions on simple transformations (closing both gaps) but fail when the instruction is abstract (language-side gap) or the transformation is structurally complex (generation-side gap). The framework unifies these observations into a coherent picture.

Second, it provides a diagnostic template for future work. Any system that generates intermediate reasoning artifacts can be probed for analogous gaps: is the system failing because it cannot determine what artifact to generate (a planning/understanding failure), or because it cannot generate it faithfully even when told what to produce (an execution/generation failure)? These demand different interventions: the first calls for better question-to-transformation mapping (via supervised imitation, as in ETCHR's Stage I), while the second calls for generation-side capability improvements (via reasoning-aware training, as in Stage II). The paper's two-stage recipe instantiates this separation, but the diagnostic concept is more general than the specific training procedure.

Third, it reframes the problem from "build a better generator" to "build a generator that reasons." The dominant framing in the image editing literature is fidelity: can the editor produce an output that looks like the ground truth? The paper's probes show that fidelity is necessary but insufficient—the editor must also perform the cognitive work of inferring what transformation advances the answer (language-side) and executing multi-step spatial inference (generation-side). This expands the definition of editing quality from perceptual similarity to reasoning utility, a shift that the paper's reward design operationalizes by measuring edit quality through downstream answer accuracy rather than visual metrics.

This diagnostic framework is the paper's most fundamental contribution because it is explanatory (it tells you why prior approaches fail), predictive (it tells you what a solution must address), and transferable (it applies to any system that generates intermediate reasoning artifacts, not just image editors). The evidence for the framework's validity is not a single table but the convergence of two independent probes (Figs. 2a and 2b), the systematic failure patterns of prior work (Table 1), and the ablations showing that both training stages—each targeting one gap—contribute complementary gains (Table 4).

Innovation 2: Reframing Image Editing Quality as Downstream Reasoning Utility Rather than Visual Plausibility

The image editing literature, from InstructPix2Pix (Brooks et al., 2023) to MagicBrush (Zhang et al., 2023) to FLUX-class models (Black Forest Labs, 2025), evaluates edit quality through visual metrics: FID (how realistic does the output look?), LPIPS (how perceptually similar is it to the reference?), CLIP score (how well does it match the text instruction?), and human preference ratings. These metrics operationalize editing as a perceptual task: the editor's job is to produce images that look good and match the user's instruction.

This paper argues that for the "thinking with images" use case, these metrics are fundamentally misaligned with the true objective. An edit can be visually plausible—a bounding box that looks like a bounding box, a path that looks continuous, a jigsaw that looks coherent—while being reasoning-useless (the box covers the wrong object, the path crosses a wall, the jigsaw tile is in the wrong position but blends in). Conversely, an edit can be visually imperfect—a bounding box with slightly jagged edges, a path rendered in a slightly unexpected shade of blue—while being reasoning-perfect (the box covers exactly the right region, the path is topologically valid). Visual metrics cannot distinguish these cases because they measure surface-level appearance, not task-specific correctness.

The paper's operationalization of this reframing is the dual-reward design in Stage II RL (Section 3.3). The Editing Guidance Reward ($r_{guide}$) measures what ultimately matters: did the edit cause the downstream model to answer correctly? This is the end-to-end objective, but it is noisy and ceiling-bound. The Editing Correctness Reward ($r_{correct}$) measures a more decoupled notion of quality: does the edit contain the right visual information, assessed by a judge VLM that checks for correctness without solving the task? Neither reward alone captures the full notion of reasoning utility—$r_{guide}$ is faithful but limited by the downstream model's capability, $r_{correct}$ is ceiling-lifting but introduces judge noise—but their combination operationalizes a definition of edit quality that is explicitly reasoning-aware rather than visually grounded.

What makes this reframing significant:

It provides a language for what was previously a silent failure mode. Prior "think with images" work reported aggregate accuracy numbers but could not explain why some edits helped and others didn't. The distinction between "the edit looks right" and "the edit is reasoning-useful" gives practitioners a diagnostic tool: when an intermediate image doesn't improve accuracy, is it because the edit was visually flawed (generation-side gap), or because it was visually fine but didn't surface the right evidence (language-side gap, or incorrect verification that the wrong evidence was sufficient)? This distinction maps directly to different interventions (improve the generator vs. improve the question-to-edit mapping).

It shifts the optimization target for editor training. If the objective is visual plausibility, training data consists of before/after image pairs with edit instructions, and the loss is perceptual reconstruction error. If the objective is reasoning utility, training data must include downstream task outcomes, and the loss must incorporate task-aware reward. This is precisely ETCHR's two-stage recipe: Stage I SFT uses $i_{gt}$ as the target (closing the language-side gap through imitation), but Stage II RL uses VLM-derived rewards (pushing the model beyond imitation toward reasoning-aware generation). The paper's ablation showing that the RL stage adds gains beyond SFT (Table 4), even if modest, validates that reasoning-aware optimization provides signal that visual imitation alone cannot.

It connects image editing to the broader "reward design for reasoning" literature. In LLM training, the shift from next-token prediction (language modeling) to RLHF (preference optimization) was driven by the recognition that what makes a good continuation is not just statistical likelihood but alignment with human values and task objectives. The paper makes an analogous move for image generation: what makes a good edit is not just visual fidelity to a ground-truth image but downstream reasoning utility. The dual-reward design—combining a task-outcome reward with a process-correctness reward—echoes the distinction between outcome reward models and process reward models in the LLM reasoning literature (Lightman et al., 2023; Wang et al., 2023), adapted to the visual domain.

The evidence that this reframing matters is indirect but compelling. The paper's comparison with Nano Banana 2 (Table 2), a closed-source frontier editor, shows that both editors improve over the no-edit baseline on simple localization tasks (Perception, Chart), but ETCHR shows larger margins on structurally complex tasks (Logic, Jigsaw, 3D). This is consistent with the hypothesis that generic editors are optimized for visual plausibility (which suffices for bounding-box overlay) while reasoning-aware training provides gains specifically when edit correctness depends on task structure rather than visual appearance. The qualitative case in Fig. 4 reinforces this: Nano Banana 2 produces a "rough frame" that is visually plausible (it's a red box) but imprecise (it doesn't tightly localize the trash can), providing "negligible guidance," while ETCHR produces a precise annotation that directly enables correct reasoning.

Innovation 3: Decoupling Editing from Understanding as a General Principle for Modular Visual Reasoning

The dominant architectural tension in multimodal AI is between unified models (Chameleon, Show-o, Janus, ThinkMorph, Zebra-CoT), which handle both understanding and generation in a single backbone, and modular pipelines (Visual Sketchpad, DeepEyes, Thyme), which couple a specialist understanding model with a separate renderer. The unified approach appeals to the scaling hypothesis—larger models trained on more interleaved data will eventually subsume both capabilities—while the modular approach appeals to specialization—dedicated components optimized for their specific functions will outperform a joint compromise.

ETCHR's architectural innovation is not the choice of modularity over unity (tool-based methods already made that choice) but a specific, principled form of modularity: decouple editing from understanding at the model level but couple them at the objective level. The editor is trained independently of the understanding model (no weight sharing, no joint optimization, no per-instance communication), so the understanding model remains frozen and the editor's generative fidelity is not compromised by having to also serve as an answer producer. But the editor is trained with objectives that are defined relative to the understanding model: the Editing Guidance Reward measures whether the understanding model answers correctly given the edit, and the Editing Correctness Reward uses a VLM-as-Judge that is architecturally identical to the understanding model. The editor does not need access to the understanding model's internals during inference, but its training objective is fundamentally shaped by what the understanding model finds useful.

This is more subtle than a simple "specialist beats generalist" claim. The paper's Table 1 shows that unified models (ThinkMorph-7B at 44.05, Bagel-Zebra-CoT at 38.27) underperform not just ETCHR but even the unaided specialist model (Qwen3-VL-8B at 55.95). This is not just a gap—it's a reversal: the unified model's own generated intermediates make it worse than having no intermediates at all. The paper's explanation is that the jointly optimized generative head produces noisy edits that degrade reasoning. ETCHR's architectural choice avoids this pathology by keeping the generative head (the editor) and the reasoning head (the understanding model) in separate models optimized for separate objectives.

What makes this contribution significant beyond the specific system:

It provides an existence proof for plug-and-play visual reasoning assistance. The paper demonstrates that a single trained editor, applied without any fine-tuning of the downstream model, improves accuracy across three very different understanding backbones: the 8B-parameter dense Qwen3-VL-8B, the closed-source Gemini-3.1-Flash-Lite, and the 1T-parameter MoE Kimi K2.5 (Table 1). The improvements are consistent across all three (+4.82, +5.47, +4.61 average Pass@1, respectively). This is strong evidence that the editor has learned a genuinely general capability—inferring and rendering the visual evidence needed to answer a question—that transfers across understanding models with different architectures, scales, and training procedures. If the gains were specific to the model used during RL training (Qwen3-VL-8B for the Editing Guidance Reward), they would not be expected to transfer to Gemini or Kimi K2.5, yet they do.

It resolves the understanding-generation tradeoff by separating it along the training/inference boundary. During training, the editor and understanding model are tightly coupled through the reward signals—the editor is optimized specifically to help the understanding model answer correctly. During inference, they are decoupled—the editor produces $i_{edit}$ without knowing which understanding model will consume it. This is an instance of the principle that training-time coupling + inference-time decoupling can achieve the benefits of both specialization and generality: the editor learns a transferable skill (generating reasoning-useful visual evidence) through tight coupling to a specific understanding model during training, and then applies that skill to any understanding model at inference because the skill itself—producing images that surface the right evidence—is model-agnostic.

It suggests a general architectural template for modular reasoning systems. The pattern—a generation module trained with objectives defined relative to a downstream module, but deployed independently—could apply beyond image editing. For example: a code generation model trained with rewards from a test-suite executor could deploy with any downstream code reviewer; a diagram generation model trained with rewards from a geometry solver could deploy with any downstream reasoning model; a data visualization model trained with rewards from a statistical analyst could deploy with any downstream consumer. The key insight is that the generation module learns to produce artifacts that are generally useful for a class of downstream tasks by being optimized against a specific downstream model, and this utility transfers because the artifact (an image, a code snippet, a diagram) encodes task-relevant information in a model-independent way.

The evidence for this transfer claim is in Table 1: the editor is trained with Qwen3-VL-8B as both $\mathcal{M}$ and $\mathcal{J}$ (providing both rewards during RL), yet it improves Kimi K2.5—a 1T-parameter MoE model from a different organization—by +4.61 points. The gains are largest on tasks where the edit provides clearly model-independent information (Jigsaw: +26.0 points with Kimi K2.5, where the restored image is unequivocally correct regardless of who looks at it; 3D: +10.5 points, where the novel viewpoint provides geometric information that any spatially-aware model can exploit) and smaller on tasks where the edit's usefulness depends on the model's specific perceptual biases (Perception: +1.5 on Kimi K2.5, where the model is already at 85.9 and the bottleneck is not visual access but reasoning precision).

Innovation 4: Edit Verification with Asymmetric Cost-Benefit as a Principled Defense Against Intermediate Errors

A blind spot across all prior "think with images" work, identified explicitly by the paper in Section 1, is that no existing approach verifies whether the intermediate edit is correct before reasoning forward from it. Tool-based methods assume the renderer's output is correct by construction (since the renderer deterministically executes the MLLM's action tokens), but the action tokens themselves may be wrong—the MLLM might emit a bounding box over the wrong referent. Unified models produce interleaved image tokens without any correctness check, allowing noisy intermediates to propagate directly into the reasoning chain. Off-the-shelf editors, as the paper's Section 2 analysis shows, frequently produce incorrect edits on structurally complex tasks. In all three paradigms, an erroneous intermediate image is indistinguishable from a correct one from the system's perspective—it is simply consumed by the next reasoning step.

The paper's innovation is not the general idea of verification (self-verification, self-consistency, and reflection are well-established in the LLM literature; e.g., Madaan et al., 2023; Huang et al., 2023; Shinn et al., 2023) but the specific argument that edit errors are asymmetric in cost and that this asymmetry justifies a verification step with a specific fallback policy. The claim is: a correct edit provides decisive visual guidance that can flip an answer from wrong to right, while an incorrect edit introduces structured confounders that MLLMs struggle to override, potentially flipping an answer from right to wrong. If the costs were symmetric (a correct edit helps as much as an incorrect edit hurts), then the expected value of using an edit would depend only on the editor's average accuracy. But because the costs are asymmetric—an incorrect edit can be worse than providing no edit at all—the expected value of unconditionally using every edit may be negative even when the editor is more often right than wrong.

This asymmetry is not just asserted; it is empirically visible in the paper's results. The unified models in Table 1 (ThinkMorph, Bagel-Zebra-CoT) perform worse than the unaided baseline, meaning their intermediate images are actively harmful. The paper's off-the-shelf editor probe (Fig. 2b) shows that edit correctness on long maze paths approaches zero—these edits are not just unhelpful but deceptive, since a path that looks continuous but crosses a wall is likely to mislead the downstream model into outputting invalid coordinates. The verification step in ETCHR's Edit-Verify-Reason pipeline (Section 3.4) addresses this by acting as a gate: only edits that pass a reliability check enter the reasoning trajectory; edits that fail are discarded in favor of the original image, which at least contains uncorrupted evidence.

The principled justification for the fallback policy—revert to $\mathcal{M}(i, q)$ on verification failure rather than, say, generating a second edit or asking the editor to revise—is that the original image provides a known performance floor. The understanding model's accuracy on the original image is a measurable baseline, and the fallback ensures the system is never worse than this baseline on any individual question (assuming perfect verification; in practice, verification errors introduce noise). This is a form of the "do no harm" principle in AI-assisted reasoning: the system should improve over the unaided baseline when its edits are correct, but should not degrade when they are not. Prior "think with images" approaches have no such guarantee.

What makes this contribution more than an incremental engineering fix:

It reframes intermediate artifact generation as a decision-under-uncertainty problem rather than a pure generation problem. The editor is not just a generator; it is a generator whose outputs must be selectively consumed based on estimated reliability. This connects image editing to the broader literature on selective prediction, abstention, and deferral in machine learning systems—the idea that when a model's output is unreliable, it is better to not use it than to use it blindly. The verification step operationalizes this by having the understanding model itself estimate edit reliability before committing to an answer.

It introduces a task-adaptive verification tradeoff. The ablation in Table 3 reveals that verification helps on tasks where baseline accuracy is high (Perception, Chart) but provides smaller or negative gains on tasks where baseline accuracy is low (Logic, Jigsaw, 3D). The paper's hypothesis is that when the model rarely solves a task from the original image alone (baseline accuracy ~10–20% on Logic, Jigsaw), even imperfect edits are more useful as hints than no edit at all—a blurry bounding box is better than no bounding box when the alternative is guessing. This suggests that verification should be selectively applied, gated by task difficulty or model confidence, rather than uniformly—an insight that the paper notes but does not fully operationalize.

It provides a concrete mechanism for making generation robust to its own errors. The broader challenge in AI systems that generate intermediate reasoning artifacts (chain-of-thought traces, retrieved documents, code sketches) is that errors in these artifacts can compound, leading to worse final outputs than if the artifact had never been generated. Verification-with-fallback is a general pattern for addressing this: generate an artifact, assess its reliability, and conditionally use it. ETCHR instantiates this pattern for the specific case of image edits, with the understanding model serving as its own verifier by prompting it differently. Whether this pattern generalizes to other artifact types—and whether the same model can reliably verify its own outputs—is an open question, but the paper establishes the pattern's value in a concrete, empirically validated setting.

5. Experimental Analysis

Evaluation Methodology

  • Dataset. The primary evaluation spans nine benchmarks organized into five task families, drawn from existing public datasets and in-house constructions. Fine-grained perception uses V*Bench (Wu & Xie, 2024) and HRBench (4K/8K) (Wang et al., 2025). Chart understanding uses ChartQA (Masry et al., 2022) and CharXiv (Descriptive/Reasoning) (Wang et al., 2024). Logic reasoning uses 200 Maze and 200 Frozen Lake tasks constructed in-house. Jigsaw reasoning uses 200 puzzles built from MS COCO (Lin et al., 2014) via tile-shuffling strategies. 3D understanding uses the Person-Perspective Relative-Direction subtask of ViewSpatial-Bench (Li et al., 2025) and DL3DV-2k, a benchmark constructed from DL3DV-10K (Ling et al., 2024) with 2,000 questions targeting perspective-transformation reasoning. The paper does not report a separate validation split for these benchmarks; strategy selection (compute-optimal policies, two-fold cross-validation) is not used here as ETCHR's policy is fixed per task family, not per-question adaptive.

  • Base model(s). The understanding models tested are Qwen3-VL-8B-Instruct (Bai et al., 2025), an 8B-parameter dense model; Gemini-3.1-Flash-Lite-Preview (Comanici et al., 2025), a closed-source model; and Kimi K2.5 (Team, 2026), a 1T-parameter Mixture-of-Experts model. The editor is built on FLUX.2-klein-base-9B (Black Forest Labs, 2025). The choice spans open-source, closed-source, dense, and MoE architectures at scales from 8B to 1T, providing broad coverage of the contemporary MLLM landscape. For RL training, Qwen3-VL-8B-Instruct serves as both the understanding model $\mathcal{M}$ (for the Editing Guidance Reward) and the judge model $\mathcal{J}$ (for the Editing Correctness Reward).

  • Metrics. All results are reported as Pass@1 (accuracy) at temperature 0—deterministic greedy decoding—with no sampling or ensembling. For each question, the model produces a single answer; Pass@1 is the fraction of questions where this answer matches the ground truth. The grading procedure for each benchmark follows the original dataset's evaluation protocol (e.g., exact match for multiple-choice, the released grading function for V*Bench, the ChartQA evaluation script). The paper does not report confidence intervals, statistical significance tests, or multiple runs with different random seeds.

  • Baselines. The paper compares against four categories of baselines:

    • Tool-based and programmatic models: DeepEyesV2 (Hong et al., 2025), which emits bounding-box and crop-zoom commands for fine-grained search and chart parsing, and Thyme (Zhang et al., 2025), which extends the action space to executable code snippets. Both require the understanding model to be fine-tuned on task-specific action formats. The maximum number of tool invocations is set to 10.
    • Unified multimodal models: Bagel-Zebra-CoT (Li et al., 2025) and ThinkMorph-7B (Gu et al., 2025), which interleave text and image tokens in a single backbone and are fine-tuned on interleaved reasoning traces. The maximum number of image generations is set to 10.
    • Off-the-shelf editors: Nano Banana 2 (Google, 2026), a closed-source frontier image editor, used as the intermediate-image generator with prompt enhancement (Gemini-3.1-Flash-Lite converts the question to an explicit edit instruction). Tested on a 100-sample-per-benchmark subset to contain API costs. This is the only baseline that directly tests whether a generic editor, without ETCHR's reasoning-aware training, can serve the same role.
    • Unaided understanding models: Qwen3-VL-8B, Gemini-3.1-Flash-Lite, and Kimi K2.5 without any intermediate visual assistance, evaluated on the original image alone. These are the primary points of comparison for ETCHR's improvements.

  • Generation budget / compute accounting. The paper does not define a unified compute budget in terms of FLOPs or wall-clock time. For tool-based baselines, the budget is measured in tool invocations (max 10). For unified models, it is measured in image generation steps (max 10). For ETCHR, inference cost is 1 diffusion generation (30 steps through the DiT) + 2 LLM forward passes (1 for verification, 1 for reasoning). There is no FLOPs-matched comparison between these different cost categories—the comparison is on accuracy alone, with inference cost discussed only qualitatively in the Limitations section.

  • Cross-validation / statistical protocol. No cross-validation, statistical significance testing, or multiple-seed evaluation is reported. All main results in Table 1 are single-run Pass@1 at temperature 0 on the full test sets. The ablation studies (Tables 3–5) use the same evaluation protocol. The comparison with Nano Banana 2 (Table 2) uses a 100-sample subset per benchmark, and the paper explicitly notes that "absolute numbers should be read as trends rather than significance-tested estimates." This is a genuine weakness: with test sets of varying size (500 for V*Bench, 200 for Maze/Frozen Lake/Jigsaw, 2000 for DL3DV-2k, plus ChartQA and CharXiv whose test set sizes are not explicitly stated but are publicly known to be 2500 and 2000 respectively), the absence of confidence intervals makes it impossible to assess whether reported differences (e.g., +0.5 on HRBench 8K with Kimi K2.5, Table 1) are statistically reliable or within noise. The paper's consistent improvement across all three backbones and most task families provides qualitative evidence against pure noise, but the lack of statistical rigor is a limitation.

Main Quantitative Results

Overall Performance Across Understanding Models and Task Families

Table 1 presents the central result: ETCHR improves average Pass@1 across all benchmarks and all three understanding models, with gains concentrated on tasks that require structural visual transformations rather than localized annotation.

With Qwen3-VL-8B as the understanding model, the unaided baseline achieves 55.95 average Pass@1. ETCHR raises this to 60.77, a gain of +4.82 points (8.6% relative improvement). The task-level breakdown:

  • Fine-grained perception: V*Bench improves from 84.8 to 86.9 (+2.1); HRBench 4K from 78.1 to 80.6 (+2.5); HRBench 8K from 74.5 to 75.3 (+0.8). The gains are modest here because baseline accuracy is already high—the bottleneck is not visual access but fine-grained reasoning precision. The editor's bounding boxes help when the model would otherwise miss the referent entirely, but when the model can already locate the object, the box provides redundant information.
  • Chart understanding: ChartQA improves from 86.7 to 88.4 (+1.7); CharXiv Descriptive from 85.0 to 86.8 (+1.8); CharXiv Reasoning from 47.9 to 49.7 (+1.8). Again, modest but consistent—chart reading benefits from having the relevant data region highlighted, but the model's existing chart parsing capability is already strong.
  • Logic reasoning: Maze improves from 27.5 to 38.5 (+11.0); Frozen Lake from 9.5 to 13.5 (+4.0). These are the largest relative gains on tasks where the model starts from a low baseline. The editor's path trace transforms a spatially complex reasoning problem (find a continuous path through obstacles) into a simpler perception problem (read the coordinates of the blue line), which the model is much better equipped to handle.
  • Jigsaw reasoning: COCO Jigsaw improves from 9.5 to 13.0 (+3.5). The gain is smaller than on Maze but still substantial (37% relative). Jigsaw restoration is a harder generation task for the editor (global rearrangement vs. additive overlay), so edit reliability is lower, limiting the downstream gain.
  • 3D understanding: ViewSpatial improves from 41.1 to 57.2 (+16.1); DL3DV-2k from 70.8 to 78.6 (+8.2). These are striking gains—the largest in absolute terms—confirming that viewpoint transformation provides genuinely novel visual evidence that the model cannot infer from a single image. The improvement on ViewSpatial (+16.1) is particularly notable because this benchmark explicitly tests perspective-taking (e.g., "From the perspective of this person, where is that object?"), which is almost impossible to solve correctly without seeing the scene from the target viewpoint.

The variation in gain magnitude across tasks reveals a clear pattern: ETCHR helps most when the edit provides information the model cannot extract from the original image alone (path traces, restored jigsaws, novel viewpoints) and helps least when the edit provides information the model already has (bounding boxes on easily-localized objects, chart highlights on simple charts). This is exactly what the system is designed for—the editor's value is in surfacing latent visual evidence, not in re-presenting evidence the model can already access.

With Gemini-3.1-Flash-Lite, the unaided baseline achieves 65.08 average Pass@1. ETCHR raises this to 70.55, a gain of +5.47 points (8.4% relative). The pattern of gains is similar to Qwen3-VL-8B but with some notable differences:

  • 3D understanding shows even larger gains: ViewSpatial +11.2, DL3DV-2k +12.6.
  • Logic reasoning: Maze +11.5, Frozen Lake +6.5.
  • Fine-grained perception shows small gains (V*Bench +2.7, HRBench 4K +1.4, HRBench 8K +0.6).
  • The overall larger absolute gain (+5.47 vs. +4.82 with Qwen3-VL-8B) may reflect Gemini's different sensitivity to visual hints—the paper does not analyze this difference.

With Kimi K2.5 (1T MoE), the unaided baseline achieves 76.55 average Pass@1. ETCHR raises this to 81.16, a gain of +4.61 points (6.0% relative). The task-level pattern shifts:

  • Jigsaw shows an enormous gain: from 44.5 to 70.5 (+26.0). This is the single largest improvement in the entire table, suggesting that Kimi K2.5, despite its scale, struggles with spatial rearrangement tasks and benefits disproportionately from having the restored image provided.
  • Logic reasoning: Maze +2.5, Frozen Lake +4.5. The small gain on Maze (2.5 vs. 11.0 with Qwen3-VL-8B) is because Kimi K2.5's baseline Maze accuracy is already 95.5—there is little room for improvement. The editor's path trace is largely redundant when the 1T-parameter model can already solve nearly all mazes from the raw image.
  • 3D understanding: DL3DV-2k +10.5. The gain remains substantial even at this scale.
  • Fine-grained perception and chart understanding show marginal gains (V*Bench +1.5, ChartQA +0.4, CharXiv DQ +0.1, CharXiv RQ +0.8). At 76.55 average Pass@1, the model is approaching ceiling on these benchmarks, and the editor's bounding boxes add little.

The consistent improvement across three model scales and architectures—and the transfer from Qwen3-VL-8B (used during RL training for the rewards) to Gemini and Kimi K2.5 (never seen during training)—provides the paper's strongest evidence for the generality of the reasoning-aware editing capability. The editor has learned to produce edits that are useful to a range of understanding models, not just the one it was optimized against.

Comparison Against Tool-Based and Unified-Model Baselines

Table 1 also positions ETCHR relative to the two prevailing "think with images" paradigms.

Tool-based methods (DeepEyesV2, Thyme) are competitive on fine-grained perception and chart understanding—the tasks their action spaces were designed for. On V*Bench, DeepEyesV2 achieves 81.8 (vs. Qwen3-VL-8B's 84.8 baseline and 86.9 with ETCHR); on ChartQA, it achieves 88.4 (matching Qwen3-VL-8B + ETCHR at 88.4). However, their predefined action spaces do not cover tasks requiring non-local edits: on Maze, Frozen Lake, Jigsaw, and 3D tasks, the paper marks results with † to indicate unsupported task scope rather than evaluated failure. These are not zero-accuracy results; they are tasks the systems fundamentally cannot attempt because they lack the required operations (path-tracing, image rearrangement, viewpoint synthesis) in their action vocabularies.

This comparison highlights a fundamental tradeoff: tool-based methods achieve high fidelity on supported operations but have zero coverage on unsupported ones, while ETCHR achieves coverage across all task families with variable fidelity. On tasks both approaches support (perception, chart), ETCHR is roughly comparable to tool-based methods (+2.1 on V*Bench vs. DeepEyesV2's 81.8, but note Qwen3-VL-8B's baseline is already 84.8, so DeepEyesV2 actually underperforms the unaided baseline on this model—likely because DeepEyesV2 was fine-tuned on a different base model and doesn't transfer cleanly). On tasks tool-based methods cannot attempt, ETCHR provides substantial gains over the unaided baseline, establishing a different point in the coverage-fidelity tradeoff space.

Unified multimodal models (Bagel-Zebra-CoT, ThinkMorph-7B) have unrestricted coverage—they can theoretically generate any visual transformation—but their actual performance is poor. On average across all tasks, ThinkMorph-7B achieves 44.05 and Bagel-Zebra-CoT achieves 38.27, compared to Qwen3-VL-8B's unaided 55.95. This means the unified models perform worse with their own generated intermediates than the specialist model does with no intermediates at all, confirming the paper's diagnosis that jointly optimized generative heads produce noisy, misleading edits. On specific tasks, the gap is stark: on V*Bench, Bagel-Zebra-CoT achieves 50.8 vs. Qwen3-VL-8B's 84.8; on Maze, ThinkMorph-7B achieves 6.5 vs. Qwen3-VL-8B's 27.5. The unified models are not just slightly worse—they are fundamentally unreliable as reasoning assistants.

ETCHR's advantage over unified models is thus structural rather than incremental: by keeping generation and understanding in separate specialist models, ETCHR avoids the optimization tension that degrades both capabilities. The comparison is not "ETCHR is a better unified model" but "ETCHR demonstrates that the modular approach is currently the only one that works—unified models have not yet reached the point where their intermediate images are useful rather than harmful."

Comparison Against an Off-the-Shelf Closed-Source Editor

Table 2 compares ETCHR against Nano Banana 2 (Google, 2026), a closed-source frontier image editor, used as the intermediate-image provider for Qwen3-VL-8B and Gemini-3.1-Flash-Lite. Both editors are evaluated on a 100-sample-per-benchmark subset (due to API cost constraints), so these are trends rather than significance-tested estimates.

With Qwen3-VL-8B: The unaided baseline achieves 48.10 average Pass@1 on this subset (lower than the full-test-set 55.95 because the subset is not stratified by difficulty—this is a methodological weakness). Nano Banana 2 improves this to 49.60 (+1.50); ETCHR improves it to 52.86 (+4.76). The task-level breakdown:

  • Perception: Nano Banana 2 and ETCHR are tied at 82.0 (vs. baseline 80.3). Both editors provide useful bounding boxes on localization tasks.
  • Chart: ETCHR (77.3) slightly edges Nano Banana 2 (77.0), both above baseline (75.7).
  • Logic: ETCHR (24.0) significantly outperforms Nano Banana 2 (20.5) and baseline (17.5). This is where reasoning-aware training shows its value: Nano Banana 2 struggles to trace valid maze paths, while ETCHR's Stage I SFT and Stage II RL specifically target this capability.
  • Jigsaw: ETCHR (15.0) vs. Nano Banana 2 (13.0) vs. baseline (11.0). Modest gains for both editors.
  • 3D: ETCHR (66.0) substantially outperforms Nano Banana 2 (55.5), which is actually slightly below the baseline (56.0). This is a critical data point: Nano Banana 2's viewpoint synthesis is unreliable enough to harm reasoning on 3D tasks, while ETCHR's provides genuine assistance. This directly validates the paper's claim that reasoning-aware training, not editor scale, drives guidance quality on structural tasks.

With Gemini-3.1-Flash-Lite: The baseline is 59.36, Nano Banana 2 achieves 61.24 (+1.88), and ETCHR achieves 65.22 (+5.86). The pattern is similar: both editors improve over baseline, but ETCHR's margin is larger, especially on Logic (61.0 vs. 53.5) and 3D (68.5 vs. 59.0).

The key takeaway from Table 2 is that even a frontier closed-source editor, without reasoning-aware training, provides only modest gains on structural tasks and can actually harm performance on the hardest transformations (3D viewpoint synthesis). ETCHR's two-stage training recipe is not just an incremental improvement over a generic editor—it is what enables the editor to function as a reasoning assistant rather than a visual noise source on tasks that demand more than localized annotation.

Ablation Studies and Robustness Checks

All ablation results are evaluated with two understanding backbones (Qwen3-VL-8B and Gemini-3.1-Flash-Lite) to check consistency, though the paper does not explicitly discuss whether ablation patterns differ between the two.

Two-stage training recipe (Table 4): This ablation compares four conditions: (1) the unaided understanding model (no editor), (2) the base FLUX.2-klein-base-9B editor used as-is with task-level prompt enhancement but no fine-tuning, (3) the editor after Stage I SFT only (+sft), and (4) the editor after both Stage I SFT and Stage II RL (+sft&rl).

With Qwen3-VL-8B, the unaided baseline achieves 47.26 (note: this is lower than Table 1's 55.95 because the ablation is evaluated on a per-task-family aggregation, not the full benchmark suite—the paper uses average across Perception, Chart, Logic, Jigsaw, and 3D macro-groups). The base FLUX.2 editor actually reduces performance to 45.26—below the unaided baseline—confirming that off-the-shelf editors without question-conditioned training are not just unhelpful but actively harmful on average. Stage I SFT recovers and surpasses the baseline, achieving 51.98 (+4.72 over unaided, +6.72 over base editor). Stage II RL adds a further 0.58 points to reach 52.56. The RL gain is modest and concentrated on Perception (+1.2: 79.7 to 80.9) and Chart (+0.9: 74.1 to 75.0), with Logic, Jigsaw, and 3D essentially flat.

With Gemini-3.1-Flash-Lite, the pattern is similar but shifted upward: baseline 58.72, base editor 56.52 (−2.20), SFT 64.78 (+6.06 over baseline, +8.26 over base editor), SFT+RL 65.26 (+0.48 over SFT). Again, SFT provides the bulk of the gain, and RL adds a small increment.

The critical finding is that Stage I SFT alone accounts for most of ETCHR's improvement over the unaided baseline. The base editor hurts performance; SFT not only recovers the loss but provides substantial gains; RL adds a small further improvement that is task-dependent. This supports the paper's diagnosis that the language-side gap (mapping questions to edits) is the primary bottleneck—once the editor learns what transformation to apply, it provides value, and further optimization for generation quality yields diminishing returns. The paper's attribution of the small RL gain to "GRPO sampling granularity" (structural edits like jigsaw restoration produce similar-looking candidates, making pairwise preference ranking uninformative) is plausible but not directly tested—there is no ablation comparing GRPO against an alternative RL algorithm that might better handle structural edits.

RL reward signals (Table 5): This ablation isolates the two reward components introduced in Section 3.3: Editing Correctness only ($r_{correct}$ alone), Editing Guidance only ($r_{guide}$ alone), and both combined (the full ETCHR). Evaluated with Qwen3-VL-8B as the understanding model (the same model used for RL training).

With Qwen3-VL-8B: Correctness-only achieves 52.20, Guidance-only achieves 52.20 (identical averages, though the per-task breakdown differs slightly), and Combined achieves 52.56. The differences are small—0.36 points between the single-reward variants and the combined variant—but the per-task pattern is informative:

  • On Perception, Correctness-only (80.7) outperforms Guidance-only (80.2), and Combined (80.9) is best. This is consistent: the judge VLM can reliably assess bounding-box correctness, making $r_{correct}$ a stronger signal, while $r_{guide}$ is ceiling-bound because the model already performs well on perception.
  • On Chart, the same pattern holds: Correctness 74.7 vs. Guidance 74.2, Combined 75.0.
  • On Logic, both single-reward variants achieve 26.0 (Guidance) and 25.8 (Correctness), with Combined at 26.0. The rewards are essentially equivalent here.
  • On Jigsaw, all three conditions are identical at 13.0—none of the rewards provide useful signal, consistent with the "GRPO sampling granularity" hypothesis.
  • On 3D, Guidance-only (67.6) slightly outperforms Correctness-only (66.8), and Combined (67.9) is best.

With Gemini-3.1-Flash-Lite (a different model than the one used for RL training), the pattern is similar: Correctness-only 64.86, Guidance-only 64.90, Combined 65.26. The fact that the combined reward transfers gains to an unseen understanding model provides weak evidence that the reward design captures something genuinely edit-quality-related rather than overfitting to Qwen3-VL-8B's specific behavior.

The key finding is that neither single reward dominates, and their combination matches or exceeds both on all task families. This validates the complementary design: $r_{correct}$ provides a fidelity floor (filtering implausible edits) while $r_{guide}$ raises the task ceiling (ensuring edits advance reasoning). However, the margins are small (maximum 0.6 points advantage for Combined over either single reward), so the evidence for complementarity is suggestive rather than definitive. A stronger test would be tasks where the two rewards disagree—do edits that pass $r_{correct}$ but fail $r_{guide}$ (or vice versa) behave differently under the combined reward? The paper does not provide this analysis.

Inference-time reflection mechanism (Table 3): This ablation compares the full Edit-Verify-Reason pipeline ("with reflection") against a variant where the verification step is skipped and every edited image is passed directly to the reasoning step ("without reflection"). Evaluated on the same per-task-family aggregation as Table 4.

With Qwen3-VL-8B: Without reflection achieves 51.84, with reflection achieves 52.56, a gain of +0.72. The task-level breakdown reveals non-uniform effects:

  • Perception: Reflection provides +1.6 points (79.3 to 80.9). At high baseline accuracy (~79-80%), suppressing even a small fraction of harmful edits yields measurable gains.
  • Chart: Reflection provides +1.8 points (73.2 to 75.0). Same logic: when the model is already strong, incorrect edits are the primary risk, and verification mitigates it.
  • Logic: Reflection provides +0.5 points (25.5 to 26.0). Minimal gain—when baseline accuracy is low, the verifier is unreliable (it cannot distinguish correct from incorrect edits on hard tasks), and even imperfect edits are more useful than no edits.
  • Jigsaw: No change (13.0 with and without reflection). The verifier provides no value because it cannot reliably assess jigsaw restoration quality at this low accuracy level.
  • 3D: Reflection provides a small negative effect: 68.2 without reflection vs. 67.9 with reflection (−0.3). This supports the paper's hypothesis that on hard tasks where even imperfect edits are valuable, verification that rejects some edits reduces the number of useful hints available.

With Gemini-3.1-Flash-Lite: Without reflection 64.40, with reflection 65.26 (+0.86). The task-level pattern is similar but shifted: larger gains on Perception (+0.8) and Chart (+1.1), small gain on Logic (+1.3), small gain on Jigsaw (+1.5), slightly negative on 3D (−0.4).

The critical insight from this ablation is that reflection is not uniformly beneficial—it helps on tasks where the understanding model is already competent (and can reliably verify edits) but provides negligible or negative value on tasks where the model is near its capability ceiling (and verification adds noise without filtering many genuinely harmful edits). The paper's suggestion that "reflection should be applied selectively, gated by backbone confidence or task family rather than uniformly" is well-supported by this data but not operationalized—no confidence-gated variant is tested.

Additional Ablation Not Explicitly Tabled

The paper mentions in Section 4.2 that the RL stage was also attempted with ReST^EM (Singh et al., 2024, cited in Appendix K and the Limitations discussion in Section 6), an alternative RL algorithm for self-improvement. The result, described in Appendix K (Figure 16) but not reproduced in the main text, is that "additional sequential revisions substantially hurt performance" with the ReST^EM-trained model. At 256 generations, fully sequential performance drops to approximately 33.5% compared to roughly 38.5% at the optimal ratio. The paper hypothesizes that on-policy data collection in ReST^EM exacerbates spurious correlations in revision data, causing the model to fail to learn the revision task properly. This is a notable negative result that highlights the sensitivity of revision training to the data generation procedure, though it pertains specifically to the revision model variant (Appendix K) rather than the main ETCHR editor.

Critical Assessment

Does ETCHR genuinely improve downstream reasoning, or does it mostly recover from a weak baseline?

The paper's central claim is that ETCHR "raises average Pass@1" across understanding models by +4.82, +5.47, and +4.61 points (Table 1). This claim is supported by the data, but the magnitude and interpretation require scrutiny.

What is demonstrated: ETCHR consistently improves over the unaided baseline across all three understanding models and nearly all task families. The improvements are largest on tasks where the baseline is weakest and the edit provides genuinely novel information (Maze +11.0, ViewSpatial +16.1 with Qwen3-VL-8B; Jigsaw +26.0 with Kimi K2.5). This is exactly what you would expect from a system that surfaces latent visual evidence: it helps most where the evidence was most needed.

What is not demonstrated but implied: that ETCHR's gains reflect the editor's reasoning awareness specifically, rather than the general value of any task-appropriate visual annotation. The paper's ablation showing that the base FLUX.2 editor hurts performance (Table 4, 45.26 vs. 47.26 baseline) provides some evidence that not any annotation works—the editor must be trained to produce the right kind of annotation. However, the ablation does not test whether a simpler training procedure (e.g., SFT on a perception-only corpus of question-bounding-box pairs, without the multi-task diversity or RL stage) would achieve similar gains on the tasks where ETCHR excels. The comparison against Nano Banana 2 (Table 2) shows that a generic frontier editor with prompt enhancement provides smaller gains than ETCHR, especially on structural tasks, but the gap is not enormous on perception and chart. It is possible that a significant fraction of ETCHR's gain comes from the general value of visual annotation (any reasonable bounding box helps) rather than the specific reasoning-aware training recipe.

What would strengthen this claim: a comparison against a "naive editor" baseline that uses the same base model (FLUX.2-klein-base-9B) fine-tuned on a single-task corpus (e.g., perception only) and tested on all five families. If this single-task editor matched ETCHR on perception but failed on logic/jigsaw/3D, it would cleanly demonstrate that multi-task diversity and reasoning-aware training are necessary for cross-task generalization. The current baselines (Nano Banana 2, unified models, tool-based methods) are too different architecturally to isolate the training recipe's contribution.

Does the decoupled editor plug into any MLLM without fine-tuning, as claimed?

The paper's second major claim is that ETCHR "plugs into different open- and closed-source MLLMs in a training-free manner." This claim is strongly supported by Table 1: the same trained editor, with no per-model adaptation, improves Qwen3-VL-8B, Gemini-3.1-Flash-Lite, and Kimi K2.5. The fact that the RL stage used Qwen3-VL-8B for both reward signals, yet the editor transfers gains to Gemini and Kimi K2.5, is compelling evidence that the editor has learned model-agnostic visual reasoning skills.

Caveats that weaken this claim: (1) The editor's task-level prompt $p_{task}$ must be manually specified per task family. The editor does not autonomously determine whether a given question is perception, chart, logic, jigsaw, or 3D—this requires external task labels. In a deployment scenario where task labels are not available, the system would need an additional task classifier, or the editor would need to infer the task type from the question alone (which the paper's Section 2 analysis shows off-the-shelf editors cannot do). (2) The paper does not test whether the editor transfers to understanding models with substantially different visual encoders (e.g., models that use a different input resolution, aspect ratio, or preprocessing pipeline). All three tested models are strong contemporary MLLMs with broadly similar architectures (vision transformer + LLM); transfer to, say, a model with a CNN-based visual encoder is untested. (3) The improvements, while consistent, are modest in absolute terms (+4-5 points on a 55-77 baseline), and it is unclear whether they justify the added inference cost of running a 9B-parameter diffusion model for every query.

Do the ablations genuinely isolate the contributions of each design choice?

The paper's ablation strategy is generally sound but has several gaps:

Stage I vs. Stage II (Table 4): The ablation clearly shows that Stage I SFT provides the bulk of the gain and Stage II RL adds a small increment. However, there is no ablation of the SFT data composition—does training on all five families jointly outperform training on each family separately, as the paper claims? The argument that multi-task diversity prevents "collapse onto a single edit template" is plausible but untested. An ablation comparing the full five-family SFT against, say, a perception-only SFT tested on all five families would directly test this claim. Without it, the reader cannot distinguish between "the editor learned a general question-to-edit mapping" and "the editor learned five separate mappings that are cued by the task-level prompt."

Reward signals (Table 5): The ablation shows that combining both rewards matches or slightly exceeds either alone, but the margins are small (0.36 points for Qwen3-VL-8B). This is consistent with complementarity but also consistent with the rewards being largely redundant—if both rewards usually agree (i.e., edits that pass correctness also pass guidance and vice versa), then combining them adds little. The paper does not report the agreement rate between $r_{correct}$ and $r_{guide}$ on the RL training data, which would directly quantify how often the two rewards provide conflicting signal and whether the combination resolves those conflicts.

Reflection (Table 3): This ablation clearly shows that reflection helps on easy tasks and is neutral-to-slightly-harmful on hard tasks. However, the paper does not test the obvious follow-up: gating reflection by model confidence or task difficulty. The claim that "reflection should be applied selectively" is supported by the data but not validated with an actual selective-reflection variant. This is a missed opportunity to demonstrate a practical improvement.

Missing ablation: task-level prompts. The paper's Section 3.2 argues that task-level meta-prompts are necessary to prevent cross-task interference, but there is no ablation testing the editor without $p_{task}$. What happens if the editor is trained on the same five-family corpus but with only the raw question as input? Does performance collapse on all families, or only on those with ambiguous edit modalities? This ablation would directly test the paper's "gradient conflict" hypothesis and would be straightforward to run.

Missing ablation: LoRA rank. The paper uses $r = 768$ for SFT and $r = 128$ for RL, arguing that "a large rank provides sufficient capacity for multi-task learning." Without a rank ablation (e.g., $r = 64$, $r = 256$, $r = 1024$), the reader cannot assess whether the large rank is necessary or whether a smaller rank would achieve similar performance with fewer parameters.

Missing ablation: number of RL training instances. The RL stage uses 2,000 instances per family (10,000 total before filtering). How sensitive are the RL gains to this number? Would 500 per family suffice? Would 5,000 improve the structural-task gains where GRPO currently plateaus? No data-quality or data-quantity ablation is reported.

Are the benchmark choices and evaluation protocols adequate?

Strengths: The five-family benchmark suite is deliberately diverse, covering qualitatively different visual transformation types (localization, information grounding, path-tracing, rearrangement, viewpoint synthesis). This is a strength—it forces the editor to acquire a general capability rather than overfitting to a single edit template. The use of multiple understanding models (open-source, closed-source, dense, MoE, 8B to 1T) provides cross-model validation that is rare in the literature.

Weaknesses:

  • Small self-constructed test sets: The Maze, Frozen Lake, and COCO Jigsaw benchmarks each have only 200 test questions. With baselines in the 9-27% range for Maze (Qwen3-VL-8B), this means the absolute number of correct answers is 18-54 out of 200. A swing of a few questions can produce noticeable Pass@1 changes. The paper does not report confidence intervals, so differences like +3.5 on COCO Jigsaw (9.5 to 13.0, or 19 to 26 correct out of 200) cannot be assessed for statistical significance. This is especially concerning for the ablation studies, where differences are often <1 point (e.g., Table 4: 51.98 vs. 52.56) and could easily be noise at this sample size.

  • No difficulty stratification: The benchmarks are reported as single aggregate numbers, but the paper's own analysis (Section 2, Fig. 2b) shows that edit correctness varies dramatically with task complexity. Does ETCHR help uniformly across easy and hard mazes, or only on short paths where the editor's generation-side gap is small? Does it help on jigsaws with 4 tiles but not 9? Without difficulty-stratified results, the reader cannot assess whether the gains are concentrated on easy instances (where the editor is reliable) or extend to hard ones (where the editor might be more error-prone).

  • The 100-sample subset for Nano Banana 2 comparison (Table 2) is not documented: How was this subset selected? If it is a random sample, why are the baseline numbers different from Table 1? (Qwen3-VL-8B averages 48.10 in Table 2 vs. 55.95 in Table 1). This discrepancy suggests either a different task weighting in the average or a non-random subset. Without documentation, the comparison is difficult to interpret.

  • No human evaluation of edit quality: All edit quality assessment is through VLM-as-Judge ($r_{correct}$) or downstream accuracy ($r_{guide}$). There is no human annotation of whether ETCHR's edits are actually correct (e.g., does the bounding box cover the right object? does the maze path avoid all walls?). This means the paper cannot distinguish between "the editor produces correct edits" and "the editor produces edits that the judge VLM and understanding model find acceptable." The two are correlated but not identical, as the paper's own discussion of judge noise acknowledges.

  • No latency or throughput measurement: The Limitations section mentions that "Image editing incurs a higher temporal cost compared to text-based reasoning," but no concrete numbers are provided. How many seconds does a 30-step DiT generation take on what hardware? How does this compare to the understanding model's forward pass? Without these numbers, practitioners cannot assess whether the accuracy gains justify the inference cost in their deployment context.

Do the paper's claims about the two gaps (Section 2) hold up under the experimental results?

The paper's diagnostic framework (language-side gap, generation-side gap) is elegant and well-motivated by the probes in Fig. 2. However, the experimental results in Section 4 provide only indirect validation that ETCHR's two-stage training actually addresses these specific gaps:

  • Does Stage I SFT close the language-side gap? The SFT ablation (Table 4) shows that SFT provides large gains, which is consistent with closing the language-side gap (the editor learns to map questions to edits). But the paper does not directly test whether the SFT checkpoint can perform question-to-edit mapping better than the base editor on the Fig. 2a probe. A direct test—comparing the base editor vs. the SFT checkpoint on the same abstract-question vs. concrete-instruction probe from Fig. 2a—would cleanly demonstrate that SFT specifically improves the language-side capability.

  • Does Stage II RL close the generation-side gap? The RL ablation (Table 4) shows that RL adds small gains, concentrated on perception and chart. If RL were specifically addressing the generation-side gap, we would expect larger gains on tasks that require multi-step spatial reasoning during generation (Maze, Jigsaw, 3D), since these are where Fig. 2b shows the gap is most severe. Instead, RL gains on these tasks are essentially flat (Logic: 25.8 to 26.0, Jigsaw: 13.0 to 13.0, 3D: 67.3 to 67.9). This suggests that Stage II RL is not effectively closing the generation-side gap—it may be improving edit quality in ways that help on simple tasks (sharper bounding boxes, more precise chart highlights) but is not overcoming the fundamental multi-step reasoning limitations of the DiT decoder. The paper's attribution to "GRPO sampling granularity" is a plausible explanation for the failure but does not rescue the claim.

  • Alternative interpretation: The experimental results are equally consistent with a simpler story: Stage I SFT teaches the editor to produce the right kind of edit for each task (via imitation of $i_{gt}$), closing the language-side gap. Stage II RL provides marginal refinement of edit precision (boxes are more tightly localized, paths are fewer pixels off), but does not address the fundamental generation-side scaling issue (long paths remain hard). The distinction matters because it suggests that future work should focus on improving the base DiT's multi-step reasoning capacity (perhaps through architectural changes or different training objectives) rather than refining the RL reward design.

Summary of Evidentiary Strengths and Gaps

What the experiments convincingly demonstrate:

  1. A fine-tuned specialist editor can improve downstream reasoning accuracy across diverse task families and understanding models (Table 1).
  2. The base off-the-shelf editor without fine-tuning actively harms performance, confirming that question-conditioned training is necessary (Table 4, base editor row).
  3. Supervised fine-tuning on question-edit pairs provides the bulk of the improvement; reinforcement learning adds a small further increment (Table 4).
  4. Edit verification with fallback provides a net benefit, primarily by filtering harmful edits on tasks where the understanding model is already competent (Table 3).
  5. The trained editor transfers gains to understanding models it was not optimized against (Gemini, Kimi K2.5 in Table 1), supporting the plug-and-play claim.

What remains uncertain or unvalidated:

  1. Whether the multi-task diversity of the training data is necessary for cross-task generalization (no single-task baseline).
  2. Whether the RL stage specifically addresses the generation-side gap as opposed to providing general quality refinement (no direct probe of generation-side capability after RL).
  3. Whether the improvements are statistically significant given small test sets for Maze, Frozen Lake, and Jigsaw (no confidence intervals).
  4. Whether the gains justify the added inference cost (no latency or throughput measurements).
  5. Whether edit quality as measured by VLM-judge correlates with human-judged edit correctness (no human evaluation).
  6. Whether the system can operate without external task labels to select $p_{task}$ (no zero-shot task inference experiment).

6. Limitations and Trade-offs

6.1 The Two-Stage Training Recipe Does Not Effectively Close the Generation-Side Gap on Structural Tasks

The assumption or constraint. The paper's diagnostic framework (Section 2) identifies two complementary gaps: a language-side gap (off-the-shelf editors cannot map abstract questions to appropriate visual transformations) and a generation-side gap (edit correctness degrades sharply as the transformation requires deeper spatial or algorithmic reasoning, e.g., tracing a long maze path). The two-stage training recipe is explicitly motivated as targeting both: Stage I SFT closes the language-side gap, Stage II RL closes the generation-side gap. The paper states in Section 3.3 that Stage II "aligns [the editor] with downstream reasoning utility via RL under VLM-derived rewards" and frames this as pushing "outputs toward edits that are correct in isolation and useful for downstream reasoning."

The consequence. The experimental results in Table 4 show that Stage II RL adds only marginal gains over Stage I SFT alone—+0.58 points with Qwen3-VL-8B (51.98 → 52.56) and +0.48 points with Gemini-3.1-Flash-Lite (64.78 → 65.26). Critically, these gains are concentrated on Perception (+1.2) and Chart (+0.9)—tasks involving localized edits where the generation-side gap is minimal—and are essentially flat on Logic (+0.2), Jigsaw (0.0), and 3D (+0.6), which are precisely the tasks where Fig. 2b demonstrated the generation-side gap is most severe. This means Stage II RL is not effectively closing the generation-side gap—the very gap it was designed to address. The paper's own attribution reinforces this: the authors note that "GRPO's sampling exhibits limited semantic diversity for structural editing (e.g., jigsaw restoration), which constrains policy exploration and prevents uniform RL gains across all reasoning families" (Section 6). In operational terms, when the editor generates 8 candidate maze paths or jigsaw restorations for pairwise comparison, those candidates tend to be similarly incorrect, providing no meaningful ranking signal for the policy gradient.

What evidence exists in the paper. Table 4 provides the primary evidence: the SFT+RL row is nearly identical to the SFT-only row on Logic (25.8 vs. 26.0), Jigsaw (13.0 vs. 13.0), and 3D (67.3 vs. 67.9). The ablation of individual reward signals in Table 5 shows the same pattern—neither Editing Correctness nor Editing Guidance individually improves structural-task performance beyond SFT. The paper's Limitations section (Section 6) explicitly acknowledges that "GRPO sampling granularity... constrains policy exploration and prevents uniform RL gains across all reasoning families." Appendix K (Figure 16) reports that an alternative RL algorithm (ReST^EM) actually degrades performance with sequential revisions, suggesting the failure is not specific to GRPO but reflects a deeper difficulty in providing effective RL signal for structural generation tasks.

Mitigation status. The paper acknowledges this limitation explicitly in Section 6 ("Limitations") and suggests "hierarchical or semantic-aware sampling" as a future direction (Section 4.2). However, no alternative RL algorithm, reward structure, or sampling strategy is tested. The limitation is fully acknowledged but unresolved—the generation-side gap remains an open problem that the current training recipe does not close, and the paper provides no evidence that it is closable with the current editor architecture.

6.2 End-to-End Performance Remains Capped by the Understanding Model's Reasoning Ceiling

The assumption or constraint. ETCHR's architecture decouples the editor from the understanding model: the editor produces $i_{edit}$, and the understanding model $\mathcal{M}$ produces the final answer. The paper states in Section 6 that "ETCHR end-to-end performance remains capped by the understanding model; even optimally edited intermediates cannot overcome the reasoning ceiling of the downstream MLLM." This is a structural limitation: if $\mathcal{M}$ lacks the capability to answer a question even when shown the ground-truth edit $i_{gt}$, then no amount of editor improvement will help. The filter $\mathcal{C}$ in Equation (1) explicitly selects RL training instances where $\mathcal{M}(i, i_{gt}, q) = a$—meaning the system only trains on questions where the understanding model is known to be capable given perfect visual evidence, but at inference, questions outside this capability envelope will receive no benefit regardless of edit quality.

The consequence. The practical implication is that ETCHR's value is bounded above by $\mathcal{M}$'s performance with ground-truth edits, not by the editor's performance. On the hardest questions—those where even a human-annotated perfect edit would not enable $\mathcal{M}$ to answer correctly—ETCHR provides zero benefit. The paper's difficulty-bin analysis in the related "compute-optimal test-time scaling" work (referenced in the prior sections) shows that on the hardest difficulty quintile, test-time compute is essentially worthless because the base model's pass@1 is near zero. The same logic applies here: on questions where $\mathcal{M}$ fundamentally cannot perform the reasoning—even with perfect visual evidence—ETCHR cannot help. This is visible in Table 1: on Frozen Lake with Qwen3-VL-8B, the gain is only +4.0 (9.5 → 13.5), and on COCO Jigsaw, only +3.5 (9.5 → 13.0). These tasks remain largely unsolved even with ETCHR's assistance, suggesting the understanding model's spatial reasoning capability is the bottleneck.

What evidence exists in the paper. The filter $\mathcal{C}$ in Equation (1) and its description in Section 3.3 explicitly acknowledge the capability ceiling: instances where $\mathcal{M}(i, i_{gt}, q) \neq a$ are discarded from RL training because "there is no verifiable upper bound" and "the reward landscape has no positive signal." This is a training-time acknowledgment that the system cannot improve on questions beyond $\mathcal{M}$'s reach. At inference, the consistently low absolute scores on Frozen Lake (13.5 with Qwen3-VL-8B + ETCHR, vs. 57.0 with Kimi K2.5 + ETCHR) and COCO Jigsaw (13.0 with Qwen3-VL-8B, 70.5 with Kimi K2.5) demonstrate that gains from ETCHR are multiplicative with the base model's capability—a stronger understanding model benefits more, but the absolute ceiling for a weak model remains low. The paper's Limitations section (Section 6) states this explicitly: "ETCHR end-to-end performance remains capped by the understanding model."

Mitigation status. The paper is transparent about this limitation but offers no mitigation beyond the implicit suggestion to use a stronger understanding model. The gains with Kimi K2.5 (+4.61 average) versus Qwen3-VL-8B (+4.82 average) suggest that stronger models benefit slightly less in relative terms (because their baseline is higher) but substantially more in absolute capability, since their higher baseline means the editor can push them into genuinely useful performance regimes (e.g., Jigsaw 70.5 with Kimi K2.5 vs. 13.0 with Qwen3-VL-8B). The limitation is fundamental to the decoupled architecture: the editor provides evidence, but the understanding model must perform the reasoning. No architectural change short of jointly training the editor and understanding model (which would sacrifice the plug-and-play property) could address this.

6.3 Image Editing Incurs a Substantial Latency Cost Not Accounted for in the Headline Accuracy Gains

The assumption or constraint. The paper measures success exclusively through Pass@1 accuracy. Inference cost—in wall-clock time, FLOPs, or computational budget—is discussed only qualitatively in the Limitations section: "Image editing incurs a higher temporal cost compared to text-based reasoning; consequently, ETCHR increases the time overhead for samples requiring only a short CoT." The ETCHR inference pipeline requires (1) a full diffusion generation pass through the 9B-parameter DiT (30 inference steps), (2) a verification forward pass through the understanding MLLM, and (3) a reasoning forward pass through the understanding MLLM. This is compared against an unaided baseline that requires only a single reasoning forward pass. The paper provides no concrete latency measurements, throughput comparisons, or FLOPs-matched accuracy comparisons.

The consequence. Without latency or cost measurements, a practitioner cannot evaluate whether the accuracy gains justify the added inference time. The cost is likely substantial. A 30-step diffusion generation through a 9B-parameter DiT is orders of magnitude slower than a single autoregressive forward pass through an 8B-parameter LLM. For Qwen3-VL-8B, the average gain per question is ~5 percentage points of accuracy (from 55.95 to 60.77), but the per-question inference time has at least tripled (1 forward pass → 1 diffusion generation + 2 forward passes). For questions that the unaided model already answers correctly (~56% of the benchmark), the editor generation adds latency with zero accuracy benefit (though the verification step could short-circuit this—if verification detects that the edit is unnecessary? The paper does not implement such a mechanism). For questions requiring only "a short CoT" (as the paper acknowledges), the relative overhead is even higher. The practical deployment question—"Is +5 points of accuracy worth 3× the inference latency?"—is entirely unaddressed.

What evidence exists in the paper. The paper provides no quantitative evidence on latency, throughput, FLOPs, or wall-clock time. The Limitations section (Section 6) acknowledges the issue in one sentence, and the training details mention that the SFT uses "inference steps $step = 30$" for the diffusion process, but there is no measurement of what this costs in seconds on specific hardware. The comparisons against tool-based methods (DeepEyesV2, Thyme) and unified models (ThinkMorph, Bagel-Zebra-CoT) in Table 1 are accuracy-only, with no accounting for the different cost structures of these approaches. Tool-based methods invoke a deterministic renderer (fast but limited), unified models generate images autoregressively (different cost profile from diffusion), and ETCHR uses a 30-step diffusion process—these are not comparable in cost, and the paper makes no attempt to normalize for compute.

Mitigation status. The paper does not attempt to mitigate this limitation. It acknowledges the "additional time cost" in Section 6 but provides no latency measurements, no analysis of how accuracy varies with number of diffusion steps (which could enable a compute-accuracy Pareto frontier), and no discussion of whether distillation, fewer inference steps, or model quantization could reduce latency without sacrificing edit quality. This is a significant practical gap: the paper's central claim—that ETCHR improves reasoning—is true in accuracy space but unqualified in cost space, making it impossible for practitioners to determine whether the method is useful in a latency-constrained deployment.

6.4 The System Requires External Task Labels to Select the Correct Edit Modality, Limiting Autonomous Deployment

The assumption or constraint. ETCHR uses task-level meta-prompts $p_{task}$ (e.g., "Draw a red box to mark the important regions for this question in the figure" for perception, "Draw the shortest path of the maze in blue" for logic reasoning) that must be prepended to the question at inference time. The paper states that these prompts "act as a soft task-router that partitions the editor's latent space into task-specific manifolds" (Section 3.2) and notes that "at inference, it adds no architectural cost: because $p_{task}$ is task-level, the editor needs no access to the understanding model's internal representations or per-instance instructions" (Section 3.2). However, this design assumes that the task family is known at inference time—the system must be told whether the current question is a perception, chart, logic, jigsaw, or 3D task in order to select the appropriate prefix. The paper does not provide a mechanism for inferring the task type from the question and image alone.

The consequence. In a realistic deployment, questions arrive without task labels. A user asking "Is the beer bottle silver?" does not annotate this as a "fine-grained perception" question. The system would need either (1) a separate task classifier, (2) a mechanism to try multiple $p_{task}$ prefixes and select the best edit, or (3) an editor trained without task-level prefixes that can infer the appropriate transformation from the question alone. The paper's own Section 2 analysis shows that option (3) fails: off-the-shelf editors fed raw questions (without task-level prefixes or concrete instructions) perform significantly worse than when given explicit instructions (Fig. 2a). ETCHR's SFT stage is trained with $p_{task}$ prefixes, so the model has never learned to infer the task type from the question alone. Removing $p_{task}$ at inference would cause a distribution shift—the editor would receive inputs unlike those seen during training—with unknown (but likely negative) effects on edit quality. This means the system, as presented, is not autonomously deployable on an open-ended stream of multimodal questions.

What evidence exists in the paper. The paper's Section 2 analysis (Fig. 2a) directly demonstrates that off-the-shelf editors cannot infer the appropriate edit modality from raw questions—they require either explicit instructions or task-level guidance. The ablation that would directly test this limitation—evaluating ETCHR without $p_{task}$ prefixes—is not performed, despite being straightforward to run: simply evaluate the trained editor on the same benchmarks with only $q$ as input, no prefix. The paper does not report this number. The task-level prompts are listed in Appendix A with distinct wordings per family, confirming that different tasks use different prefixes. The paper's claim that $p_{task}$ "prevents collapse onto a single edit template" (Section 3.2) implies—but does not test—that removing it would cause exactly such collapse.

Mitigation status. The paper does not address this limitation. No task classifier is proposed or evaluated. No experiment tests the editor's performance without $p_{task}$. The paper's suggestion that "reflection should be applied selectively, gated by backbone confidence or task family rather than uniformly" (Section 4.2) implicitly acknowledges that task-family identification is an open problem, but no solution is developed. For the method to be practically deployable, future work would need to either (1) train the editor to infer the appropriate transformation from the raw question (closing the language-side gap without relying on task prefixes), (2) develop a lightweight task classifier that selects $p_{task}$ automatically, or (3) implement a multi-hypothesis generation-and-selection procedure where the editor produces edits under multiple possible prefixes and the verifier selects the best one. All three options add complexity and cost beyond the current system.

6.5 The Method Is Evaluated on a Narrow Set of Benchmarks with Small Self-Constructed Test Sets and No Statistical Significance Testing

The assumption or constraint. The paper evaluates ETCHR on nine benchmarks spanning five task families. Three of these benchmarks—Maze (200 questions), Frozen Lake (200 questions), and COCO Jigsaw (200 questions)—are self-constructed with small test sets. The DL3DV-2k benchmark (2,000 questions) is also self-constructed. No confidence intervals, statistical significance tests, or multi-seed evaluations are reported anywhere in the paper. All results in Tables 1–5 are single-run Pass@1 at temperature 0. The paper notes for the Nano Banana 2 comparison (Table 2) that "absolute numbers should be read as trends rather than significance-tested estimates," but this caveat applies equally to the main results in Table 1, which are not qualified as such.

The consequence. With only 200 test questions for Maze, Frozen Lake, and COCO Jigsaw, a single-question swing changes Pass@1 by 0.5 percentage points. Many of the reported gains—especially in the ablation studies—are on the order of 0.5–2.0 points, which means they could be driven by a handful of questions. For example, the +3.5 gain on COCO Jigsaw with Qwen3-VL-8B (9.5 → 13.0) represents an increase from 19 to 26 correct answers out of 200—just 7 questions. The +4.0 gain on Frozen Lake (9.5 → 13.5) is an increase from 19 to 27 correct answers—8 questions. Without confidence intervals, the reader cannot assess whether these gains are statistically reliable or could reverse under a different random seed, a slightly different train/test split (for the self-constructed benchmarks), or a different sampling of the benchmark questions. This is particularly concerning for the ablation studies (Tables 3–5) where differences are often ≤ 0.5 points (e.g., Table 5: Combined vs. Correctness-only on Perception: 80.9 vs. 80.7—a 0.2-point difference; Table 3: with vs. without reflection on Logic: 26.0 vs. 25.5—a 0.5-point difference). At a test size of 200, a 0.5-point difference is exactly one question.

What evidence exists in the paper. The paper provides no statistical evidence—no confidence intervals, no standard deviations, no significance tests, no multi-seed results. The Limitations section (Section 6) does not mention this issue. The description of the Maze, Frozen Lake, and Jigsaw benchmarks in Section 4 states only that they consist of "200 tasks" each, with no discussion of how they were sampled, whether there is a held-out validation set, or how stable the results are to resampling. The DL3DV-2k benchmark is described as "comprising 2000 questions targeting the reasoning capability over 3D perspective-transformation" with no details on construction methodology, difficulty distribution, or validation protocol. For the existing public benchmarks (V*Bench, HRBench, ChartQA, CharXiv, ViewSpatial), test set sizes are larger (500 for V*Bench, ~2500 for ChartQA, ~2000 for CharXiv), but the paper still does not report confidence intervals for performance on these benchmarks.

Mitigation status. The paper does not acknowledge or address this limitation. The Nano Banana 2 comparison caveat ("trends rather than significance-tested estimates") is the only mention of statistical rigor, and it applies only to that specific 100-sample subset comparison, not to the main results. The absence of confidence intervals is a significant methodological gap that weakens the strength of the paper's claims, particularly for the small-gain results in the ablation studies. Standard practice would be to report 95% confidence intervals (e.g., via bootstrap resampling of the test set) for all main results, or at minimum to note the standard error for benchmarks with small test sets.

6.6 The RL Reward Design Relies on a VLM-as-Judge Whose Reliability Is Not Calibrated Against Human Judgments

The assumption or constraint. The Stage II RL training uses two VLM-derived rewards: $r_{guide}$ from the understanding model $\mathcal{M}$ and $r_{correct}$ from a judge VLM $\mathcal{J}$ (Section 3.3). Both are LLM-based: $\mathcal{M}$ is Qwen3-VL-8B-Instruct, and $\mathcal{J}$ is also Qwen3-VL-8B-Instruct prompted differently. The paper acknowledges that $r_{correct}$ has a blind spot: "judge noise: $\mathcal{J}$ may accept a plausible-but-uninformative edit, or reject a correct one due to superficial visual differences." However, the paper provides no calibration of how often the judge's verdicts agree with human judgments of edit correctness. The judge prompts (Appendix A) ask binary questions (e.g., "If the red box contains valid information, reply with 1"), but there is no measurement of the judge's false positive rate (accepting invalid edits), false negative rate (rejecting valid edits), or agreement with human annotators.

The consequence. If the judge VLM has systematic biases—for example, being lenient on edits with bright, clearly visible annotations regardless of whether they highlight the correct object, or being strict on edits with subtle visual differences from the expected format—then $r_{correct}$ will provide a systematically distorted reward signal. Since $r_{correct}$ contributes half the combined reward (with $\alpha = \beta = 0.5$ in Equation 4), judge bias directly shapes the RL optimization landscape. The paper's ablation (Table 5) shows that $r_{correct}$-only training achieves nearly the same performance as the combined reward (52.20 vs. 52.56), suggesting that $r_{correct}$ is the dominant signal. If this signal is miscalibrated, the RL stage could be optimizing for edits that look verifier-pleasing rather than edits that are genuinely correct—a classic reward hacking scenario. The paper's observation that the RL gains are concentrated on perception and chart (where the judge can rely on simple heuristics like "is there a red box?") and absent on structural tasks (where correctness requires checking complex spatial constraints) is consistent with the hypothesis that the judge is rewarding surface-level edit plausibility rather than deep correctness.

What evidence exists in the paper. The paper provides no human evaluation of edit quality—no measurement of whether ETCHR's edits are judged correct by human annotators, and no measurement of how often the VLM judge agrees with human judgments. The only quality assessments are the VLM judge itself (for $r_{correct}$) and the downstream understanding model (for $r_{guide}$). This creates a circularity: the editor is optimized to satisfy the judge, and success is measured by whether the judge (or a similarly-architected model) is satisfied. The paper does not report the agreement rate between $r_{correct}$ and $r_{guide}$—if they agree 95% of the time, the rewards are redundant and the dual design provides little benefit; if they disagree frequently, the combined reward is making tradeoffs whose correctness is unknown. The judge prompts in Appendix A are task-specific and reasonably detailed (e.g., the maze prompt checks for continuity, obstacle avoidance, and four-direction movement), but there is no validation that the judge can actually perform these checks reliably.

Mitigation status. The paper acknowledges judge noise as a limitation of $r_{correct}$ in Section 3.3 ("The cost is judge noise: $\mathcal{J}$ may accept a plausible-but-uninformative edit, or reject a correct one due to superficial visual differences") but treats it as an unavoidable cost of having a ceiling-lifting reward. No calibration against human judgments is performed or proposed as future work. The variance reduction technique (stochastic decoding with $K$ queries) partially addresses random noise but does not address systematic judge bias—if the judge consistently accepts a particular type of incorrect edit, averaging multiple queries will not help. A human evaluation of edit correctness, even on a small subset (e.g., 100 edits sampled across task families), would substantially strengthen confidence in the reward design and is a notable gap in the current evaluation.

7. Implications and Future Directions

How This Work Changes the Landscape

ETCHR represents a methodological reframing rather than a paradigm shattering revolution, but the reframing it offers resolves a genuine tension in the "think with images" literature and redirects research attention toward a more productive question. The shift is this: instead of asking "can we build a single model that both understands and generates visual reasoning artifacts?"—the implicit question behind unified multimodal models—the paper asks "can we build a specialist generator that learns to produce reasoning-useful artifacts without ever touching the weights of the model that reasons over them?" The answer, demonstrated across three understanding backbones spanning 8B to 1T parameters (Table 1), is yes, and this answer carries both negative and positive implications for the field.

The negative implication: unified models are not the right bet for this problem, at least not yet. The paper's Table 1 provides stark evidence: ThinkMorph-7B and Bagel-Zebra-CoT perform substantially worse than a specialist understanding model with no visual assistance at all (44.05 and 38.27 vs. 55.95 average Pass@1). This is not a small gap—it means the unified models' own generated intermediates are net harmful, injecting noise rather than evidence into the reasoning chain. This finding, paired with the UniG2U-Bench results the paper cites (Wen et al., 2026), should cause researchers to question whether the joint optimization of understanding and generation in a single backbone is a viable path for reasoning-aware generation, or whether it forces a compromise that leaves both capabilities suboptimal. The paper does not prove that unified models can never work—scaling laws may eventually overcome the optimization tension—but it shifts the burden of proof: any future unified model making "think with images" claims should be required to demonstrate that its intermediate images are helpful rather than harmful compared to a specialist baseline.

The positive implication: the modular approach works better than previously demonstrated, but for a more interesting reason than "specialists beat generalists." The standard modularity argument—dedicated models outperform joint models on their respective tasks—is well-worn. What ETCHR demonstrates that is new is that a specialist editor can be trained to produce outputs that are generally useful to models it was never optimized against. The editor is trained with Qwen3-VL-8B providing both reward signals during RL (Section 3.3), yet it transfers gains to Gemini-3.1-Flash-Lite (+5.47) and Kimi K2.5 (+4.61) in Table 1. This is not a trivial property—it means the editor has learned to surface visual evidence in a way that is model-agnostic, not merely an artifact of overfitting to a specific understanding model's preferences. The finding suggests that training-time coupling + inference-time decoupling is a viable architectural pattern: the editor learns what constitutes reasoning-useful visual evidence by optimizing against a specific downstream model during training, but the evidence itself—a correctly placed bounding box, a valid maze path, a coherent novel viewpoint—is useful to any model with basic visual perception capabilities.

This pattern, if it generalizes, has implications beyond image editing. Any setting where a generation module produces intermediate artifacts for downstream reasoning—code generation for test-suite execution, diagram generation for geometry solving, data visualization for statistical analysis—could potentially adopt the same architecture: train the generator with rewards from a specific downstream module, then deploy it with any module that consumes the same artifact type. The key requirement is that the artifact encodes task-relevant information in a model-independent format, which images, code, and structured diagrams all satisfy.

The paper also resolves—or at least provides a vocabulary for resolving—the contradictory findings in prior "think with images" work. Why do tool-based methods succeed on chart understanding but fail on maze solving? Because their action spaces are designed for the former and cannot express the latter—a coverage limitation, not a capability limitation. Why do unified models underperform unaided baselines on perception tasks? Because their generative heads produce noisy intermediates that degrade reasoning—a fidelity limitation. Why do off-the-shelf editors work when given explicit instructions but fail when given raw questions? Because they suffer from a language-side gap (Section 2, Fig. 2a) that instruction-following training does not address. The two-gap diagnostic framework (language-side: inferring what to draw; generation-side: drawing it correctly) provides a unified language for analyzing failure modes that previously appeared as unrelated empirical phenomena. This is the paper's most durable contribution: future work on reasoning-aware generation can use the two-gap vocabulary to diagnose whether a system is failing because it cannot determine what artifact to produce, or because it cannot produce that artifact faithfully, and target interventions accordingly.

What becomes more attractive as a research direction: training specialist generation models with reasoning-aware objectives derived from downstream task performance, and deploying them as plug-and-play modules. What becomes less attractive: scaling unified multimodal models under the assumption that interleaved training will naturally yield useful intermediate images—the paper provides strong evidence that this assumption is empirically false at current scales, and the burden of proof should shift to demonstrating helpfulness rather than assuming it.

Follow-Up Research This Work Enables

Closing the generation-side gap through improved diffusion decoder reasoning. The paper's most important unresolved finding is that Stage II RL provides essentially no gain on structural tasks—Maze, Jigsaw, 3D (Table 4: +0.2, 0.0, +0.6 points respectively with Qwen3-VL-8B). The diagnosis is that GRPO's per-group sampling produces structurally similar edits that provide no meaningful ranking signal, and the paper speculates that this reflects a fundamental limitation of the DiT decoder's capacity for multi-step spatial reasoning (Section 4.2, Section 6). A direct follow-up would test whether architectural modifications to the diffusion backbone—specifically, mechanisms that allow the DiT to perform explicit spatial planning before committing to pixel-level generation—can close this gap. One concrete experiment: augment the DiT with a lightweight spatial reasoning head that predicts intermediate representations (e.g., a coarse path trajectory, a tile arrangement grid, a camera pose estimate) as auxiliary outputs during the denoising process, trained with supervised losses to the ground-truth structural representations. The hypothesis is that forcing the model to externalize its spatial reasoning into an explicit intermediate representation—before the diffusion process renders pixels—would improve generation-side fidelity on long paths and complex rearrangements. The evaluation would measure edit correctness as a function of path length (extending Fig. 2b) with and without the auxiliary head, on the Maze and Jigsaw benchmarks from the paper.

Training an editor to autonomously infer task type from raw questions, removing the $p_{task}$ dependency. The paper's Section 3.2 identifies task-level meta-prompts as necessary for disambiguating edit modality, but this requires external task labels at inference—a practical limitation for open-ended deployment (Section 6.4). A natural extension is to train the editor without $p_{task}$ prefixes, relying on the question text and input image alone to infer the appropriate transformation. This is directly testable: fine-tune FLUX.2-klein-base-9B on the same five-family corpus but with only $q$ as the prompt (no task prefix), and evaluate on the full benchmark suite. The paper's own Fig. 2a predicts that this will underperform the prefix-conditioned model, but the critical comparison is by how much—if the degradation is small, the prefix dependency is an implementation convenience rather than a fundamental requirement. If the degradation is large, the follow-up would test whether a lightweight task classifier (e.g., a linear probe on the frozen text encoder's representation of $q$) can automatically select $p_{task}$ with sufficient accuracy to recover most of the prefix-conditioned performance. The evaluation metric is Pass@1 compared against the prefix-conditioned upper bound and the no-prefix lower bound.

Evaluating whether multi-task training is necessary for cross-task generalization, or whether single-task specialists achieve comparable performance. The paper argues in Section 3.2 that five-family multi-task training "forces the editor to acquire a meta-capability of inferring what visual transformation each question demands" and prevents "collapse onto a single edit template." This claim is plausible but untested. A direct ablation would train five separate editors—each fine-tuned on only one task family (perception, chart, logic, jigsaw, 3D)—using the same SFT recipe and LoRA configuration, and compare their performance against the multi-task editor on their respective in-family benchmarks. If the single-task specialists match the multi-task editor on their own families, the multi-task claim is unsupported—the editor is simply learning five independent mappings cued by the prefix. If the single-task specialists underperform (particularly on families with limited training data), multi-task training provides genuine cross-task benefit through shared representations. A stronger test would evaluate each single-task specialist on out-of-family benchmarks—does a perception-only editor, when prompted with a perception prefix, produce useful edits on chart questions? This would measure whether the question-to-edit mapping generalizes across task types or is task-specific.

Replacing VLM-as-Judge rewards with ground-truth verification where available to quantify judge noise. The $r_{correct}$ reward relies on a VLM judge whose reliability is uncalibrated against human judgments (Section 6.6). For tasks where ground-truth edit correctness can be automatically verified—maze paths (check connectivity and obstacle avoidance algorithmically), jigsaw restorations (compare against known correct arrangement), bounding boxes (check IoU with annotated ground-truth boxes)—a follow-up study would replace $r_{correct}$ with programmatic correctness checks during RL training, and measure how the RL gains change compared to the VLM-judge condition. The hypothesis is that removing judge noise would amplify RL gains, particularly on structural tasks where the paper speculates judge reliability is low. The experiment would use the same RL setup (Pref-GRPO, same hyperparameters) with $r_{correct}$ computed deterministically from ground-truth annotations on the training set, and compare against the VLM-judge baseline from Table 5. If deterministic rewards substantially improve RL gains on Maze, Jigsaw, and 3D, it would confirm that judge noise is the bottleneck and motivate investment in better automated verification. If deterministic rewards provide similar gains to VLM-judge, then the generation-side gap is the bottleneck regardless of reward quality.

Stress-testing the plug-and-play claim with understanding models that have substantially different visual encoders. The paper demonstrates transfer from Qwen3-VL-8B (used during RL training) to Gemini-3.1-Flash-Lite and Kimi K2.5, but all three are strong contemporary MLLMs with similar architectural principles (vision transformer + LLM). A more stringent test of the model-agnostic claim would evaluate ETCHR with understanding models that use different visual processing paradigms: a model with a CNN-based visual encoder (e.g., an older LLaVA variant), a model that operates at very different input resolutions, or a model fine-tuned on domain-specific data that may have different visual priors. The hypothesis is that ETCHR's edits encode visual evidence in a format (bounding boxes, highlighted paths, restored images) that is robust to encoder variation because the evidence is spatially explicit—a red box over an object is a red box over an object regardless of how the downstream model processes it. Confirming this with diverse encoder architectures would strengthen the plug-and-play claim considerably. The evaluation would measure Pass@1 with each test model, using the same ETCHR editor without any per-model adaptation.

Developing selective verification policies gated by model confidence or task difficulty. The ablation in Table 3 shows that reflection helps on Perception and Chart (where baseline accuracy is ~80%) but provides negligible or negative value on Logic and 3D (where baseline accuracy is ~20-50%). This suggests a straightforward improvement: apply verification only when the understanding model's confidence (or the task family's average difficulty) exceeds a threshold. A concrete experiment would measure the model's calibration on the verification task—how often does verification correctly predict whether the edit will lead to a correct answer?—and then implement a gating policy that skips verification when the model's confidence in its own answer from the original image is below a threshold (indicating that even imperfect edits are better than guessing). The evaluation metric is Pass@1 compared against the uniform-verification baseline from Table 3, with the threshold tuned on a held-out validation set. This is an ablation that the paper's own data suggests would yield gains, and it requires no retraining—only a change to the inference pipeline.

Practical Applications and Downstream Use Cases

Enhancing visual question answering for fine-grained detail in high-stakes applications. The most immediate deployment scenario is any setting where a question depends on a small or easily missed visual detail, and the cost of an incorrect answer is high. Medical image analysis is a canonical example: a radiologist asks "Is there a micronodule in the upper right lobe?" on a high-resolution CT scan, where the finding may occupy <1% of the image area. An MLLM without visual assistance might miss the nodule because its visual encoder does not allocate sufficient representational resolution to that region. ETCHR, with a perception-appropriate $p_{task}$, would draw a bounding box around the candidate region, transforming the question from "find a tiny object in a large image" (hard) to "is the boxed region a micronodule?" (easier). The paper's V*Bench results (86.9 with Qwen3-VL-8B + ETCHR vs. 84.8 baseline, Table 1) demonstrate this pattern on natural images, and the HRBench results (80.6 vs. 78.1 at 4K resolution) show that the benefit holds at higher resolutions where the fine-grained perception challenge is amplified. The practical value is higher accuracy on exactly the cases where errors are most consequential—the subtle findings that are easy to miss but clinically significant.

Improving chart and document understanding in automated report generation. Organizations that process large volumes of charts, graphs, and structured documents—financial analysts reading quarterly reports, researchers conducting meta-analyses, journalists fact-checking claims against source data—face the challenge of extracting precise numerical values from visual representations. An MLLM reading a chart without assistance might misread a bar height or confuse similarly-colored data series. ETCHR's chart understanding mode (ChartQA: 88.4 → 90.1 with Kimi K2.5, Table 1) highlights the specific data region relevant to each question, reducing extraction errors. The practical benefit is not just accuracy improvement (+1.7 on ChartQA with Qwen3-VL-8B, Table 1) but verifiability: the highlighted chart region provides an auditable visual record of where the model obtained its answer, enabling human reviewers to quickly confirm or reject the extraction. This addresses a key limitation of current MLLM chart reading—the answer appears without visual grounding, making errors hard to catch.

Assisting spatial reasoning in robotics and navigation interfaces. Tasks that require understanding spatial layout from a single viewpoint—"From my current position, is the red door to the left or right of the staircase?"—are fundamentally challenging because the answer depends on perspective-taking that a single image cannot provide. The paper's ViewSpatial results (57.2 with Qwen3-VL-8B + ETCHR vs. 41.1 baseline, +16.1 in Table 1) demonstrate that providing a novel viewpoint of the same scene substantially improves spatial reasoning accuracy. In a robot navigation context, this translates to: given the robot's current camera feed and a question about object locations relative to the robot's body frame, an ETCHR-style editor could synthesize an overhead or reverse-angle view that makes the spatial relations visually explicit, enabling the planner to generate correct navigation commands without performing mental rotation. The DL3DV-2k results (+8.2 with Qwen3-VL-8B, +10.5 with Kimi K2.5) show that this benefit is robust across model scales.

Data generation for self-improving visual reasoning systems. The paper's training pipeline—generating ground-truth edits for diverse question types, then training a specialist editor to produce reasoning-useful intermediates—provides a template for bootstrapping visual reasoning capability. An organization with a large corpus of questions about images (e.g., a customer support system for a visual product, an educational platform with diagram-based assessments) could: (1) use human annotators or strong MLLMs to generate ground-truth edits for a subset of questions, (2) fine-tune an editor on those (question, edit) pairs using the SFT recipe from Stage I, (3) deploy the editor to generate edits for new, unseen questions, and (4) use the downstream model's accuracy on those questions to filter high-quality edits for further training (closing the loop with self-generated data, analogous to the ReST^EM approach the paper's Appendix K explores but with better outcomes). The paper's consistent improvement across understanding models (Table 1) suggests the editor learns a transferable skill, so a single trained editor could serve multiple downstream use cases within the same organization.

When to Prefer This Method

ETCHR does not propose a tradeoff against named alternatives in a formalized decision framework—the paper compares against tool-based and unified-model approaches empirically (Table 1) but does not articulate explicit conditions for choosing one over another. The choice is implicit in the results: if the task requires visual transformations outside the predefined action space of tool-based methods (maze tracing, jigsaw restoration, viewpoint synthesis), ETCHR is applicable where tool-based methods are not. If the task is within the action space of tool-based methods (bounding-box overlay, chart region highlighting), both approaches are viable, and ETCHR's plug-and-play deployment (no understanding model fine-tuning) may be preferred when the downstream model should remain frozen. If unified models are the alternative, the paper's results strongly favor ETCHR—unified models currently perform worse than unaided baselines, while ETCHR consistently improves them. However, the paper does not formalize these tradeoffs into a decision rule, so a structured "Prefer A when... Prefer B when..." matrix would be imposing a framework the paper does not itself provide.