Think in Strokes, Not Pixels: Process-Driven Image Generation via Interleaved Reasoning

🎯 Pitch

A 7B model that iteratively plans, sketches, inspects, and refines images surpasses a 12B one-shot generator on compositional tasks, matching prior process work with 8× less data and compute. Crucially, exposing the model to its own self-sampled error trajectories during training—not just external corrections—unlocks these relational and attribute-based reasoning gains that single-pass models fail to resolve.

1. Executive Summary

This paper introduces process-driven image generation, a multi-step paradigm that decomposes image synthesis into an interleaved reasoning trajectory of textual plans, visual sketches, inspections, and refinements across a recurring four-stage cycle — Plan, Sketch, Inspect, Refine — rather than generating images in a single forward pass. Training the unified multimodal model BAGEL-7B on a trajectory dataset constructed via scene-graph subsampling (for logically ordered incremental instructions), self-sampled critique traces (for learning to detect instruction–intermediate conflicts), and image–instruction alignment pairs (for evaluating visual-textual consistency), the approach lifts BAGEL-7B from 0.79 to 0.83 (+4% absolute) on GenEval for compositional object alignment and from 0.70 to 0.76 (+6% absolute) on WISE for world knowledge reasoning, while achieving an 8× reduction in both training data and inference cost compared to the prior process-level method PARM (0.83 vs. 0.77 on GenEval with 62K vs. 688K training samples and 131 vs. 1000 inference steps). The framework establishes that supervising intermediate visual states with concrete semantic partitioning — exposing the model to its own error trajectories through self-sampled critiques rather than imposing external symbolic corrections — enables a 7B unified model to match or surpass a 12B generation-only model (FLUX.1-dev) only when the process trajectory couples textual reasoning tightly with visual feedback, with the hardest gains concentrated on relational and attribute-sensitive tasks that single-pass generation fundamentally fails to resolve.

2. Context and Motivation

The Core Problem: Single-Pass Generation Cannot Resolve Complex Visual Logic

The fundamental problem this paper addresses is that current image generation models fail on prompts requiring precise spatial reasoning, object relationships, and attribute consistency because they must resolve the entire scene in a single forward pass without any visual feedback. This is not merely a quality issue — it reflects a structural limitation in how generation is formulated. When a model generates an image in one shot, it commits to every pixel simultaneously: the placement of objects, their relative positions, colors, counts, and spatial relationships are all decided in a single denoising trajectory. There is no opportunity to inspect the developing scene, notice that a bear ended up beside a spoon rather than hovering above it, and correct the error.

The paper opens with exactly this example (Figure 1). The prompt "a bear hovering above a silver spoon" produces an image where the bear stands beside the spoon. The model has generated a plausible scene — a bear and a spoon exist — but it has violated a specific spatial relation. This is not a random failure; it is a predictable consequence of forcing the model to encode all compositional constraints into a single latent representation and decode them in one pass. The more complex the prompt, the more likely that fine-grained relations get lost in the compression.

This matters because compositional precision is not a niche requirement. Any application where users specify scenes with multiple interacting objects — product visualization, architectural rendering, instructional illustration, creative storytelling — demands that models respect spatial relations, counts, and attributes reliably. The paper's motivating examples (bear/spoon, cat/bench/mouse, bird/skateboard/cloud, all in Figure 1) are deceptively simple prompts that nevertheless expose systematic failures in single-pass generation. If models cannot handle these elementary compositions, they cannot be trusted for more complex real-world tasks.

The Gap Between Textual Reasoning and Visual Generation

A deeper structural issue underlies the single-pass problem: textual reasoning and visual generation are decoupled in existing systems, even those that claim to be "multimodal." The paper identifies three categories of approaches that all fall short of genuine interleaved reasoning:

Text-only chain-of-thought (CoT) for generation. Several works (Wei et al., 2023; Creswell et al., 2022; Feng et al., 2020) have extended chain-of-thought reasoning to image generation by having the model produce a textual plan before generating. The model might think "first I'll place the spoon, then add the bear above it" in text, then feed that plan into the image generator. The paper describes this as "visually blind" — the textual reasoning happens without access to the evolving visual state. The model cannot see whether the plan was executed correctly, cannot detect spatial misalignments in the generated output, and cannot course-correct. The reasoning is a monologue that precedes generation, not a dialogue with it.

Post-hoc refinement and verification. Another line of work applies reasoning after generation: generate an image, check it against the prompt, and if problems are detected, regenerate or edit (Qin et al., 2025; Guo et al., 2025). This is what the paper calls "outcome-based" — the reasoning operates on completed outputs, treating generation as a black box. The interleaving is limited to "repairing after generation rather than reasoning during generation." The model never sees partial states, never catches errors as they emerge, and cannot use intermediate visual information to guide its next steps. Each refinement cycle is a full regeneration rather than a targeted edit.

Multimodal CoT with static image endpoints. More recent attempts at multimodal chain-of-thought (Mitra et al., 2024; Zheng et al., 2023) alternate between text and images, but the paper argues these methods "typically treat images as static endpoints rather than intermediate states to be interpreted, critiqued, and updated." The images are outputs to be consumed, not states to be reasoned about. The model never asks "does this partially complete image match my plan?" or "should I revise what I've drawn so far?" This creates what the paper calls a "fragmented" reasoning flow that "fails to maintain coherence across steps, limiting fine-grained control over spatial relations, object dynamics, and global scene evolution."

The critical gap uniting all these approaches is the absence of genuinely interleaved reasoning where textual analysis and visual generation mutually inform each other throughout the entire process. The paper's position is that existing methods have only made reasoning adjacent to generation — before it, after it, or in parallel — but never embedded within the generative act itself.

Why Unified Multimodal Models Haven't Solved This

The paper builds on BAGEL (Deng et al., 2025), part of a recent wave of unified multimodal models that integrate understanding and generation within a single architecture — including Chameleon (Team, 2025), Emu3 (Wang et al., 2024b), Show-o (Xie et al., 2025a), Janus (Wu et al., 2024a), and Janus-Pro (Chen et al., 2025). These models represent an architectural advance: rather than piping text through an LLM into a separate diffusion model, they handle both modalities natively, which in principle should enable tighter coupling between reasoning and generation.

However, the paper observes that even these unified models "still struggle to tightly couple semantic reasoning with the generative process, limiting their ability to produce images with complex, logically structured content." The architectural capability for interleaving exists — BAGEL can autoregressively generate interleaved sequences of text and image tokens — but the training data and objectives have not been designed to exploit this capability for process-driven reasoning. The models are trained to generate final images from prompts, not to produce, inspect, and refine intermediate visual states. The gap is not architectural but procedural: the models lack training on trajectories that teach them to reason through partial states.

The Supervision Challenge: What Does a Correct Intermediate Look Like?

The paper identifies a deeper, more subtle challenge that has likely prevented prior work from tackling process-driven generation: intermediate visual states are inherently ambiguous, making them difficult to supervise. This is a genuinely hard problem that the paper's methodology is designed to solve, and understanding it is crucial to appreciating the contribution.

Consider a prompt: "A cat standing on a wooden bench, curiously looking down at a black computer mouse to the left of the bench." After one step, the model generates an image containing a bench and a cat. Is this intermediate state correct or incorrect? The answer is ambiguous: the mouse hasn't been drawn yet, but that's because we're only partway through the process, not because the model failed. The paper frames this as the challenge of distinguishing "not yet drawn" from "incorrectly omitted." A naive supervision strategy that penalizes missing objects at intermediate steps would teach the model the wrong behavior — it would learn that every intermediate state must be complete, defeating the purpose of progressive generation.

Conversely, if the intermediate state shows the mouse on the bench seat rather than on the ground to the left of the bench, that IS an error — not an incompleteness. The model needs to learn to distinguish valid intermediate progress (incomplete but on-track) from genuine errors (completed incorrectly relative to the instruction). This requires supervision that is step-aware: the critique must reference what the current step was supposed to accomplish, not just compare against the final target image.

The paper's three-part dataset construction — scene-graph subsampling for logically ordered instructions, self-sampled critique traces for detecting instruction-intermediate conflicts, and image-instruction alignment pairs for evaluating visual fidelity — is a direct response to this supervision challenge. Each component teaches the model a different aspect of process reasoning that prior work simply avoided by staying at the level of final outputs.

How This Paper Positions Itself

The paper frames its contribution as a paradigm shift from outcome-driven to process-driven generation. The key distinction is not just "multi-step" — many approaches are multi-step (iterative refinement, diffusion denoising). The distinction is that the process is explicit, interpretable, and directly supervisable. At each step, the model produces human-interpretable intermediate states: a textual plan, a visual draft, a textual critique, and a visual refinement. This contrasts with approaches like PARM (Guo et al., 2025), which operate on "blurry latent noise" in the diffusion process — states that are mathematically meaningful but semantically opaque.

The paper's ambition is not merely to improve benchmark scores but to change how image generation models reason. By training a single unified model to perform the full cycle — plan, sketch, inspect, refine — the approach makes the generation process transparent and controllable. The model externalizes its reasoning as interpretable text and its progress as inspectable images, enabling human understanding of what the model is doing and why. This connects to broader trends in AI toward process-level supervision and chain-of-thought reasoning, extending them from pure text into genuinely multimodal territory.

The choice of BAGEL-7B as the base model is strategic. At 7 billion parameters, it is small enough to fine-tune end-to-end and to demonstrate that the gains come from the process-driven paradigm rather than from model scale. The fact that this 7B model, augmented with process-driven reasoning, can match or exceed a 12B generation-only model (FLUX.1-dev) on compositional benchmarks supports the paper's core claim: how you generate matters as much as what you generate with. The efficiency comparison with PARM — achieving superior accuracy with 11× less training data and 8× less inference compute — further reinforces that semantic partitioning of the process (supervising concrete visual states) is more effective than supervising abstract latent states.

In summary, the paper positions itself at the intersection of two converging trends — unified multimodal architectures that can natively interleave text and images, and process-level reasoning that extends chain-of-thought beyond text — arguing that the missing piece is training data and objectives that teach models to use their architectural capability for genuine interleaved reasoning. The three-part dataset construction pipeline, the four-stage Plan-Sketch-Inspect-Refine cycle, and the end-to-end training of BAGEL-7B are the concrete mechanisms for filling this gap.

3. Technical Approach

3.1 Reader Orientation

This paper presents a training methodology and dataset construction pipeline that teaches a unified multimodal model — one that natively handles both text and images — to generate images through an explicit, multi-step reasoning process rather than in a single forward pass. The system solves the problem of compositional image generation failures (where objects end up in wrong spatial relationships, wrong counts, or wrong attributes) by decomposing the generation task into a recurring cycle of textual planning, visual sketching, self-inspection, and refinement, such that errors are caught and corrected mid-generation instead of being baked irreversibly into the final output.

3.2 Big-Picture Architecture (Diagram in Words)

The system has four major components that interact in a tight loop:

Unified Multimodal Backbone (BAGEL-7B) — a pretrained transformer that autoregressively generates interleaved sequences of text tokens and image tokens. It serves as the single engine for all stages: planning, drafting, inspecting, and refining. No external models (no separate LLM planner, no separate verifier) are used at inference.
Multi-Turn Generation Dataset — a training corpus of ~32K samples, each containing a text prompt plus a trajectory of 3–5 intermediate images with corresponding step-level instructions. Constructed via scene-graph subsampling to ensure logically ordered, contradiction-free incremental instructions.
Instruction-Intermediate Conflict Dataset — ~15K samples produced by self-sampling from a fine-tuned model, where GPT evaluates whether intermediate textual descriptions are consistent with the original prompt, generating both positive examples (correct intermediate descriptions) and negative examples with corrective instructions.
Image-Instruction Alignment Dataset — ~15K image-text pairs (10K negative, 5K positive) that teach the model to detect when a generated draft violates its step-level instruction, providing refinement instructions for correction.

Information flows as follows: a text prompt enters the system → the model autoregressively generates a Plan (an incremental instruction <ins> and a global scene description <des>) → the model switches to image generation mode and produces a visual Sketch conditioned on the plan → the model Inspects by comparing the instruction/intermediate against the prompt (textual conflict detection) and the image against the instruction (visual misalignment detection) → if discrepancies are found, the model emits a Refine signal with a corrective instruction and regenerates → the cycle repeats until the final image is emitted with an end-of-sequence token.

3.3 Roadmap for the Deep Dive

First, the formal framework (Equation 1 and the trajectory definition) — what the model is being trained to produce, and how the four-stage cycle maps onto the autoregressive sequence.
Second, the multi-turn generation dataset construction — how scene-graph subsampling creates logically ordered intermediate states, and why this solves the ambiguity problem.
Third, the two reasoning supervision datasets — how self-sampled critiques teach the model to detect instruction-level and image-level errors, and why self-sampling outperforms symbolic corrections.
Fourth, the training objective — how the standard autoregressive and rectified flow losses are combined to enable seamless text-image interleaving in a single model.
Fifth, the inference procedure — how the model determines trajectory length adaptively and switches modalities automatically at test time.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a methodology and training-data paper whose core idea is that a unified multimodal model can learn to generate images through an explicit, interpretable, self-correcting trajectory if trained on the right kind of interleaved reasoning traces. The key technical challenges are (a) constructing intermediate states that are unambiguous enough to supervise, (b) teaching the model to distinguish "not yet drawn" from "drawn incorrectly," and (c) enabling seamless modality switching within a single autoregressive sequence.

Formal Framework: The Interleaved Trajectory

The paper reformulates image generation as sampling from a trajectory distribution rather than a single-output distribution. Given a unified multimodal model with parameters $\theta$ , denoted $P_\theta$ , and an input text prompt $T$ (optionally with an input image $I_{\text{input}}$ for editing tasks), the model generates a sequence of alternating textual reasoning steps and intermediate visual states:

$\{s^{(1)}, v^{(1)}, s^{(2)}, v^{(2)}, ..., v^{(k)}, s^{(k)}\}, I \sim P_\theta(\cdot | T)$

where $s^{(i)}$ is the $i$ -th textual reasoning step, $v^{(i)}$ is the $i$ -th intermediate visual state, $k$ is the total number of reasoning cycles (determined adaptively by the model), and $I$ is the final completed image.

What it computes: This equation defines the output distribution the model is trained to sample from. Rather than producing $I$ directly from $T$ , the model produces a trajectory of intermediate states that progressively build toward $I$ . Each $s^{(i)}$ and $v^{(i)}$ is an explicit, interpretable artifact — text or image tokens — that can be inspected, supervised, and, if necessary, corrected in subsequent steps.

Why this form: The trajectory formulation decomposes the intractable one-shot mapping from text to image into a sequence of smaller, more manageable sub-problems. Each sub-problem involves only the incremental change specified by the current plan, conditioned on all prior context. This means the model never has to resolve the entire scene's spatial composition in a single forward pass; it builds the scene incrementally and can inspect partial results before committing to the next addition. The alternation between text and vision is essential — text provides explicit, structured control signals (what to add, where, with what attributes), while vision provides the ground truth of what has actually been rendered so far. This alternation makes the process self-grounding: the textual plan constrains the visual output, and the visual output in turn constrains the next textual plan.

The concrete four-stage cycle — Plan, Sketch, Inspect, Refine — maps onto the trajectory as follows:

$T \rightarrow s^{(1)}_{\text{plan}} \rightarrow v^{(1)}_{\text{sketch}} \rightarrow s^{(1)}_{\text{inspect}} \rightarrow v^{(1)}_{\text{refine}} \rightarrow ... \rightarrow I$

where $s^{(i)}_{\text{plan}}$ contains a step-specific painting instruction enclosed in <ins>...</ins> tags and a global scene description enclosed in <des>...</des> tags, $v^{(i)}_{\text{sketch}}$ is a rough visual draft reflecting the intended update, $s^{(i)}_{\text{inspect}}$ is a textual analysis comparing the plan and draft against the original prompt (emitting a refinement signal <refine>...</refine> if misalignment is detected), and $v^{(i)}_{\text{refine}}$ is a corrected visual update. All visual outputs are wrapped between <|vision_start|> and <|vision_end|> tokens to explicitly mark modality transitions in the autoregressive sequence.

Multi-Turn Generation Dataset: Scene-Graph Subsampling for Unambiguous Intermediates

The fundamental challenge in constructing a training dataset for process-driven generation is the ambiguity of intermediate states. If you show a partially complete image to a model and ask "is this correct?" the answer depends on what step the model is currently on. A missing object could be "not yet drawn" (correct intermediate state) or "incorrectly omitted" (error). Standard supervised learning cannot distinguish these cases without step-level context.

The paper's solution is to generate intermediate states through scene-graph subsampling, which ensures that every intermediate state is both (a) logically complete for what it claims to contain and (b) an unambiguous prefix of the final target.

Step 1: Scene graph representation. Each text prompt is parsed into a scene graph — a structured representation where nodes represent objects and their attributes, and edges represent spatial or semantic relationships between objects. For example, "a bear hovering above a silver spoon" would yield nodes for bear (with attributes like [hovering]) and spoon (with attributes like [silver]), connected by an edge above(bear, spoon).

Step 2: Subgraph subsampling into incremental steps. From the full scene graph, subgraphs are sampled in increasing order of completeness. The first subgraph might contain only the spoon and its attributes; the second adds the bear and the spatial relation. Each subgraph is converted back into a natural-language instruction that describes only the incremental change from the previous step. The paper states this "naturally expand[s] the scene in a correct and controllable order — ensuring that intermediate steps remain logically grounded" (Section 3.2). This directly addresses the ambiguity problem: at step $i$ , the model's target is the subgraph-complete image for step $i$ , not the final image. If an object is missing, it is because it hasn't been introduced yet, and the supervision signal treats this as correct.

Step 3: Ground-truth image synthesis. For each incremental prompt (each subgraph expansion), a ground-truth intermediate image is synthesized using Flux-Kontext (Labs et al., 2025) and filtered with GPT for quality. Flux-Kontext is an in-context image generation and editing model that can produce images conditioned on both a text instruction and a previous image, making it suitable for generating the sequential visual states needed for the trajectory.

Step 4: Instruction augmentation for operation diversity. Subgraph expansion alone yields only additive operations — each step adds a new object or relation. Real-world image editing involves a richer action space: modifying attributes, swapping objects, removing elements. To broaden the model's editing vocabulary, the paper augments a subset of step instructions by rewriting them with GPT. The rewritten instructions are "semantically equivalent but structurally different multi-step reasoning variants," increasing "the coverage of visual editing behaviors and encourag[ing] the model to internalize richer transformation primitives beyond simple addition" (Section 3.2).

Key design choice: why subsample the scene graph rather than randomly partition the prompt? A random partition (e.g., "first draw half the objects, then the other half") would produce incoherent intermediate states — objects without spatial context, relations without both relata present. The scene-graph structure ensures that each intermediate step is a semantically meaningful, self-contained scene. For example, you wouldn't introduce the relation above(bear, spoon) before introducing both bear and spoon. The subsampling naturally respects this dependency structure.

Dataset statistics. The Multi-Turn Generation Subset contains 32,012 total samples, with an average prompt length of 152.8 characters, an average of 3.51 images per sample, and a maximum of 5 images per sample (Table 1). Each sample is a complete trajectory: a prompt plus a sequence of 3–5 step-level instructions and corresponding intermediate images, terminating in the final image.

Instruction-Intermediate Conflict Reasoning Dataset: Teaching Textual Self-Critique

The Multi-Turn Generation dataset teaches the model to execute the Plan and Sketch stages — it learns to produce incremental instructions and generate images that follow them. However, this dataset alone does not teach the model to detect when its plans or intermediate descriptions drift from the original prompt. The model needs supervision for the Inspect and Refine stages, specifically for catching instruction-level conflicts: cases where the textual description of the current intermediate state contradicts the overall prompt.

The paper constructs this supervision through a self-sampling procedure:

Step 1: Generate trajectories from a preliminary model. First, a version of the model is fine-tuned on only the Multi-Turn Generation dataset. This produces a model that can execute multi-step generation but has not been trained to self-critique.

Step 2: Sample and evaluate intermediate states. From this preliminary model, the authors "sample generated intermediate reasoning traces that include textual descriptions of partially completed images" (Section 3.2). For each sampled trajectory, at each intermediate step, the textual description (the <des> tag content — the global scene hypothesis) is compared against the original raw prompt using GPT as a judge.

Step 3: Generate corrective feedback. When GPT identifies a conflict between the intermediate description and the prompt, it generates two things: a textual analysis explaining what is wrong, and a corrective instruction (what the description should say to be consistent with the prompt). When no conflict is found, GPT generates an explanation of why the description is consistent. This provides both positive and negative examples: the model learns not only to detect errors but also to recognize correct intermediate states and explain why they are correct.

Step 4: Fine-tune on conflict traces. The model is fine-tuned on these self-sampled trajectories, where the target output includes the inspection analysis and (if applicable) the refinement instruction. This teaches the model to perform $s^{(i)}_{\text{inspect}}$ — to look at its own intermediate textual state and ask "does this match what I was ultimately asked to produce?"

Why self-sampling rather than synthetic conflict injection? The paper argues (and demonstrates in the ablation study, Table 6) that self-sampling is superior to "symbolic corrections" derived from the scene graph. Symbolic corrections target a specific object, attribute, or relation and produce a generic critique (e.g., "the spoon should be silver, not gold"). Self-sampled critiques, by contrast, reflect the model's actual failure modes — the specific ways it tends to drift from prompts in practice. The critique data is in-distribution for the model, making the supervision signal more aligned with the model's internal reasoning dynamics and therefore more learnable.

Dataset statistics. The Instruction-Intermediate Conflict Subset contains 15,201 total samples, with 6,905 positive samples (correct intermediate descriptions with explanations) and 8,296 negative samples (conflicts with corrective instructions) (Table 1).

Image-Instruction Alignment Reasoning Dataset: Teaching Visual Self-Critique

The second reasoning supervision dataset addresses a complementary failure mode: cases where the textual plan is correct (consistent with the overall prompt), but the generated image fails to execute it properly. The model needs to learn to compare $v^{(i)}_{\text{sketch}}$ against the step-level instruction and detect visual misalignments — e.g., the instruction says "add a mouse on the ground to the left of the bench," but the image shows a mouse on the bench seat.

The paper constructs this dataset by extending and refining an existing resource:

Source dataset. The authors build on Gen-Ref (Zhuo et al., 2025), a dataset originally designed for reflection tuning in image generation. Gen-Ref contains image-text pairs with annotations about whether the image correctly reflects the text instruction.

Annotation into two categories. The paper extends and refines Gen-Ref into two annotated categories:

Positive samples (5,000): cases where the image is consistent with the instruction. For these, GPT generates an explanation of why the alignment holds — e.g., "the mouse is correctly positioned on the ground to the left of the bench, matching the spatial specification in the instruction." This teaches the model to recognize correct execution and articulate the evidence.
Negative samples (10,000): cases where the image misaligns with the instruction. For these, GPT provides both an error analysis ("the mouse appears on the bench seat rather than on the ground to the left") and a refinement instruction ("remove the mouse from the seat and add a mouse on the ground, to the left of the bench").

The asymmetry in sample counts (twice as many negative as positive) reflects the practical reality that detecting and correcting errors is harder and requires more training signal than confirming correct execution.

Key design choice: why separate instruction-level and image-level supervision? The paper's ablation study (Table 7) demonstrates that these two types of intermediate supervision address distinct failure modes. Instruction-intermediate conflict supervision primarily improves semantic and spatial consistency (e.g., +5% on Position), while image-instruction alignment supervision improves visually grounded reasoning (e.g., +12% on Counting). Combining both yields the best overall performance because the model learns to check its work at both the semantic (textual) and visual (image-text) levels, catching errors that might slip through only one check.

Dataset statistics. The Image-Instruction Alignment Subset contains 15,000 total samples, with 5,000 positive samples and 10,000 negative samples (Table 1).

Training Objective: Seamless Text-Image Interleaving in a Single Model

The model must be trained to generate both text tokens (plans, inspections, refinements) and image tokens (sketches, refined outputs) within a single autoregressive sequence, switching modalities based on context. The paper adopts BAGEL-7B's architecture and extends its training objective to support process-driven generation.

Text generation loss. For textual segments $s^{(i)}$ , the model is trained with standard autoregressive cross-entropy loss:

$\mathcal{L}^{\text{text}}_{\text{CE}} = - \sum_{t \in [1,i]} \log P_\theta\left(s_t \mid y_{<t}, T\right)$

where $s_t$ is the $t$ -th text token in the current textual reasoning step, $y_{<t}$ represents all preceding tokens (both text and vision) in the interleaved sequence, $T$ is the input prompt, and $P_\theta$ is the model's predicted probability for the correct next token.

What it computes: This is the standard next-token prediction loss for autoregressive language modeling, applied only to positions corresponding to text tokens. At each text position $t$ , the model receives all prior context (the prompt plus all previous plans, images, inspections, and refinements) and must predict the next text token. The log probability of the correct token is negated and summed across all text positions, producing a scalar loss that is minimized when the model assigns high probability to the ground-truth textual reasoning sequence.

Why this form: Autoregressive cross-entropy is the de facto standard for training language models because it is the maximum-likelihood objective for sequential discrete data. Applied here to interleaved sequences, it forces the model to learn the dependencies between successive reasoning steps: the inspection text must be conditioned on the sketch image, the refinement instruction must be conditioned on the inspection analysis, and so on. The loss is only applied to text tokens (not image tokens) to avoid conflating the discrete text prediction objective with the continuous image generation objective.

Modality-switching tokens. To enable the model to seamlessly transition between text and image generation, the paper adds a loss term on the special tokens <|vision_start|> and <|vision_end|> that mark modality boundaries. These tokens are part of the text vocabulary, so the cross-entropy loss naturally applies to them. By training the model to predict when to start and end image generation based on prior context, the model learns to autonomously regulate its own interleaving behavior.

Image generation loss. For image segments, the paper follows BAGEL's approach of using the rectified flow paradigm (Liu et al., 2022) rather than discrete token prediction. Rectified flow models image generation as learning a velocity field that transports samples from a noise distribution to the data distribution along straight-line paths. Formally, given a clean image latent $z^{(i)}_0$ and a noise sample $z^{(i)}_1 \sim \mathcal{N}(0, I)$ , the intermediate state at time $t \in [0, 1]$ is defined by linear interpolation:

$z^{(i)}_t = t \cdot z^{(i)}_0 + (1 - t) \cdot z^{(i)}_1$

where $z^{(i)}_t$ is the noisy latent at interpolation time $t$ for the $i$ -th intermediate visual state, $z^{(i)}_0$ is the clean latent (the target image encoded into latent space), and $z^{(i)}_1$ is pure Gaussian noise.

What it computes: This equation defines a straight-line path from noise to data. When $t = 0$ , $z^{(i)}_0$ is the clean image latent (what we want to generate). When $t = 1$ , $z^{(i)}_1$ is pure noise. At intermediate times, $z^{(i)}_t$ is a blend: more noise when $t$ is small, more signal when $t$ is large. The model is trained to predict the velocity (direction and magnitude) along this path, which, when integrated from $t = 0$ to $t = 1$ during inference, transports a noise sample to the target image.

Why this form: Rectified flow offers two advantages over standard diffusion. First, the straight-line paths require fewer integration steps during inference because the trajectory is simpler (no curvature). Second, the velocity prediction task is easier to learn because the target — the difference $z^{(i)}_0 - z^{(i)}_1$ — is constant along the path, whereas diffusion models must predict the noise $\epsilon$ which is path-dependent. This aligns with practical efficiency: process-driven generation produces multiple images per prompt, so reducing per-image inference cost is critical.

The image loss is mean squared error between the model's predicted velocity and the true velocity:

$\mathcal{L}^{\text{image}}_{\text{MSE}} = \mathbb{E}\left[ \left\| P_\theta\left(z^{(i)}_t \mid y_{<t}, T\right) - (z^{(i)}_0 - z^{(i)}_1) \right\|^2 \right]$

where $P_\theta(z^{(i)}_t \mid y_{<t}, T)$ is the model's predicted velocity conditioned on all prior interleaved context (text and vision tokens before the current image segment) and the original prompt, and $(z^{(i)}_0 - z^{(i)}_1)$ is the ground-truth velocity (the direction from noise to clean latent).

What it computes: The expectation is taken over training samples, noise samples $z^{(i)}_1$ , and interpolation times $t$ . For each training example, a random $t$ is sampled, the corresponding $z^{(i)}_t$ is computed via linear interpolation, the model predicts the velocity given this noisy latent and all prior context, and the squared error between predicted and true velocity is computed. Minimizing this loss teaches the model to produce the correct denoising direction at every point along the path.

Why this form: MSE is the standard regression loss for continuous targets. The velocity formulation — predicting the direction to the clean latent rather than the noise — is a direct consequence of the rectified flow framework. An alternative would be noise prediction (as in standard diffusion), but the velocity formulation is simpler because the target is independent of $t$ : the vector from noise to data is the same regardless of where you are on the path. This reduces the variance of the training signal.

Combined loss. The total training objective is a weighted combination:

$\mathcal{L}_{\text{total}} = \lambda_{\text{CE}} \cdot \mathcal{L}^{\text{text}}_{\text{CE}} + \mathcal{L}^{\text{image}}_{\text{MSE}}$

where $\lambda_{\text{CE}}$ is a scaling coefficient to balance the magnitudes of the cross-entropy loss (computed over discrete tokens) and the MSE loss (computed over continuous latent vectors). The paper does not specify the exact value of $\lambda_{\text{CE}}$ , but its existence as a hyperparameter indicates that balancing these two losses — which operate on fundamentally different scales and units — requires tuning.

Key design choice: why a single unified model rather than separate text and image modules? Many prior systems use a large language model for planning and a separate diffusion model for generation (e.g., DALL-E 3's caption upsampling + diffusion). The paper argues this decoupling "prevents the model from fully leveraging its understanding capability during generation." When the planner and generator are separate models, the planner cannot see what the generator actually produced, and the generator cannot ask the planner for clarification. A single model that autoregressively produces both modalities has full access to all prior context for every prediction, enabling true mutual grounding. The cost is architectural complexity — the model must handle both discrete token prediction and continuous latent prediction — but this complexity is the point: it is what enables the interleaved reasoning that drives the performance gains.

Inference Procedure: Adaptive Trajectory Generation

At inference time, the model generates the interleaved reasoning trajectory autonomously, without external guidance. The procedure is:

Input. The model receives a text prompt $T$ (and optionally an input image $I_{\text{input}}$ for editing tasks). No additional instructions about how many steps to take or what to plan are provided — the model has been trained to produce the full trajectory from the prompt alone.

Autoregressive generation. The model generates tokens sequentially, producing text and images in an interleaved fashion. When the model emits a <|vision_start|> token, it switches to image generation mode. In this mode, it uses the rectified flow sampling procedure: starting from random noise $z^{(i)}_1$ , it iteratively integrates the predicted velocity field to arrive at the clean latent $z^{(i)}_0$ , which is then decoded to pixel space. When the image is complete, the model emits a <|vision_end|> token and returns to text generation mode.

Adaptive trajectory length. The paper states that the model "autonomously determines the trajectory length based on task difficulty" (Section 4.3). For simple prompts that require few compositional elements, the model may produce only 1–2 cycles before emitting the final image. For complex prompts, it may produce 4–5 cycles. The average number of reasoning steps per image is reported as 2.62, with a total inference cost of 131 sampling steps on average (compared to PARM's 1000 steps).

Termination condition. The process terminates when the model emits a <|vision_end|> token without a following <|vision_start|> token. This signals that the model considers the image complete and is not planning further refinements. The final image $I$ is the last visual state produced.

Why adaptive length? Fixed-length trajectories would be wasteful for simple prompts (spending compute on unnecessary inspection and refinement) and insufficient for complex prompts (not enough cycles to resolve all compositional constraints). The model's ability to decide when to stop is learned from the training data: trajectories vary in length, and the model observes the conditions under which refinement cycles are productive versus unnecessary.

Inference cost calculation. The paper reports an average of 131 sampling steps per image, which is calculated based on an average of 2.62 reasoning steps per image. This cost accounts for all the rectified flow integration steps across all intermediate images and the final image. For comparison, PARM uses a Best-of-20 search strategy that requires 1000 cumulative sampling steps. The 8× reduction in inference cost is a direct consequence of semantic partitioning: by working with concrete visual states rather than blurry latent noise, the model can decide when refinement is actually needed rather than exhaustively searching over many latent candidates.

Summary of Design Choices and Their Justifications

Scene-graph subsampling over random prompt partitioning: ensures intermediate states are semantically meaningful and logically ordered, eliminating the ambiguity problem where missing objects could be "not yet drawn" or "incorrectly omitted."
Instruction augmentation with GPT over pure additive operations: exposes the model to diverse editing primitives (modify, swap, remove) that enable it to handle corrections during the Refine stage, not just progressive addition.
Self-sampled critiques over symbolic scene-graph corrections: critiques reflect the model's actual error distribution, making the supervision signal in-distribution and more learnable. The ablation study (Table 6) shows this yields substantially larger gains (+0.05 on Color, +0.02 on Position, +0.02 on Color Attribute vs. symbolic corrections).
Dual-stream process-critique data (instruction-level + image-level) over a single critique type: addresses distinct failure modes — textual plan drift vs. visual execution failure — that require different corrective strategies.
Unified autoregressive + rectified flow training over separate text and image models: enables the model to condition every prediction on full prior context, creating genuine mutual grounding between textual reasoning and visual generation.
Adaptive trajectory length over fixed-step generation: lets the model allocate compute proportional to task difficulty, achieving 8× inference cost reduction over PARM's fixed Best-of-20 search.
Asymmetric positive/negative sampling (10K negative vs. 5K positive in Image-Instruction Alignment): recognizes that detecting and correcting errors is harder and requires more training signal than confirming correctness.

4. Key Insights and Innovations

Innovation 1: Semantic Partitioning as a Superior Process Representation Over Latent-Space Supervision

The paper's most distinctive conceptual move is its definition of what constitutes a "process" in image generation, and its demonstration that supervising concrete, human-interpretable intermediate states — actual images with visible objects and relations — is fundamentally more effective than supervising abstract latent representations. This is not a minor implementation choice; it is a reframing of where the reasoning should happen.

Prior work on process-level image generation, exemplified by PARM (Guo et al., 2025), operated on the diffusion latent space. In that paradigm, "intermediate states" are blurry, partially denoised latents — mathematically meaningful as waypoints on the path from noise to image, but semantically opaque. A critic evaluating such a state cannot point to a missing object or a misplaced relation because nothing is visually concrete yet. PARM's approach is to train a verifier to predict whether a given noisy latent will eventually lead to a prompt-satisfying image, then use that verifier to guide search (Best-of-20) over candidate latents. The process is implicit — the reasoning about correctness is embedded in the verifier's scores on abstract representations, never surfaced as interpretable steps.

This paper argues, through its architecture and results, that this is the wrong locus of supervision. By instead defining the process in terms of semantic partitioning — where each step corresponds to the introduction, modification, or removal of a semantically meaningful visual element (an object, an attribute, a spatial relation) — the intermediate states become directly inspectable. The model can look at a partially complete image and reason "the mouse is on the bench seat, but the instruction says to the left of the bench." This kind of spatially grounded error detection is impossible in latent space because there is no "mouse" or "bench" to point to — only tensors.

The evidence for this being a genuine conceptual advance rather than an implementation detail is the efficiency comparison in Table 4. The approach achieves 0.83 GenEval accuracy (vs. PARM's 0.77) while using 11× less training data (62K vs. 688K samples) and 8× less inference compute (131 vs. 1000 sampling steps). These are not marginal improvements; they are order-of-magnitude efficiency gains. The 8× inference speedup is particularly revealing: PARM's Best-of-20 search over latent candidates is expensive precisely because the verifier must evaluate 20 different blurry latents to find a good one, whereas semantic partitioning lets the model decide adaptively when refinement is needed (averaging only 2.62 reasoning steps per image). The model doesn't search over alternatives — it thinks through the problem.

This reframing has implications beyond this paper. It suggests that the broader trend of applying chain-of-thought and process supervision to generative models should target the semantic level — where states correspond to meaningful compositional choices — rather than the representational level — where states are mathematical intermediates. The paper's approach is fundamentally a complexity-adaptive reasoning strategy: easy prompts require few compositional decisions and therefore few steps; hard prompts require more. Latent-space search, by contrast, applies uniform computation regardless of difficulty because the verifier has no semantic understanding of what makes a prompt hard. This connection between semantic process supervision and adaptive computation is a conceptual contribution that extends beyond image generation to any domain where outputs have compositional structure.

Innovation 2: Self-Sampled Error Traces as a Distribution-Aware Alternative to Synthetic Correction Data

The second conceptual innovation is methodological but has deep implications for how process-supervision data should be constructed. The paper demonstrates that supervision signals derived from the model's own failure distribution significantly outperform externally imposed correction patterns, even when those external patterns are logically valid.

The standard approach to teaching models to self-correct would be to generate synthetic error-correction pairs: take a correct output, introduce a controlled error (e.g., by swapping an attribute, moving an object, or deleting a relation), and train the model to detect and fix that error. The paper implements this as the "symbolic corrections" baseline in the ablation study (Table 6): corrections are derived from the scene graph by targeting a specific object, attribute, or relation and producing a corresponding critique. This is clean, controllable, and guarantees balanced coverage of error types.

The counterintuitive finding — and the paper's key methodological insight — is that self-sampled critiques substantially outperform symbolic corrections (+5 points on Color, +2 points on Position, +2 points on Color Attribute). The reason, as the paper argues, is that self-sampling operates in the model's own distribution. The errors the model actually makes — the specific ways it drifts from prompts, the particular spatial misplacements it tends toward, the attribute confusions it is prone to — are not uniformly distributed across all possible errors. A synthetic dataset that samples errors uniformly from a scene-graph ontology will spend training signal on error types the model rarely makes and undersample the error types it frequently makes. Self-sampling, by generating trajectories from a preliminary model and having GPT evaluate them, naturally concentrates the supervision signal on the model's actual failure modes.

This is more than a data augmentation trick. It represents a distribution-matching principle for critique supervision that has not been articulated in prior work on self-correction and reflection tuning. The insight is that for a model to learn to detect and correct its own errors, the training distribution of errors must match the model's inference-time error distribution. Synthetic error injection — no matter how carefully designed — creates a distributional mismatch that limits transfer. This principle likely generalizes beyond image generation to any domain where models are trained to self-critique: code generation (where self-sampled buggy code would better reflect real bug patterns than synthetic bugs), mathematical reasoning (where self-sampled proof errors would match real reasoning gaps), and dialogue (where self-sampled inconsistencies would reflect genuine conversational failure modes).

The paper's dual-stream design — instruction-intermediate conflict traces for textual drift AND image-instruction alignment pairs for visual execution failure — further refines this principle by showing that different failure modes require different critique data sources. Textual drift from the prompt is best caught by self-sampling from the generation model and evaluating with GPT (the Instruction-Intermediate Conflict subset). Visual misalignment with the step instruction is best caught by extending existing alignment datasets (the Image-Instruction Alignment subset, built on Gen-Ref). This decomposition of critique types and their corresponding data sources is a diagnostic contribution: it identifies what kind of supervision is needed for what kind of error, rather than treating all process supervision as homogeneous.

Innovation 3: Tightly Coupled Text-Vision Co-Evolution as a Distinct Reasoning Mode

The paper introduces a genuinely new mode of multimodal reasoning that is categorically different from the three paradigms that preceded it. Understanding this distinction requires mapping the space of how text and images interact during generation:

Pre-generation reasoning (text → image). The model produces a textual plan, then generates an image conditioned on that plan. The image never feeds back into the reasoning. This is what chain-of-thought approaches for image generation do (Liao et al., 2025; ImageGen-CoT). The reasoning is a monologue that happens before the visual act.

Post-generation reasoning (image → text → image). The model generates an image, inspects it, and if problems are found, regenerates or edits. This is what reflection-based approaches do (Qin et al., 2025; Zhuo et al., 2025). The reasoning is a critique of a finished product, and any revision is a new generation task.

Parallel reasoning (text + image simultaneously). The model produces text and image tokens in the same sequence, but the text describes or annotates the image rather than guiding its construction. This is what multimodal CoT approaches do (Mitra et al., 2024). The reasoning is commentary on what exists, not planning for what should exist next.

The paper's process-driven paradigm introduces a fourth mode: co-evolving reasoning, where text and vision mutually constrain each other in a tight loop. The textual plan specifies what the next visual state should contain. The visual state, once generated, provides ground truth about what is actually present. The textual inspection compares this ground truth against the plan and the original prompt. The textual refinement specifies a correction. The visual refinement executes it. Then the cycle repeats, with each iteration building on all prior text and vision context.

This is not simply "multi-step generation" — many systems are multi-step. The distinction is that the reasoning is not adjacent to generation but embedded within it. The model does not plan entirely upfront, generate entirely separately, and then inspect only at the end. It plans a little, generates a little, inspects what it generated, refines if needed, and then plans the next increment. The paper's four-stage cycle (Plan → Sketch → Inspect → Refine) is an instantiation of this co-evolution principle, but the principle itself is more general: any task requiring compositional output with spatial or structural constraints can benefit from alternating between explicit planning and concrete execution with inspection-based feedback.

The evidence that this is a distinct and important reasoning mode comes from the ablation in Table 4, which compares the approach to two training-free baselines that attempt to achieve similar effects with external tools. Using GPT-4o as an external planner for the base BAGEL model causes a 23% performance collapse (0.83 → 0.60 on GenEval). Using GPT-4o as an external inspector for single-round refinement provides only marginal gains over the base model (0.80 vs. 0.77). The planning baseline fails because the base model, not having been trained to ground incremental instructions into stable visual intermediates, cannot consistently execute multi-step plans — the plans are sensible textually but the model cannot translate them into precise visual updates. The inspection baseline fails for a subtler reason: verbal feedback ("the mouse is in the wrong place") does not translate into precise visual corrections unless the model's generative path has been aligned through process-level training. The model may understand the feedback textually but cannot map it to the exact visual editing operations needed.

The success of the full approach — where planning, generation, inspection, and refinement are all handled by a single model trained end-to-end on interleaved trajectories — demonstrates that these capabilities cannot be bolted on externally. They must be internalized through training data that mirrors the desired inference-time behavior. The model learns to plan in a way that its own generator can execute, and to inspect in a way that its own refiner can act on. This co-adaptation of the planner, generator, inspector, and refiner is what makes the system work, and it cannot be achieved by composing independently trained modules. This finding has implications for the broader debate about modular vs. monolithic architectures in multimodal AI: for tightly coupled reasoning where each step depends on the outputs of the previous step in a modality-specific way, end-to-end training of a unified model may be necessary, not merely convenient.

Innovation 4: Distinguishing "Not Yet Drawn" from "Incorrectly Drawn" as a Core Process-Supervision Challenge

The paper identifies and solves a diagnostic problem that has been latent in process-supervision research but rarely articulated explicitly: how do you supervise intermediate states when incompleteness and incorrectness are confounded? This is the ambiguity problem at the heart of the paper's motivation, and the scene-graph subsampling solution represents a conceptual contribution to the methodology of process-supervision data construction.

In most process-supervision settings — mathematical reasoning (process reward models for math), code generation (step-by-step verification), planning (subgoal evaluation) — intermediate states can be evaluated against a ground-truth prefix of the solution. A partially complete math proof either follows a valid logical path toward the solution or it doesn't. A partially complete code snippet either compiles and passes intermediate tests or it doesn't. The correctness of an intermediate state is well-defined relative to the final answer.

Image generation breaks this assumption. A partially complete image is not a prefix of the final image in any well-defined sense. If the image shows a bench and a cat but no mouse, this could be because (a) the mouse hasn't been drawn yet and the intermediate state is correct for step 1, or (b) the mouse was supposed to be drawn in step 1 but was incorrectly omitted. The same visual state can be correct or incorrect depending on what step it represents. Standard supervised learning, which maps inputs to correctness labels, cannot handle this context-dependent evaluation without step-level conditioning.

The paper's scene-graph subsampling approach solves this by making the step-level target explicit and guaranteed to be correct. Each incremental instruction is derived from a subgraph that is, by construction, a valid subset of the full scene graph. The ground-truth intermediate image is generated from this subgraph, so it contains exactly and only what the subgraph specifies — no more, no less. When the model is trained to produce this intermediate image from this incremental instruction, there is no ambiguity: the correctness of the intermediate output is defined relative to the subgraph specification, not relative to the final prompt. The model learns that at step $i$ , it should produce an image matching subgraph $i$ , even though subgraph $i$ is incomplete relative to the full prompt.

This is not merely a data construction trick. It is a formal solution to the confound between progress and error in generative process supervision. It works because the scene graph provides a compositional decomposition of the final target into independently specifiable and independently renderable sub-components. The subgraph abstraction ensures that each step's target is self-contained and semantically meaningful — you would never have an intermediate target that says "draw half a cat" or "draw a spoon without specifying its attributes."

The broader significance of this insight is that process-supervision data for generative tasks requires a compositional representation of the output that can be decomposed into independently valid prefixes. For image generation, scene graphs provide this decomposition because they break the scene into objects, attributes, and relations that can be introduced incrementally. For other generative domains, analogous representations would be needed: for code generation, a dependency graph of functions that can be implemented in topological order; for text generation, an outline or entity-relation structure that can be expanded section by section; for 3D scene generation, a spatial hierarchy that allows progressive detailing. The paper's methodology generalizes: find a compositional representation of the target output, subsample prefixes that are semantically self-contained, generate ground-truth intermediate states from those prefixes, and train the model to produce those states in order. This is a blueprint for extending process-driven generation beyond 2D images.

5. Experimental Analysis

Evaluation Methodology

Dataset. The paper evaluates on two benchmarks: GenEval (Ghosh et al., 2023), which assesses compositional text-to-image generation across six object-centric attributes (Single Object, Two Objects, Counting, Colors, Position, Color Attributes), and WISE (Niu et al., 2025), which evaluates world knowledge reasoning across six domains (Culture, Time, Space, Biology, Physics, Chemistry). GenEval is the primary benchmark for compositional alignment; WISE tests whether the model integrates structured semantic knowledge into generation. The paper does not specify test set sizes, but the original GenEval paper defines evaluation prompts per attribute category, and WISE provides domain-specific prompts. No custom splits are created — the standard benchmark evaluation protocols are used.
Base model(s). All experiments use BAGEL-7B (Deng et al., 2025), a unified multimodal model with 7 billion parameters that natively handles both text understanding and image generation within a single autoregressive-plus-rectified-flow architecture. The paper states it chose BAGEL because it is "representative of the capabilities of many contemporary LLMs" and operates in a regime where the architectural capability for interleaved text-image generation exists but the training data and objectives for process-driven reasoning do not. The 7B scale is strategic: it demonstrates that performance gains come from the process-driven paradigm, not from model scale, and enables fair comparison with other 7B unified models (Janus-Pro-7B, Show-o2) as well as the 12B generation-only model FLUX.1-dev. For the FLOPs-matched comparison against PARM, the same BAGEL-7B backbone is used, with PARM representing an alternative process-level approach applied to diffusion models. The paper also reports reproducing BAGEL-7B's baseline results from the official repository and checkpoint (marked with an asterisk in Table 2: BAGEL-7B* at 0.77 overall GenEval, versus the paper's reported 0.79 — the 0.79 appears to be the paper's own multi-turn generation baseline before full process-driven training).
Metrics. For GenEval, the metric is accuracy — the fraction of generated images that satisfy the prompt's compositional constraints, evaluated per attribute category and averaged into an overall score. Each category tests a specific compositional skill: Single Object (whether a single specified object appears), Two Objects (whether two specified objects both appear), Counting (whether the correct number of objects is generated), Colors (whether objects have correct colors), Position (whether spatial relations like "left of" or "above" are respected), and Color Attributes (whether objects have both correct colors and correct types). For WISE, the metric is similarly accuracy per domain and overall, evaluating whether the generated image reflects the world knowledge specified in the prompt (e.g., temporal concepts, scientific phenomena, cultural artifacts). The paper does not detail the grading procedure for either benchmark, referencing the original GenEval and WISE papers for evaluation protocols.
Baselines. The paper compares against an extensive set of baselines spanning three categories. Generation-only models: PixArt-Σ (Chen et al., 2024), SDv2.1 (Rombach et al., 2022b), DALL-E 2 (Ramesh et al., 2022), SDXL (Podell et al., 2023), DALL-E 3 (Betker et al.), SD3-Medium (Esser et al., 2024), FLUX.1-dev (12B) (Labs et al., 2025), SDv1.5 (Rombach et al., 2022a), SD3.5-large (Esser et al., 2024), Playground-v2.5 (Li et al., 2024). Unified multimodal models: Chameleon (Team, 2025), LWM (Liu et al., 2025), SEED-X (Ge et al., 2025), TokenFlow-XL (Qu et al., 2025), ILLUME (Wang et al., 2024a), Transfusion (Zhou et al., 2024a), Emu3-Gen (Wang et al., 2024b), Janus (Wu et al., 2024a), Janus-Pro-7B (Chen et al., 2025), Show-o (Xie et al., 2025a), Show-o2 (Xie et al., 2025b), VILA-U (Wu et al., 2025a), MetaQuery (Pan et al., 2025). Process-based baselines (Table 4 only): BAGEL + GPT (Planner), where GPT-4o provides step-by-step instructions for multi-turn generation by the vanilla BAGEL model; BAGEL + GPT (Inspector), where BAGEL performs single-round refinement conditioned on verbal feedback from GPT-4o about inconsistencies; PARM (Guo et al., 2025) in two variants — TTS (Tree-search with Trained verifier Selection) using 400K training samples and RL + TTS (reinforcement learning plus tree search) using 688K training samples. The baseline selection is comprehensive for unified multimodal models, covering most major published systems at the time of writing, though generation-only baselines serve more as reference points than direct competitors (since they lack understanding capabilities).
Generation budget / compute accounting. For the main benchmark results (Tables 2 and 3), the paper does not explicitly constrain a generation budget — the model adaptively determines its own trajectory length. For the efficiency comparison in Table 4, compute is measured in cumulative sampling steps required to synthesize the final image. For PARM, this is 1000 steps (Best-of-20 search, where each of 20 candidates requires ~50 denoising steps). For the process-driven approach, the average is 131 steps (2.62 reasoning steps per image, with each visual state requiring rectified flow integration). Training data efficiency is measured in number of fine-tuning samples: 62K for the process-driven approach versus 688K for PARM (RL + TTS) and 400K for PARM (TTS). The paper does not detail how sampling steps are counted for the rectified flow inference (number of integration steps, whether adaptive step sizes are used, or whether classifier-free guidance adds additional forward passes), making this cost comparison approximate. The training cost in GPU-hours is also not reported — only the number of samples and infrastructure (8× NVIDIA H100 GPUs, 10,000 steps, packed sequence length of 33,000 tokens, learning rate 2×10⁻⁵ with cosine decay) are specified.
Cross-validation / statistical protocol. The paper reports no cross-validation, no confidence intervals, and no statistical significance tests for any benchmark results. The GenEval and WISE benchmarks are evaluated on standard test sets, and the process-driven model's performance is reported as point estimates without uncertainty quantification. The ablation studies (Tables 5, 6, 7) similarly report point estimates on GenEval subcategories. For the compute-optimal strategy selection (the adaptive trajectory length), the model's behavior is learned implicitly from the training data rather than selected via cross-validation — the paper does not describe a held-out validation set for tuning trajectory-related hyperparameters. This absence of statistical rigor is a limitation given the relatively small size of some GenEval subcategories (e.g., Position and Color Attributes typically have fewer test prompts than Single Object) and the 500-question test set sizes common in this domain, where differences of 1–2 percentage points could arise from sampling variance on small subcategory sizes.

Main Quantitative Results

Compositional Text-to-Image Generation on GenEval

The headline result (Table 2): process-driven training lifts BAGEL-7B from 0.77 overall GenEval accuracy to 0.83, a +6% absolute gain (reported as +4% in the abstract, but the raw numbers are 0.77 → 0.83 in Table 2 — the abstract's +4% figure appears to reference 0.79 → 0.83, where 0.79 is the paper's own multi-turn baseline). This overall score matches FLUX.1-dev (12B) at 0.82, placing the 7B process-driven model on par with the best generation-only model that is nearly twice its size, and substantially outperforms all other unified multimodal models (next best: Janus-Pro-7B at 0.80, Show-o2 at 0.76).

Breaking down by attribute category (Table 2):

Position: The largest absolute gain. BAGEL-7B baseline achieves 0.51. The process-driven model achieves 0.72, a +21-point improvement. This is the category that most directly tests spatial reasoning — understanding and rendering relationships like "to the left of," "above," "below" — which is the paper's primary motivating failure mode. For context, FLUX.1-dev scores 0.68, meaning the 7B process-driven model exceeds the 12B generation-only model by 4 points on the hardest spatial reasoning task.
Color Attributes: The second-largest gain. Baseline at 0.56, process-driven at 0.69, a +13-point improvement. This category requires binding the right color to the right object type (e.g., "a red car and a blue bicycle"), testing whether the model can maintain attribute-object associations across multiple entities. FLUX.1-dev scores 0.65, again exceeded by the process-driven model.
Single Object, Two Objects, Counting, Colors: These categories show minimal or no improvement. Single Object: 0.99 → 0.99 (unchanged). Two Objects: 0.95 → 0.95 (unchanged). Counting: 0.76 → 0.75 (slight decrease). Colors: 0.87 → 0.87 (unchanged). These tasks are already near-ceiling for the base model or test simpler compositional skills that do not benefit from multi-step reasoning — detecting whether one or two objects exist does not require spatial planning, and basic color assignment without attribute binding is relatively easy for the base model.

The pattern is clear and interpretable: process-driven generation provides gains almost exclusively on relational and attribute-binding tasks that require resolving interactions between multiple visual elements. Categories where the base model already succeeds (single objects, basic color naming) or where the task is inherently simple (two-object detection) show no benefit. This is consistent with the paper's framing: the paradigm shift targets precisely the failure modes that single-pass generation cannot resolve. The fact that the improvements are concentrated rather than uniform strengthens the paper's causal claim — if the gains were from general model improvement (e.g., longer training, more data, better hyperparameters), we would expect broad improvement across all categories. Instead, the gains are specific to the categories that the paper's mechanism is designed to address.

Comparison with FLUX.1-dev (12B): The process-driven model matches or exceeds FLUX.1-dev on every category where the base BAGEL was substantially behind: Position (0.72 vs. 0.68), Color Attributes (0.69 vs. 0.65), Overall (0.83 vs. 0.82). On categories where BAGEL was already stronger (Single Object 0.99 vs. 0.98, Two Objects 0.95 vs. 0.93), the process-driven model maintains the advantage. The only category where FLUX.1-dev holds a lead is Counting (0.75 vs. 0.75 — equal), and Colors (0.93 vs. 0.87, a 6-point disadvantage for the process-driven model). This last gap — colors without attribute binding — suggests the process-driven paradigm does not improve the model's fundamental color perception, which may be limited by the base visual encoder rather than compositional reasoning.

Comparison with other unified models: The next-best unified multimodal model is Janus-Pro-7B at 0.80 overall. The process-driven model's 0.83 represents a 3-point advantage. The gap is largest on Position (0.72 vs. Janus-Pro-7B's 0.79 — but this comparison is counterintuitive because Janus-Pro-7B scores 0.79 on Position, higher than the process-driven model's 0.72. Checking the table: BAGEL-7B baseline has 0.51 on Position; the process-driven model improves to 0.72; Janus-Pro-7B scores 0.79. This means Janus-Pro-7B is still stronger on spatial reasoning than the process-driven BAGEL-7B, despite the latter's improvement. The process-driven model's overall advantage comes from stronger performance on Counting (0.75 vs. 0.59), Colors (0.87 vs. 0.90 — Janus-Pro leads here), and Color Attributes (0.69 vs. 0.66).) The overall pattern suggests that different unified architectures have different strengths, and the process-driven training primarily closes BAGEL's gap on Position and Color Attributes relative to Janus-Pro rather than surpassing it on all dimensions.

World Knowledge Reasoning on WISE

The headline result (Table 3): process-driven training lifts BAGEL-7B from 0.70 overall WISE accuracy to 0.76, a +6% absolute gain (reported as +6% in the abstract, consistent with Table 3: 0.70 → 0.76, which is actually an +8.5% relative improvement — the paper's text in Section 4.2 says "boosts BAGEL-7B by 8.5% absolute gains," which appears to be a misstatement since 0.70 to 0.76 is +6 points absolute; the "nearly 15% gains on challenging tasks like Time and Chemistry" appears to refer to relative percentage increases on specific domains). The overall score of 0.76 substantially exceeds all generation-only models (best: FLUX.1-dev at 0.50) and all unified multimodal models (next best: BAGEL baseline at 0.70, Show-o2 at 0.61).

Breaking down by domain (Table 3):

Time: The largest absolute improvement. BAGEL baseline: 0.69. Process-driven: 0.82, a +13-point gain. This domain tests temporal reasoning in image generation — prompts involving concepts like "sunset," "dawn," "medieval," "futuristic" require the model to render appropriate visual indicators of time periods.
Chemistry: The second-largest gain and the most dramatic relative improvement. BAGEL baseline: 0.58. Process-driven: 0.78, a +20-point gain. This domain requires rendering scientific concepts like molecular structures, chemical reactions, or laboratory equipment, testing whether the model can translate abstract scientific knowledge into visual form.
Biology: Notable gain. Baseline: 0.64. Process-driven: 0.70, a +6-point gain. Tests rendering of biological concepts (organisms, anatomical structures, ecosystems).
Physics: Small gain. Baseline: 0.75. Process-driven: 0.76, a +1-point gain. Tests physical concepts (gravity, motion, optical phenomena).
Space: Slight decrease. Baseline: 0.75. Process-driven: 0.73, a -2-point change. Tests astronomical and spatial concepts.
Culture: Slight decrease. Baseline: 0.76. Process-driven: 0.74, a -2-point change. Tests cultural artifacts, historical scenes, and social concepts.

The pattern is again non-uniform and interpretable. Process-driven generation provides the largest gains on domains that require structured reasoning about complex, multi-faceted concepts — time periods involve coordinating multiple visual elements (lighting, architecture, clothing, technology), and chemistry involves precise spatial arrangements of abstract entities. The domains where gains are minimal or negative (Physics, Space, Culture) may be limited by the base model's factual knowledge rather than its compositional reasoning — the process-driven paradigm amplifies existing knowledge but does not inject new knowledge. If the base BAGEL-7B has weak chemistry knowledge, the process-driven approach helps it deploy what knowledge it has more effectively; if the base model already has strong physics knowledge, there is less room for reasoning to improve output.

Comparison with generation-only models on WISE: The gap is enormous — the process-driven model at 0.76 versus FLUX.1-dev at 0.50 represents a 26-point advantage. This is expected because WISE tests world knowledge understanding, not just visual quality, and generation-only models lack the language understanding backbone that unified models possess. The more meaningful comparison is with other unified models: Show-o2 at 0.61, MetaQuery at 0.55, Janus-Pro-7B at 0.35, Emu3 at 0.39. The BAGEL baseline's 0.70 already dominates this field, and the process-driven model extends the lead further. This suggests BAGEL's architecture — which integrates autoregressive text modeling with rectified flow image generation — is particularly well-suited for knowledge-intensive generation even before process-driven training, and the process-driven paradigm amplifies this architectural advantage.

Comparison with generation-only models on WISE is somewhat artificial because WISE explicitly tests world knowledge — a capability that requires language understanding that generation-only models by definition lack. The fact that FLUX.1-dev scores only 0.50 despite being a 12B model with strong compositional abilities (0.82 on GenEval) confirms that WISE measures a fundamentally different capability. The process-driven model's strong WISE performance therefore reflects the base BAGEL's language understanding combined with the process-driven paradigm's ability to structure that knowledge into coherent visual compositions.

Efficiency Comparison with Process-Based Baselines

Table 4 presents a controlled comparison specifically designed to evaluate the process-driven paradigm against alternative approaches to process-level reasoning in image generation:

Training-free baselines fail catastrophically or provide marginal gains. Using GPT-4o as an external planner (BAGEL + GPT Planner) produces a GenEval score of 0.60, a 23-point drop from the process-driven model's 0.83, and even below the BAGEL baseline of 0.77. The base model cannot ground external multi-step instructions into stable visual intermediates without specialized training. Using GPT-4o as an external inspector (BAGEL + GPT Inspector) achieves 0.80, a modest +3-point gain over the BAGEL baseline (0.77) but still 3 points below the process-driven model. External verbal critiques cannot be translated into precise visual corrections without process-level training alignment.
Training-based methods show a Pareto frontier where the process-driven approach dominates on both accuracy and efficiency. PARM (TTS, 400K samples) achieves 0.67 — worse than the base BAGEL-7B (0.77) despite using 6.5× more training data. PARM (RL + TTS, 688K samples) improves to 0.77, matching the base BAGEL but 6 points below the process-driven model (0.83). The process-driven model achieves superior accuracy with 11× less training data (62K vs. 688K) and 7.6× less inference compute (131 vs. 1000 sampling steps).

The inference cost comparison deserves careful interpretation. PARM's 1000 sampling steps come from Best-of-20 search: the model generates 20 candidate images, each requiring ~50 denoising steps, and uses a trained verifier to select the best. The process-driven model's 131 steps come from 2.62 reasoning cycles on average, where each cycle involves generating one or two images (sketch + optional refinement). The direct step count comparison may not reflect wall-clock time differences because: (a) the process-driven model's steps are sequential (each depends on prior text and image context) while PARM's 20 candidates can be generated in parallel, so wall-clock time might favor PARM despite higher step count; (b) the computational cost per step differs between diffusion denoising and rectified flow integration; (c) the process-driven model generates text tokens in addition to images, adding autoregressive decoding cost not captured by the image sampling step count. The paper treats "sampling steps" as a unified cost metric without these qualifications.

The key efficiency insight is not about step counting but about search strategy. PARM uses exhaustive search (Best-of-20) with a trained verifier to find good outputs in latent space. The process-driven model uses adaptive reasoning: it decides based on task difficulty how many refinement cycles to perform, averaging only 2.62 steps rather than a fixed 20 candidates. This adaptive computation — spending more effort on hard prompts and less on easy ones — is what drives the efficiency gain, and it is made possible by semantic partitioning: the model can evaluate whether an intermediate visual state needs refinement by inspecting it, rather than needing to generate 20 alternatives and pick the best.

Ablation Studies and Robustness Checks

Diverse editing instructions unlock relational reasoning (Table 5). The paper compares two variants of the multi-turn generation dataset: one with only additive operations (from scene-graph subgraph expansion, "w/o aug.") and one augmented with GPT-rewritten instructions introducing modification, removal, and swapping operations ("w/ aug."). The augmented variant yields clear improvements on relational tasks: Position improves from 0.58 to 0.67 (+9 points), Color Attribute from 0.50 to 0.62 (+12 points). Color shows a smaller gain (0.81 to 0.82). When self-critique fine-tuning is applied on top, both variants improve, but the augmented variant again shows larger gains — Position reaches 0.72 (vs. 0.61 for non-augmented), Color Attribute reaches 0.69 (vs. 0.53). The non-augmented variant with self-critique plateaus at lower performance, suggesting that exposure to diverse editing operations during training enables the model to develop more flexible intermediate reasoning strategies that are better foundations for learning to self-correct. The finding is non-obvious because one might expect that purely additive operations — which match the subgraph expansion logic exactly — would produce the cleanest training signal. The paper's interpretation is that instruction diversity "encourages the model to interpret partially formed images not simply as 'incomplete additions,' but as editable states that may require correction or adjustment."

Self-sampled critiques outperform symbolic corrections from scene graphs (Table 6). Starting from a multi-turn model baseline (Color: 0.82, Position: 0.67, Color Attribute: 0.62), adding scene-graph-derived corrections improves to 0.83 / 0.70 / 0.67 — modest gains of +1 to +3 points per category. Replacing these with self-sampled critiques yields 0.87 / 0.72 / 0.69 — gains of +5, +5, and +7 points over the unaugmented baseline, and +4, +2, +2 over the scene-graph correction variant. The paper attributes this to distribution matching: self-sampled critiques reflect the model's actual failure modes, making the supervision signal aligned with the model's internal reasoning dynamics. Scene-graph corrections, while logically valid, may target error types the model rarely makes or present corrections in a form the model does not naturally produce, creating a distributional mismatch between training supervision and inference behavior. This is the paper's strongest empirical argument for its data construction methodology and represents the most counterintuitive finding — the "cleaner" symbolic supervision is worse than the "messier" self-sampled supervision.

Instruction-level and image-level constraints address distinct failure modes (Table 7). Adding instruction-intermediate conflict supervision alone ("w/ ins.") improves Position from 0.66 to 0.71 (+5 points) but yields minimal gains on Counting (0.61 to 0.62), Colors (0.84 to 0.85), and Color Attribute (0.62 to 0.65). Adding image-instruction alignment supervision alone ("w/ img-ins.") improves Counting from 0.61 to 0.73 (+12 points) but produces smaller or negative gains on Position (0.66 to 0.69, +3 points) and Color Attribute (0.62 to 0.65, +3 points). Combining both ("w/ ins. + img-ins." — the full model) achieves the best performance across all categories: Counting 0.75, Colors 0.87, Position 0.72, Color Attribute 0.69. This is a clean double-dissociation pattern: instruction-level supervision primarily helps with semantic and spatial consistency (ensuring the textual plan stays aligned with the prompt), while image-level supervision primarily helps with visual grounding (ensuring the generated image matches the step instruction). The fact that combining both yields the best performance on every category confirms that these are complementary mechanisms targeting different stages of the Plan → Sketch → Inspect → Refine cycle.

The ablation studies collectively support a nuanced causal story. Process-driven generation does not work because of any single component — it works because of the interaction between diverse instruction training (which teaches flexible editing), self-sampled critique supervision (which teaches error detection in the model's own distribution), and dual-stream constraint checking (which catches both semantic drift and visual execution failures). Removing any one of these degrades performance, but the degradation patterns differ by component and by evaluation category, which is strong evidence that each component contributes through a distinct mechanism rather than all components jointly providing a general training signal.

Critical Assessment

Does the process-driven paradigm genuinely improve compositional reasoning, or does it improve a narrower capability?

The GenEval results (Table 2) strongly support improvement on relational tasks (Position: +21 points, Color Attributes: +13 points) but show zero improvement on object-presence tasks (Single Object: unchanged, Two Objects: unchanged, Counting: slightly negative, Colors: unchanged). This is consistent with the paper's claimed mechanism — inspecting and refining spatial and attribute relations during generation — but it reveals that the gains are narrower than the phrase "compositional image generation" might imply. The process-driven model is not better at generating images in general; it is specifically better at resolving spatial relations and attribute-object bindings. For applications where these are the primary failure modes, the approach is highly effective. For applications where other compositional skills matter (e.g., generating exactly three objects when asked for three), the approach provides no benefit. This narrowness is not a weakness — it demonstrates mechanism specificity — but the paper's framing occasionally implies broader compositional improvement than the data support.

Does the efficiency advantage over PARM hold under a fair comparison?

The 8× inference cost reduction (131 vs. 1000 steps) is the paper's headline efficiency claim (Table 4). Several qualifications are necessary. First, PARM uses Best-of-20 search because it operates on blurry latents that cannot be semantically inspected; the process-driven model uses adaptive refinement because it operates on inspectable visual states. The cost gap is therefore architectural — a consequence of representing the process at the semantic rather than latent level — and would persist under any fair sampling-step accounting. However, PARM's 20 candidates can be generated in parallel (batch size 20), while the process-driven model's 2.62 cycles are sequential (each depends on prior text and image context). Wall-clock latency may favor PARM despite higher total FLOPs. The paper reports no latency measurements, making real-time deployment comparisons impossible.

Second, the training data efficiency claim (62K vs. 688K, 11× reduction) compares against PARM's RL + TTS variant. But PARM (TTS) with 400K samples achieves only 0.67 on GenEval — worse than BAGEL-7B's zero-shot performance (0.77). This suggests PARM's base model or training procedure is fundamentally less effective than BAGEL's for this task, making the data efficiency comparison potentially confounded by base model quality differences. A fair comparison would apply the process-driven training methodology to PARM's base diffusion model, or apply PARM's latent-space verification to BAGEL's outputs. Neither experiment is attempted.

Third, the paper's GenEval score for BAGEL-7B baseline (0.77) differs from the reported reproduction (0.77 with asterisk in Table 2, and the abstract mentions "lifts BAGEL-7B from 79% to 83%" implying a 0.79 baseline). The 0.77 number is explicitly marked as reproduced from the official repository, but the abstract's 0.79 suggests the paper's multi-turn generation baseline (before adding reasoning supervision) achieves 0.79. The 0.79 to 0.83 improvement is +4 points, while the 0.77 to 0.83 improvement is +6 points. The discrepancy is not explained and makes it unclear whether the process-driven approach provides a 4-point or 6-point lift over the strongest available baseline.

Are the ablation results robust given the small scale?

The ablation studies (Tables 5, 6, 7) report results on GenEval subcategories — Position, Color Attribute, Color, Counting — without specifying the number of test prompts per subcategory. The original GenEval paper provides per-category prompt counts that are typically small (often 50–100 prompts for relational categories). A +5-point improvement on a 50-prompt test set represents 2–3 additional correct answers. Without confidence intervals or statistical tests, it is impossible to determine whether the observed differences between ablations are reliable. The consistent patterns across multiple related categories (Position and Color Attribute both show gains from instruction diversity; Counting and Position show differential responses to instruction-level vs. image-level supervision) provide qualitative support, but the quantitative precision should be treated as approximate.

The WISE results may partially reflect BAGEL's pre-existing knowledge advantage.

The BAGEL-7B baseline already achieves 0.70 on WISE, which is 9 points higher than the next-best unified model (Show-o2 at 0.61) and 20 points higher than the best generation-only model (FLUX.1-dev at 0.50). The process-driven approach improves this to 0.76 — a meaningful gain, but one that builds on a base model that was already dominant on this benchmark. The paper does not establish whether the process-driven paradigm would provide similar gains on a weaker base model with less world knowledge. It is plausible that the approach amplifies existing knowledge (by structuring it into better compositions) but does not compensate for missing knowledge, in which case the WISE gains may be specific to knowledge-rich base models like BAGEL.

Missing experiments that would strengthen the claims.

No ablation on the number of reasoning cycles. The paper reports an average of 2.62 steps as an emergent property of the trained model, but does not experiment with constraining or varying the number of steps to establish the performance-cost Pareto frontier. How much does performance improve going from 2 to 3 to 4 steps? Does forcing more steps on simple prompts degrade performance (over-refinement)?
No baseline using the same multi-turn generation data but without the inspect-refine cycle. If the model were trained on the Multi-Turn Generation dataset alone (no conflict or alignment supervision) and evaluated after a fixed number of steps, how much of the gain comes from multi-step generation versus from the inspect-refine loop? Table 5 provides partial evidence (the "w/o aug. + Self-critique" row represents additive-only data without the full reasoning supervision), but a clean ablation removing only the critique data while keeping instruction diversity would isolate the contribution of the inspect-refine mechanism.
No human evaluation. GenEval and WISE use automated metrics that may not capture visual quality, aesthetic appeal, or perceptual plausibility. A process-driven model that optimizes for compositional alignment could produce images that are compositionally correct but visually worse (artifacts from multiple generation cycles, inconsistent lighting across increments). The qualitative examples in Figures 4 and 5 are curated and cannot establish that quality is maintained on average.
No results on standard image quality metrics (FID, CLIP score, aesthetic scores). The paper exclusively evaluates compositional alignment. Without quality metrics, there is no evidence that the multi-step generation process does not degrade image fidelity relative to single-pass generation. The paper's choices suggest a deliberate focus on composition over quality, but for practical deployment, both matter.
No breakdown of where the 131 inference steps are spent. How many steps are used for initial sketches versus refinement passes? Does refinement use the same number of rectified flow integration steps as initial generation, or fewer (since it starts from a better initialization)? Without this breakdown, the efficiency claim is coarse.
No results on prompts the model gets wrong despite process-driven generation. The paper shows successful trajectories in Figures 1 and 4 but does not analyze failure cases. Understanding what kinds of prompts resist even multi-step reasoning — and whether failures stem from planning errors, sketch execution errors, or inspection failures — would clarify the approach's limits.

Summary of evidential strength

The paper's central claim — that training a unified multimodal model on interleaved reasoning trajectories with semantic-level intermediate state supervision improves compositional image generation, particularly for spatial relations and attribute bindings — is well-supported by the GenEval results, with the caveat that improvements are specific to relational tasks and do not generalize to all composition types. The efficiency advantage over PARM is directionally convincing (semantic partitioning is more efficient than latent-space search) but the precise 8× figure requires qualification around parallelism, latency, and base model comparability. The ablation studies provide mechanistically interpretable patterns (differential effects of instruction diversity across task types, double dissociation between instruction-level and image-level supervision) that strongly suggest the proposed components address distinct failure modes. The absence of statistical rigor, human evaluation, quality metrics, and failure analysis limits the strength of conclusions that can be drawn about practical deployment, but the paper's primary contribution — demonstrating that process-driven interleaved reasoning with semantic intermediate states is a viable and effective paradigm — is convincingly established within the scope of the experiments conducted.

6. Limitations and Trade-offs

6.1 The Difficulty Estimation Cost Is Not Accounted for in the Efficiency Claims, and There Is No Lightweight Alternative

The assumption or constraint. The entire process-driven paradigm depends on the model being able to determine, at each reasoning cycle, whether the current intermediate visual state is correct, incomplete-but-on-track, or incorrect. This requires the model to perform inspection — comparing the generated sketch against the step-level instruction and comparing the intermediate textual description against the original prompt. The model learns this capability from the Instruction-Intermediate Conflict and Image-Instruction Alignment datasets, which are constructed using expensive external evaluation: GPT-4o serves as a judge, and ground-truth intermediate images are synthesized using Flux-Kontext. The paper does not quantify the cost of this data construction pipeline nor does it amortize it into the reported efficiency numbers.

More critically at inference time, the model performs inspection autoregressively — it generates textual analysis tokens and, if a conflict is detected, refinement tokens — before producing each refined image. The paper reports an average of 131 total sampling steps across 2.62 reasoning cycles, but this count only includes rectified flow integration steps for image generation. The autoregressive text generation cost for plans, inspections, and refinements — which involves forward passes through the full 7B-parameter model for every text token — is not included in the step count. For a model producing multi-sentence inspections and refinements across multiple cycles, this text-generation cost could be substantial.

The consequence. The 8× inference cost reduction claimed over PARM (131 vs. 1000 sampling steps, Table 4) is an incomplete accounting of total compute. PARM's 1000 steps capture the full inference cost (50 denoising steps × 20 candidates). The process-driven model's 131 steps capture only the image generation portion of inference, omitting the autoregressive text decoding that produces plans, global descriptions, inspection analyses, and refinement instructions. If each reasoning cycle requires, say, 50–100 text tokens of planning and inspection, that adds 50–100 forward passes through the 7B transformer per cycle, or roughly 130–260 additional forward passes across 2.62 cycles. This text generation cost may be comparable to or exceed the image generation cost, potentially narrowing or eliminating the reported efficiency advantage.

Furthermore, the training data construction pipeline — using GPT-4o as judge for 30K+ samples across three dataset components, plus Flux-Kontext for synthesizing intermediate images — represents a significant upfront cost that the paper does not quantify. A practitioner seeking to replicate the approach on a new domain would need access to (a) a high-quality external judge model, (b) a high-quality in-context image generation/editing model for producing ground-truth intermediate images, and (c) sufficient compute budget to run both at scale. The paper provides no guidance on whether cheaper judges or weaker intermediate-image generators would suffice.

What evidence exists in the paper. The paper acknowledges the cost of difficulty estimation only implicitly. Section 3.2 describes the data construction pipeline but provides no cost analysis. Table 4 compares inference steps (131 vs. 1000) without mentioning that this metric excludes text generation cost. The paper's inference procedure description (end of Section 3.3) states the model "autoregressively generates an interleaved reasoning trajectory" with "textual and visual intermediates produced in a unified sequence" — confirming that text generation is part of inference — but the cost accounting in Table 4 treats only image sampling steps as the cost metric.

Mitigation status. The paper does not address this limitation. It does not report the number of text tokens generated per reasoning cycle, does not provide a FLOPs-based cost comparison that would capture both text and image generation, and does not ablate the cost of inspection (e.g., by comparing performance with and without inspection at various cycle counts). The adaptive trajectory length (2.62 average cycles) is presented as an efficiency feature without acknowledging that each cycle includes text generation overhead. The paper does not suggest future work on reducing inspection cost or on cheaper difficulty-estimation methods.

6.2 The Approach Is Tested on a Single Benchmark Pair with a Single Model Family, with No Evidence of Transfer to Other Domains, Modalities, or Architectures

The assumption or constraint. All experiments use BAGEL-7B as the base model and evaluate exclusively on two benchmarks: GenEval (compositional object alignment) and WISE (world knowledge reasoning). Both benchmarks test text-to-image generation from natural language prompts requiring compositional or knowledge-intensive reasoning. The paper's title claims "Think in Strokes, Not Pixels" and the introduction frames process-driven generation as a general paradigm, but the empirical validation is restricted to a single model architecture and a narrow task family.

Several aspects of the approach could be architecture-dependent. BAGEL uses a specific integration of autoregressive text modeling with rectified flow image generation. The training procedure adds a loss term on <|vision_start|> and <|vision_end|> tokens to enable modality switching — a mechanism that may not transfer to unified models using different architectures (e.g., fully autoregressive discrete-token models like Chameleon or Emu3, or diffusion-based unified models). The specific balance between cross-entropy loss and MSE loss (controlled by λ_CE in Equation 6) may require retuning for different architectures.

The benchmark selection is also narrow. Both GenEval and WISE focus on compositional and knowledge-intensive prompts, which is precisely where the paper argues process-driven generation should help. The approach's performance on standard image quality benchmarks (FID, CLIP score, human preference ratings) is untested. There is no evidence that process-driven generation maintains or improves image fidelity, aesthetic quality, or diversity relative to single-pass generation — the paper evaluates only compositional correctness, not visual quality.

The consequence. A practitioner considering adopting process-driven generation cannot determine from this paper alone whether the approach would work with their model architecture (e.g., a diffusion-based unified model, a discrete-token autoregressive model, or a larger model like BAGEL-70B if it existed) or whether the gains would transfer to their task domain (e.g., photo-realistic generation, artistic stylization, image editing rather than generation from scratch). The paper does not establish that the approach is robust to architecture choice or task distribution.

More subtly, the exclusive focus on compositional correctness metrics creates an unknown quality-composition tradeoff. Process-driven generation involves generating multiple images per prompt (sketches and refinements), each of which may introduce artifacts, inconsistencies in lighting or style across steps, or degradation from repeated encoding-decoding cycles. The paper's curated qualitative examples (Figures 4 and 5) show visually appealing results, but these are selected successes — they cannot establish that quality is maintained on average across the full test set. A practitioner deploying this approach for user-facing applications where visual quality matters as much as compositional correctness would be making a decision under significant uncertainty.

What evidence exists in the paper. The paper explicitly acknowledges the model-specific scope in Section 3.3: "we adopt a unified multimodal model, such as BAGEL, as our backbone." The "such as" implies the approach should generalize, but no other backbone is tested. The evaluation sections (4.2, 4.3) are restricted to GenEval and WISE. No image quality metrics are reported anywhere in the paper. The qualitative figures (4 and 5) are explicitly selected examples and are not accompanied by any quantification of quality degradation on negative examples.

Mitigation status. The paper does not address this limitation and does not propose experiments on other architectures, benchmarks, or quality metrics as future work. The conclusion (Section 5) mentions extending the approach "to videos and 3D space" and enabling "real-time human-in-the-loop control" as future directions, but does not suggest validating the current approach on additional 2D image generation benchmarks or architectures.

6.3 The Model Occasionally Revises Correct Outputs into Incorrect Ones, and the Paper Provides No Analysis of This Failure Mode's Frequency or Impact

The assumption or constraint. The inspect-and-refine cycle is trained to detect and correct errors, but the training data construction creates an asymmetry: the model is trained predominantly on trajectories where intermediate states are incorrect (the Instruction-Intermediate Conflict subset contains 8,296 negative vs. 6,905 positive samples; the Image-Instruction Alignment subset contains 10,000 negative vs. 5,000 positive samples). This means the model sees many more examples of "here is an error, here is how to fix it" than "here is a correct state, confirm it and move on." The paper does not discuss whether this asymmetry could bias the model toward over-refinement — detecting "errors" that are not actually errors and "correcting" them in ways that degrade the output.

This is directly analogous to the correct-to-incorrect reversion problem observed in the revision model literature. A model trained primarily on incorrect→correct trajectories may, at inference time, encounter correct intermediate states and incorrectly "refine" them, introducing errors where none existed. In the process-driven paradigm, this would manifest as the Inspect stage flagging a non-existent conflict and the Refine stage producing a worse image than the Sketch stage had produced.

The consequence. If the model over-refines, then additional reasoning cycles could degrade rather than improve output quality. The paper's adaptive trajectory length (averaging 2.62 cycles) could reflect not optimal stopping but rather a limit beyond which further refinement is harmful. The ablation study in Table 5 shows that self-critique fine-tuning improves performance, but this is evaluated on the final output — if over-refinement occurs on some fraction of prompts and is balanced by genuine improvements on others, the net effect could be positive while the per-prompt reliability is worse. A user who receives a degraded output after the model "inspected and refined" it would experience a particularly frustrating failure mode: the model not only made an error but actively made the image worse while claiming to improve it.

The ablation in Table 7 provides indirect evidence. Adding image-instruction alignment supervision alone (which focuses on detecting and correcting visual misalignments) improves Counting but produces smaller gains on Position and Color Attribute compared to instruction-intermediate conflict supervision. This could indicate that image-level refinement sometimes interferes with spatial or attribute relations that were correctly rendered in the initial sketch. The combined supervision achieves the best results, suggesting the two critique types compensate for each other's over-refinement tendencies, but the paper does not investigate this directly.

What evidence exists in the paper. The paper does not report any metric related to over-refinement: no measurement of how often refinement degrades a correct intermediate state, no comparison of Sketch-stage vs. Refine-stage accuracy, and no analysis of prompts where the final output is worse than an intermediate state. The qualitative examples in Figure 4 show successful refinement but do not show cases where refinement fails. The paper's sample counts (Table 1) reveal the negative-skew of the training data but the paper does not discuss the potential consequences of this skew.

Mitigation status. Not addressed. The paper does not acknowledge over-refinement as a potential failure mode, does not measure its frequency, and does not propose mitigation strategies (such as training on balanced positive/negative examples, adding a "no refinement needed" output option, or using the PRM-equivalent to decide whether to trust the refinement or the original sketch). This is a notable gap given that the revision model literature has extensively documented the correct-to-incorrect reversion problem and the paper's own motivation draws on that literature.

6.4 The Scene-Graph Subsampling Approach Assumes Prompts Can Be Parsed into Compositional Scene Graphs, Limiting Applicability to Prompts Without Clear Compositional Structure

The assumption or constraint. The multi-turn generation dataset is constructed by parsing prompts into scene graphs, subsampling subgraphs to create incremental instructions, and synthesizing ground-truth intermediate images from those subgraphs using Flux-Kontext (Section 3.2: "we represent each prompt using a scene graph, where object nodes, attribute nodes, and relation edges define the target composition"). This pipeline assumes that every prompt can be meaningfully decomposed into objects, attributes, and relations — i.e., that the prompt describes a scene with discrete, nameable entities and explicit spatial or semantic relationships between them.

Many prompts do not fit this structure. Prompts describing abstract concepts ("a feeling of melancholy"), atmospheric scenes ("a misty forest at dawn with no specific focal objects"), textures or patterns ("a seamless tartan plaid"), or highly stylized outputs ("in the style of Van Gogh's Starry Night") may not parse into clean scene graphs. The scene-graph representation is inherently object-centric and relation-centric; it struggles with prompts where the primary content is global (lighting, mood, texture, style) rather than compositional.

The consequence. The approach may not transfer to prompt distributions that differ from GenEval and WISE — both of which emphasize compositional, object-centric prompts by design. A practitioner using process-driven generation for a general-purpose text-to-image system (where users provide diverse prompts including abstract, stylistic, and atmospheric requests) would encounter prompts that either fail to parse into scene graphs (breaking the training data pipeline) or produce nonsensical intermediate states when forced through the decomposition. The model might attempt to plan incremental additions for a prompt that has no natural compositional decomposition, producing awkward or incoherent intermediate steps that degrade rather than improve the final output.

Even within the compositional domain, the scene-graph approach assumes that objects and relations are independent enough to be introduced incrementally. For highly interdependent scenes — where the visual appearance of one object depends on another in ways that cannot be rendered independently and then combined (e.g., reflections, shadows, occlusions, or lighting interactions) — incremental generation may produce physically inconsistent results. Adding a "bear hovering above a spoon" in two steps (first spoon, then bear) may fail to correctly render the shadow the bear casts on the spoon or the spoon's reflection of the bear, because these interdependent effects cannot be cleanly separated into independent rendering steps.

What evidence exists in the paper. The paper does not discuss limitations of the scene-graph representation. It does not report what fraction of prompts from GenEval or WISE could be successfully parsed into scene graphs, whether any prompts were excluded due to parsing failures, or how abstract or non-compositional prompts were handled. The dataset statistics (Table 1) report 32,012 samples in the multi-turn generation subset but do not report how many prompts were initially considered and discarded. The qualitative examples (Figures 4 and 5) all show clearly compositional prompts with discrete objects and relations — bears on spoons, cats on benches, birds on skateboards — which are the best case for the scene-graph approach.

Mitigation status. The paper does not address this limitation. The instruction augmentation step (rewriting additive instructions with GPT to introduce modification, removal, and swapping operations) diversifies within the compositional paradigm but does not extend beyond it. The conclusion mentions extending to "videos and 3D space" but does not discuss handling prompts that lack compositional structure. This is a fundamental scope constraint: process-driven generation as formulated in this paper is a technique for compositional image generation, not a general-purpose replacement for single-pass generation.

6.5 The Adaptive Trajectory Length Is an Emergent Property That Is Not Directly Controlled, Making Computational Cost Unpredictable and Potentially Unbounded

The assumption or constraint. The model determines its own trajectory length at inference time — it generates reasoning cycles until it emits a final image without a subsequent <|vision_start|> token. The paper reports an average of 2.62 cycles and 131 total sampling steps, but these are averages over the GenEval test distribution. There is no mechanism to cap the number of cycles or to enforce a budget constraint. The paper's abstract and Section 4.3 frame this adaptive behavior as a feature: "complexity-adaptive reasoning, where it autonomously determines the trajectory length based on task difficulty."

However, the paper provides no evidence about the distribution of trajectory lengths. The average of 2.62 cycles could hide substantial variance: some prompts may require 1 cycle while others require 10 or more. If the model enters a loop — detecting a "problem," refining, re-detecting the same or a new "problem," and refining again without converging — it could generate an unbounded number of cycles before emitting the final image. The paper's training data includes a maximum of 5 images per sample (Table 1), but the inference procedure does not enforce this limit.

The consequence. For deployment in latency-sensitive or cost-constrained settings, the unpredictability of inference cost is a significant practical barrier. A system that sometimes generates an image in 50 steps and other times in 500 steps cannot provide consistent latency guarantees to users. In the worst case, the model could enter an infinite refinement loop, consuming compute indefinitely without producing a satisfactory output. Even without infinite loops, high-variance inference cost complicates batch scheduling, load balancing, and cost estimation.

The paper's comparison with PARM (131 vs. 1000 steps) uses the average cost, which masks this variance. If the process-driven model occasionally requires 500+ steps on difficult prompts while PARM consistently uses 1000 steps on all prompts (due to its fixed Best-of-20 strategy), the worst-case latency might be comparable or worse, even though the average favors the process-driven approach. A risk-averse practitioner planning for peak load would need to provision for the maximum observed cost, not the average, and the paper provides no tail-cost data.

What evidence exists in the paper. The paper reports only the average trajectory length (2.62 reasoning steps) and average inference cost (131 sampling steps) in Section 4.3. It does not report the distribution, minimum, maximum, or standard deviation of trajectory lengths. It does not analyze whether trajectory length correlates with prompt difficulty in the expected direction (harder prompts → more cycles). The paper does not discuss whether termination is guaranteed or whether the model sometimes fails to terminate.

Mitigation status. Not addressed. The paper does not propose a maximum cycle limit, a budget-aware stopping criterion, or a mechanism for early exit if refinement stops improving. These are standard techniques in the chain-of-thought and test-time compute literature that the paper does not adopt or discuss. The conclusion mentions "real-time human-in-the-loop control" as a future direction but does not address the more immediate need for predictable inference cost.

6.6 The Paper Does Not Compare Against Single-Pass Generation with Equivalent Total Compute, Leaving Unclear Whether the Gains Come from Process Supervision or Simply from More Compute per Prompt

The assumption or constraint. The process-driven model generates an average of 2.62 intermediate images plus a final image, for a total of roughly 3–4 images per prompt (each sketch and refinement counts as an image). The 131 sampling steps represent the cumulative cost of generating all these images. In contrast, single-pass baselines like the BAGEL-7B baseline (0.77 on GenEval) generate one image per prompt, presumably using far fewer sampling steps (likely 20–50 rectified flow integration steps, though the paper does not report this).

The paper never establishes a compute-matched comparison. The natural question — "if we gave the single-pass BAGEL-7B the same 131 sampling steps to generate and select from multiple candidates (e.g., best-of-4 with 33 steps each, or best-of-8 with 16 steps each plus a verifier), how would it perform?" — is not asked or answered. The paper's baseline comparisons use each model's default or reported configuration, not a configuration that equalizes inference compute.

The consequence. The reported gains (0.77 to 0.83 on GenEval) confound two effects: (1) the process-driven paradigm (planning, inspecting, refining) and (2) the increased compute per prompt (generating multiple images rather than one). It is possible that a significant fraction of the improvement comes simply from spending more compute — e.g., generating 4 independent images with the single-pass model and selecting the best using majority voting or a verifier might match or approach the process-driven model's performance without any process supervision. The paper provides no evidence to disentangle these effects.

The comparison with PARM partially addresses this by comparing against a method that also uses increased inference compute (1000 steps via Best-of-20 search), but PARM uses a different base model and training procedure, making it a confounded comparison. The more direct ablation — single-pass BAGEL-7B with best-of-N sampling at equivalent total compute — is absent.

This is a fundamental methodological gap because it leaves open the most skeptical interpretation of the results: that process-driven generation is an expensive way to achieve what simpler test-time compute scaling (best-of-N, majority voting, verifier-guided selection) could achieve more straightforwardly. The paper's own related work section acknowledges that best-of-N sampling with verifiers is a known approach (Cobbe et al., 2021) but does not implement it as a baseline.

What evidence exists in the paper. The paper provides no compute-matched baselines. Table 2 compares the process-driven model against single-pass models without adjusting for inference cost. Table 4 compares against PARM, which uses more compute (1000 steps) but a different base model, and against GPT-augmented baselines that use external models at inference. No experiment holds total compute constant and varies only whether that compute is spent on process-driven reasoning versus parallel sampling from a single-pass model.

Mitigation status. Not addressed. The paper does not discuss this confounding factor, does not propose compute-matched comparisons as future work, and does not report the single-pass BAGEL-7B's inference cost to enable readers to perform the comparison themselves. The efficiency claims (8× reduction over PARM) focus on relative efficiency against a more expensive process-based method rather than establishing that process-driven generation is more efficient than simple test-time scaling of single-pass generation at equivalent compute budgets.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper introduces a genuinely new axis along which image generation models can be evaluated and improved: not just what they generate, but how they generate it — the process itself. The shift from outcome-driven to process-driven generation is not an incremental improvement; it is a reconceptualization of the generation task that changes what we optimize, what we supervise, and what we expect models to be capable of. The paper's finding that a 7B model trained on interleaved reasoning trajectories can match a 12B generation-only model on compositional benchmarks (GenEval: 0.83 vs. 0.82) is not a claim about scale — it is a claim that process matters independently of model size, and that investing in better generation processes can substitute for investing in larger models, at least within the capability range where the base model has non-trivial competence.

The field has been shaped by a particular mental model of image generation progress: better architectures (GANs → diffusion → rectified flow), larger models (SD → SDXL → SD3 → FLUX), and better data (LAION → internal curated datasets). Each generation of models improves by reducing the overall error rate across all prompts. This paper challenges that mental model by showing that error reduction is not uniform — the base BAGEL-7B already achieves near-ceiling performance on object presence (Single Object: 0.99, Two Objects: 0.95) while failing badly on spatial relations (Position: 0.51) and attribute bindings (Color Attributes: 0.56). Process-driven training does not improve the former at all; it dramatically improves the latter (+21 points on Position, +13 points on Color Attributes). This pattern suggests that single-pass generation hits a compositional ceiling — a fundamental limit on how well a one-shot mapping from text to pixels can resolve multi-entity spatial and attributive constraints — and that crossing this ceiling requires a different generation paradigm, not just a bigger or better-trained model.

The paper also resolves a tension in the literature about the value of reasoning for image generation. Prior work had explored chain-of-thought for generation (Liao et al., 2025; ImageGen-CoT) with mixed results, and the failure of external planning (the catastrophic 0.60 GenEval score when using GPT-4o as a planner for BAGEL, Table 4) explained why: reasoning must be internalized through end-to-end training on interleaved trajectories, not bolted on as a pre-generation text step. The planner-generator gap — where a capable text model produces plans that a separate image model cannot reliably execute — is a fundamental limitation of modular architectures that the paper's unified approach overcomes. This finding redirects research attention away from "better prompting" or "better planning modules" and toward end-to-end training of unified models on process trajectories as the path to compositional competence.

The self-sampled critique finding (Table 6: +5 points on Color, +2 on Position over symbolic corrections) introduces a distribution-matching principle for critique supervision that extends beyond image generation. The idea that correction data should be sampled from the model's own error distribution rather than synthetically constructed from an ontology has implications for code generation (self-sampled buggy code for repair training), mathematical reasoning (self-sampled proof errors), and any domain where models are trained to detect and correct their own mistakes. This principle was not articulated in prior work on self-correction and represents a methodological contribution that other fields can adopt immediately.

The research directions that become more attractive after this work include: process-supervision data construction for other generative modalities (video, 3D, audio), verifier training on semantic rather than latent states, and adaptive-computation strategies that allocate reasoning cycles based on estimated prompt difficulty. Directions that become less attractive include: purely text-based chain-of-thought for image generation (shown to be "visually blind" and limited by the planner-generator gap), latent-space process supervision without semantic grounding (shown to be 8× less efficient than semantic partitioning), and modular architectures that separate planning from generation (shown to fail when plans require precise visual execution that the planner cannot verify).

Follow-Up Research This Work Enables

Direct measurement of the over-refinement rate and its impact on output quality. The paper's training data is skewed toward negative examples (8,296 instruction-intermediate conflicts, 10,000 image-instruction misalignments, versus 6,905 and 5,000 positive examples respectively; Table 1). This asymmetry could bias the model toward detecting "errors" that are not actually errors and refining correct intermediate states into worse ones — a correct-to-incorrect reversion problem analogous to what the revision model literature has documented. A follow-up study should measure, on a per-step basis, what fraction of Refine-stage images are worse than their corresponding Sketch-stage images according to both automated metrics (GenEval subcategory accuracy at intermediate vs. final steps) and human evaluation. The study should also ablate the positive-to-negative ratio in the training data — e.g., 50:50, 33:67 (the current skew), and 20:80 — to determine whether a more balanced ratio reduces over-refinement without sacrificing error-detection capability. If over-refinement is significant, mitigation strategies such as training an explicit "no refinement needed" output token or using the model's own inspection confidence to gate whether refinement is applied should be tested.

Compute-matched comparison between process-driven generation and best-of-N sampling from the single-pass model. The paper's baseline comparisons do not control for total inference compute: the process-driven model uses 131 sampling steps on average (2.62 reasoning cycles, each generating sketch and optionally refinement images), while the single-pass BAGEL-7B baseline uses an unreported number of steps to generate a single image. A critical follow-up experiment would hold total compute constant and compare the process-driven model against single-pass BAGEL-7B with best-of-N sampling (e.g., best-of-4 with 33 steps each, best-of-8 with 16 steps each) using the same PRM or a trained verifier for selection. If best-of-N with equivalent compute matches or approaches the process-driven model's GenEval performance, this would suggest that the gains come primarily from increased compute per prompt rather than from the process-driven paradigm itself. If best-of-N falls substantially short, it would strengthen the paper's claim that interleaved reasoning provides benefits beyond what parallel sampling can achieve. The experiment should sweep across multiple compute budgets (50, 100, 200, 400 steps) to map out the performance-cost Pareto frontier for both approaches, and should measure not just final accuracy but also the diversity-quality tradeoff (are process-driven outputs less diverse because they follow similar reasoning paths?).

Extension to fully autoregressive discrete-token unified models (Chameleon, Emu3) to test architectural dependence. The paper builds on BAGEL's specific architecture — autoregressive text modeling combined with rectified flow image generation, with explicit modality-switching tokens. Does the process-driven paradigm transfer to unified models that represent images as discrete tokens and generate them autoregressively (e.g., Chameleon, Emu3), or to models that use diffusion for both text and images (e.g., Transfusion)? A follow-up study should replicate the three-part dataset construction pipeline (scene-graph subsampling, self-sampled critiques, image-instruction alignment pairs) for at least one discrete-token unified model and evaluate on GenEval. The key question is whether the inspect-and-refine cycle — which requires the model to generate an image, then generate text about that image, then generate a revised image — works when all modalities are discrete tokens, or whether the continuous latent representation in BAGEL is important for enabling precise visual edits during refinement. If discrete-token models show similar gains, the paradigm is architecture-agnostic; if they do not, the contribution is more narrowly tied to continuous-latent unified architectures.

Difficulty-aware adaptive trajectory length with explicit budget constraints. The paper's model determines its own trajectory length (averaging 2.62 cycles) but provides no control over this behavior. A practical extension would train the model to accept an explicit compute budget (maximum number of reasoning cycles or maximum sampling steps) and to allocate that budget adaptively — performing more inspection and refinement on prompts estimated to be difficult, and terminating early on easy prompts. This would require: (1) training a lightweight difficulty estimator (perhaps a small head on top of the BAGEL text encoder that takes only the prompt as input and predicts the optimal number of cycles, trained on the observed relationship between prompt features and trajectory lengths from the current model's behavior); (2) fine-tuning the model with budget tokens in the input (e.g., <|max_cycles=3|>) so it learns to respect a constraint; and (3) evaluating the performance-cost tradeoff across a range of budget levels, producing a Pareto curve that practitioners can use to select their operating point. This would directly address the paper's limitation of unpredictable inference cost and would connect process-driven generation to the broader test-time compute scaling literature.

Human evaluation of visual quality and comparison with single-pass generation on non-compositional prompts. The paper evaluates exclusively on compositional correctness (GenEval, WISE) and provides no metrics on image fidelity, aesthetic quality, or perceptual plausibility. A follow-up study should conduct a rigorous human evaluation comparing process-driven BAGEL-7B against single-pass BAGEL-7B and against FLUX.1-dev on both compositional prompts (from GenEval) and non-compositional prompts (abstract, stylistic, atmospheric — e.g., "a melancholy sunset over a calm ocean in the style of Turner"). For compositional prompts, human raters should evaluate both compositional correctness (did the model get the relations right?) and overall visual quality (is the image aesthetically pleasing? are there artifacts?). For non-compositional prompts, only visual quality can be evaluated, and the question is whether the process-driven paradigm degrades quality on prompts that do not benefit from compositional reasoning. If the process-driven model produces lower-quality images on non-compositional prompts (e.g., due to artifacts from multiple generation cycles, inconsistent lighting across increments, or the model forcing compositional decomposition where none is appropriate), this would define a boundary condition for the approach's applicability and would suggest that a deployed system should route prompts to either single-pass or process-driven generation based on estimated compositionality.

Application to text-to-3D and text-to-video generation using compositional scene graphs with temporal dynamics. The paper's scene-graph subsampling approach decomposes a 2D scene into objects, attributes, and spatial relations that can be introduced incrementally. For 3D generation, the scene graph naturally extends to include 3D spatial relations (behind, in front of, to the left of in world coordinates), camera parameters, and lighting specifications — all of which benefit from incremental, inspectable construction. For video generation, the scene graph extends to include temporal relations (before, after, while, causes) and object state changes over time. A follow-up study should adapt the three-part dataset construction pipeline to (a) text-to-3D scene generation, where intermediate states are rendered from the current subgraph at each step and the model inspects for spatial consistency and occlusion correctness, and (b) text-to-video generation, where the scene graph evolves over time and intermediate states are keyframes that must maintain temporal coherence. For both, the key question is whether the Plan-Sketch-Inspect-Refine cycle with semantic intermediate states provides similar compositional gains as in 2D, and whether the approach can handle the additional complexity of 3D spatial reasoning and temporal consistency without requiring exponentially more training data.

Practical Applications and Downstream Use Cases

Compositional product visualization and advertising creative generation. In e-commerce and advertising, prompts often specify precise arrangements of multiple products with specific spatial relationships, colors, and attributes — exactly the failure modes that process-driven generation targets. A prompt like "a red leather handbag on a marble counter, with a gold watch to its left and a pair of sunglasses above the watch" requires the model to correctly position three objects with specific spatial relations (on, to its left, above) and attribute bindings (red + handbag, gold + watch). Single-pass models frequently fail on such prompts (GenEval Position baseline: 0.51 for BAGEL-7B), producing images where objects are present but in the wrong arrangement. The process-driven model's 0.72 Position accuracy represents a 21-point improvement that directly translates to fewer rejected generations and less manual post-editing in a production pipeline. The model's adaptive trajectory length (averaging 2.62 cycles) means it spends more compute on complex multi-product arrangements and less on simple single-product shots, providing cost efficiency for batch generation workflows where prompt complexity varies. A creative team generating 1,000 product images per day, with 30% requiring multi-object spatial arrangements, would see approximately 60 fewer compositional errors per day compared to using the single-pass BAGEL-7B baseline, reducing the human review and regeneration overhead proportionally.

Educational and instructional illustration with verifiable compositional constraints. Textbook and e-learning content frequently requires diagrams and illustrations with precise spatial and attributive specifications: "a diagram showing the Earth orbiting the Sun, with the Moon orbiting the Earth, all on a black background with labeled orbital paths." Such prompts combine counting (three celestial bodies), spatial relations (two concentric orbital paths), and attribute binding (each body with the correct label) — a stress test for single-pass generation. The process-driven model's inspect-and-refine cycle provides a form of verifiable generation: the model explicitly checks whether the generated image matches the step-level instruction before proceeding, and the intermediate textual descriptions (<des> tags) serve as an audit trail that a human reviewer or automated system can check. For an educational publisher generating 500 diagrams per textbook, the ability to inspect intermediate reasoning traces — seeing that the model planned to add the Moon orbiting the Earth, generated that, verified the orbital relationship, and then proceeded — provides a level of quality assurance that single-pass black-box generation cannot offer. The model's 0.75 Counting and 0.72 Position accuracy on GenEval suggests that approximately 3 out of 4 complex instructional diagrams would be compositionally correct without manual correction, up from roughly 2 out of 4 for the single-pass baseline.

Assistive creative tools with human-in-the-loop intermediate state inspection. The interleaved reasoning trajectory naturally supports human-in-the-loop interaction: at each reasoning cycle, the model produces a textual plan (<ins> and <des>), a visual sketch, and optionally an inspection and refinement, before proceeding to the next cycle. A creative tool built on this model could expose these intermediate states to the user, allowing them to approve or modify the plan before the sketch is generated, or to accept or reject a refinement before it replaces the previous state. For example, an architect specifying "a modern two-story house with a wraparound porch, floor-to-ceiling windows on the ground floor, and a sloped roof with solar panels" could see the model first plan and sketch the basic house structure (step 1), then plan and sketch the porch (step 2), then plan and sketch the windows (step 3), inspecting and refining at each stage. If the model misplaces the porch (e.g., on only one side rather than wrap-around), the user can intervene at the inspection stage, provide a corrected instruction, and continue — without regenerating the entire image from scratch. The paper's qualitative examples (Figure 4, second and third rows) show the model successfully detecting and correcting two distinct error types (instruction-prompt conflict and image-instruction misalignment) in a 2–3 cycle process, demonstrating the feasibility of this workflow. The average of 2.62 cycles per image means the user would review roughly 2–3 intermediate states per final image, which is a manageable interaction granularity for a professional creative workflow.