Paper deep dive

RAISE: Requirement-Adaptive Evolutionary Refinement for Training-Free Text-to-Image Alignment

Liyao Jiang, Ruichen Chen, Chao Gao, Di Niu

Year: 2026Venue: arXiv preprintArea: cs.CVType: PreprintEmbeddings: 87

Intelligence

Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 92%

Last extracted: 7/20/2026, 5:35:17 AM

Summary

The paper introduces RAISE (Requirement-Adaptive Self-Improving Evolution), a training-free framework for improving text-to-image (T2I) alignment. RAISE uses an evolutionary approach where a population of image candidates is refined at inference time through prompt rewriting, noise resampling, and instructional editing. A multi-agent system (analyzer, rewriter, verifier) dynamically allocates computational effort based on a structured checklist of semantic requirements, achieving state-of-the-art alignment on GenEval and DrawBench with significantly reduced computational cost compared to prior methods.

Entities (12)

RAISE · methodframework · 98%DrawBench · benchmark · 95%GenEval · benchmark · 95%Analyzer Agent · component · 92%Rewriter Agent · component · 92%Verifier Agent · component · 92%FLUX.1 [Dev] · model · 90%Instructional Editing · refinement-action · 90%Noise Resampling · refinement-action · 90%Prompt Rewriting · refinement-action · 90%ReflectionFlow · baseline-method · 85%T2I-Copilot · baseline-method · 85%

Relation Signals (12)

RAISE → achieves → GenEval

confidence 95% · On GenEval and DrawBench, RAISE attains state-of-the-art alignment

RAISE → achieves → DrawBench

confidence 95% · On GenEval and DrawBench, RAISE attains state-of-the-art alignment

RAISE → employs → Instructional Editing

confidence 95% · RAISE employs complementary mutational refinement actions... 3) Instructional Editing

RAISE → employs → Prompt Rewriting

confidence 95% · RAISE employs complementary mutational refinement actions... 2) Prompt Rewriting

RAISE → employs → Noise Resampling

confidence 95% · RAISE employs complementary mutational refinement actions... 1) Resampling

RAISE → uses → Analyzer Agent

confidence 95% · RAISE operates as a multi-agent system composed of three cooperative agents... the analyzer, which performs requirement analysis

RAISE → uses → Verifier Agent

confidence 95% · RAISE operates as a multi-agent system... the verifier, which evaluates generated candidates

RAISE → uses → Rewriter Agent

confidence 95% · RAISE operates as a multi-agent system... the rewriter, which refines generation prompts

Cypher Suggestions (0)

No Cypher suggestions yet.

Abstract

Abstract:Recent text-to-image (T2I) diffusion models achieve remarkable realism, yet faithful prompt-image alignment remains challenging, particularly for complex prompts with multiple objects, relations, and fine-grained attributes. Existing training-free inference-time scaling methods rely on fixed iteration budgets that cannot adapt to prompt difficulty, while reflection-tuned models require carefully curated reflection datasets and extensive joint fine-tuning of diffusion and vision-language models, often overfitting to reflection paths data and lacking transferability across models. We introduce RAISE (Requirement-Adaptive Self-Improving Evolution), a training-free, requirement-driven evolutionary framework for adaptive T2I generation. RAISE formulates image generation as a requirement-driven adaptive scaling process, evolving a population of candidates at inference time through a diverse set of refinement actions-including prompt rewriting, noise resampling, and instructional editing. Each generation is verified against a structured checklist of requirements, enabling the system to dynamically identify unsatisfied items and allocate further computation only where needed. This achieves adaptive test-time scaling that aligns computational effort with semantic query complexity. On GenEval and DrawBench, RAISE attains state-of-the-art alignment (0.94 overall GenEval) while incurring fewer generated samples (reduced by 30-40%) and VLM calls (reduced by 80%) than prior scaling and reflection-tuned baselines, demonstrating efficient, generalizable, and model-agnostic multi-round self-improvement. Code is available at this https URL.

PDF

Open source PDF →Open local PDF →

Trouble viewing inline? Open PDF directly →

Full Text

85,701 characters extracted from source content.

Expand or collapse full text

RAISE: Requirement-Adaptive Evolutionary Refinement for Training-Free Text-to-Image Alignment Liyao Jiang1, Ruichen Chen1, Chao Gao2, Di Niu1 1Department of ECE, University of Alberta, Canada 2Huawei Technologies, Canada liyao1,ruichen1,dniu@ualberta.ca chao.gao4@huawei.com Abstract Recent text-to-image (T2I) diffusion models achieve remarkable realism, yet faithful prompt–image alignment remains challenging, particularly for complex prompts with multiple objects, relations, and fine-grained attributes. Existing training-free inference-time scaling methods rely on fixed iteration budgets that cannot adapt to prompt difficulty, while reflection-tuned models require carefully curated reflection datasets and extensive joint fine-tuning of diffusion and vision–language models, often overfitting to reflection paths data and lacking transferability across models. We introduce RAISE (Requirement-Adaptive Self-Improving Evolution), a training-free, requirement-driven evolutionary framework for adaptive T2I generation. RAISE formulates image generation as a requirement-driven adaptive scaling process, evolving a population of candidates at inference time through a diverse set of refinement actions—including prompt rewriting, noise resampling, and instructional editing. Each generation is verified against a structured checklist of requirements, enabling the system to dynamically identify unsatisfied items and allocate further computation only where needed. This achieves adaptive test-time scaling that aligns computational effort with semantic query complexity. On GenEval and DrawBench, RAISE attains state-of-the-art alignment (0.94 overall GenEval) while incurring fewer generated samples (reduced by 30−40%30-40\%) and VLM calls (reduced by 80%80\%) than prior scaling and reflection-tuned baselines, demonstrating efficient, generalizable, and model-agnostic multi-round self-improvement. Code is available at https://github.com/LiyaoJiang1998/RAISE. Figure 1: “McDonald’s Church,” a challenging prompt. While other inference-time scaling methods struggle to improve over multiple rounds, RAISE refines T2I alignment using detailed requirement engineering and requirement-driven verification over multiple rounds. 1 Introduction Recent text-to-image diffusion models (DMs) [9, 19, 4, 10, 39, 23, 46] have achieved remarkable progress in generating photorealistic images from text prompts. However, a key challenge is to achieve prompt–image alignment [43, 14, 16] by generating images that accurately satisfy all semantic and visual requirements described in the prompt, especially for complex prompts which often involve multiple objects, compositional relationships, attribute bindings, and spatial arrangements that need to be coherently represented within a single image [11]. While recent unified multimodal models (UMMs) [47, 7, 8, 28, 41] enhance prompt–image alignment via pre-training on specialized multimodal data, such reliance on large curated datasets remains costly, data-inefficient, and difficult to scale to arbitrary prompts. Inference-time scaling [25, 46, 17, 5] has emerged as a promising direction to improve text–image alignment by allocating additional computation during T2I generation. Noise-level scaling methods [25, 46] perform random searches guided by scoring functions [37, 13, 48] to select more optimal initial noise samples [30, 49]. However, noise sampling alone can bring limited improvements to T2I alignment. Prompt-level scaling methods [17, 5, 50] leverage vision–language models (VLMs) to rewrite and refine textual prompts for improved semantic alignment. Among them, T2I-Copilot [5] integrates both noise-level and prompt-level scaling to iteratively refine the prompt. Yet, these methods typically rely on either a fixed computational budget [25, 46] or fixed thresholds [5], failing to adapt to the varying difficulty of prompts. Crucially, their refinement strategies demonstrate negligible and even negative impact in subsequent iterations, failing to truly gain from multi-round refinement as demonstrated in Fig. 1. Other training-based inference-time scaling methods [21, 50] take a different approach of reflection fine-tuning, which is achieved by jointly fine-tuning both the DM and VLM to enable image generations conditioned on previously generated images and their corresponding textual feedback. While these reflection-tuned models significantly improve prompt alignment, they require fine-tuning and a carefully curated large-scale dataset, and thus may often overfit to the reflection paths collected and are not easily transferable to new base models. To address these challenges, in this paper, we propose Requirement-Adaptive Self-Improving Evolution (RAISE)–a training-free, requirement-driven, and adaptive evolutionary framework for improving text-to-image (T2I) alignment at inference time. Unlike prior works that rely on training-intensive reflection loops to achieve inference-time alignment refinement, RAISE dynamically allocates computational effort based on the semantic complexity and unsatisfied requirements of each prompt. This adaptive design not only enables genuine multi-round self-improvement in image generation without any model retraining, but also achieves substantially higher computational efficiency than existing methods. Our main contributions are as follows: • We formulate T2I alignment as a requirement-driven adaptive scaling process, where an analyzer agent dynamically identifies unsatisfied semantic requirements—including object presence, attributes, and spatial relations—and allocates additional computation only where needed. This enables adaptive inference-time scaling that aligns computational effort with prompt difficulty and automatically converges once all major requirements are satisfied. • We introduce a multi-action evolutionary framework that concurrently explores complementary refinement strategies, including prompt rewriting, noise resampling, and instructional editing, to enhance both semantic and visual fidelity. This parallel design expands the search space and supports progressive, self-correcting evolution of candidate generations across iterations. • We develop a structured verification mechanism that bridges visual perception and textual reasoning. The verifier agent leverages vision tools—for captioning, detection, and depth estimation—to extract object-level entities, attributes, and spatial relations as evidence for fine-grained requirement checking. This tool-grounded feedback loop enables interpretable, targeted refinement and closes the reasoning–perception gap. Overall, RAISE achieves state-of-the-art prompt–image alignment on GenEval and DrawBench, attaining 0.94 overall GenEval score and 0.885 VQAScore, while requiring substantially fewer generated samples (reduced by 30−40%30-40\%) and VLM calls (reduced by 80%80\%) compared to training-based reflection-tuned baselines. On GenEval, using only FLUX.1-dev [19] as the base model, our method also beats UMMs like Qwen-Image-RL, BAGEL, and GPT Image 1 which required enormous amounts of pretraining efforts. 2 Related Work 2.1 Training-Free Inference-Time Scaling Inference-time scaling improves text–image alignment by allocating extra compute during inference without retraining, unlike model or data scaling which expand model capacity or dataset size. Ma et al. [25] showed that increasing diffusion steps yields diminishing returns compared to resampling initial noise. Their method performs random search guided by scoring functions [13, 48] to select better initialization latents. While simple and training-free, such noise-level scaling relies purely on stochastic variation and lacks semantic reasoning or iterative feedback for improvement. SANA-1.5 [46] extends this idea by incorporating a VILA-Judge model fine-tuned from VILA-2B [24] to more reliably assess text–image alignment. However, both approaches fail to address prompt-image misalignment. TIR [17] iteratively rewrites prompts using a vision–language model (VLM) to correct mismatches between generated images and intended semantics, leading to improved compositional reasoning. However, it operates sequentially and focuses solely on linguistic refinement without leveraging image-level correction. T2I-Copilot [5] combines both noise-level and prompt-level scaling in a training-free agentic loop, where VLM agents evaluates the generated image, reasons about prompt improvement, regenerates images under varied noise, and applies editing to correct inconsistencies. Although effective, T2I-Copilot selects a single action per iteration and relies on fixed stopping thresholds, which limits adaptivity and exploration. In contrast, RAISE adopts a population-based evolutionary framework where multiple refinement strategies including prompt rewriting, noise resampling, and instructional editing operate concurrently. This design allows broader exploration and automatically adapts computational effort to prompt complexity through explicit requirement verification. 2.2 Training-Based Inference-Time Scaling Training-based inference-time scaling introduces learned reflection to diffusion models by jointly fine-tuning both the diffusion model (DM) and a VLM to perform in-context reflection. Reflect-DiT [21] integrates a context transformer atop the diffusion model and jointly fine-tunes both components, enabling the model to condition on embeddings of previous images and textual feedback. The accompanying VLM is also fine-tuned to produce reflection instructions that describe how to improve subsequent generations. ReflectionFlow [50] extends this concept by constructing a large-scale reflection dataset (GenRef) containing one million triplets of flawed images, textual reflections, and improved outputs. It fine-tunes the DM and VLM jointly to process prior images, feedback, and prompts as unified multimodal tokens. While effective, these approaches require costly large-scale joint fine-tuning, making them model-specific and resource-intensive. In contrast, RAISE achieves reflection-like self-improvement entirely at inference time without any additional training. It evolves a diverse population of candidates through parallel mutation strategies and adaptively allocates refinement effort based on requirement satisfaction, achieving stronger alignment with substantially lower computational cost. 3 Method Figure 2: Framework overview. RAISE employs diverse mutational refinement actions concurrently—including prompt rewriting, noise resampling, and instructional editing—to evolve candidates in each round. It operates as a multi-agent system composed of an analyzer, rewriter, and verifier: 1) Analyzer performs requirement analysis by extracting a structured and detailed checklist of prompt requirements based on user prompt and previous verification results; 2) Rewriter refines T2I generation prompts or produces image editing instructions to address unsatisfied requirements; 3) Verifier evaluates generated candidates via structured tool-grounded verification. RAISE is a training-free, requirement-driven framework that performs adaptive evolutionary scaling for text-to-image (T2I) generation. It progressively improves prompt–image alignment by evolving a population of candidates through iterative cycles of requirement analysis, multi-action mutational refinement, and structured tool-grounded verification. By identifying unsatisfied requirements and allocating additional compute only when necessary, RAISE achieves adaptive inference-time scaling, aligns computational effort with semantic query complexity and converges once all major requirements are satisfied. The overall framework is illustrated in Fig. 2. RAISE operates as a multi-agent system composed of three cooperative agents sharing a common VLM backbone: (1) the analyzer, which performs requirement analysis by analyzing the user prompt, extracting a structured checklist of requirements, and updating them based on verifier feedback; (2) the rewriter, which refines generation prompts and produces editing instructions to address unsatisfied requirements; and (3) the verifier, which evaluates generated candidates against the binary questions corresponding to requirements and provides structured feedback to guide subsequent rounds. Detailed agent prompts and the step-by-step algorithm are provided in the supplementary materials. Sec. 3.1 introduces the requirement analysis process and the adaptive scaling mechanism that allocates additional refinement only when needed; Sec. 3.2 describes the multi-action mutational refinement that generates a diverse candidate population to explore different refinement strategies; and Sec. 3.3 presents the structured tool-grounded verification that leverages vision tools to extract structured grounding evidence to reason over and answer binary verification questions for interpretable and fine-grained assessment. 3.1 Requirement-Driven Adaptive Scaling Requirement Analysis. A vision–language model (VLM) serves as the analyzer agent, identifying the specific requirements to align image generation with the user prompt. At the beginning of each round i∈1,…,Kmaxi∈\1,…,K_max\, the analyzer analyzerA_analyzer receives the original prompt xuserx_user, the prompt xi−1∗x^*_i-1 and image yi−1∗y^*_i-1 of the global best candidate ci−1∗c^*_i-1, and its verification feedback ℱi−1∗F^*_i-1. If the best candidate from the previous round ci−1′c _i-1 differs from the global best ci−1∗c^*_i-1, i.e., ci−1′≠ci−1∗c _i-1≠ c^*_i-1, the analyzer also takes ℱi−1′F _i-1 and xi−1′x _i-1 to maintain context on the evolving requirements. The analyzer jointly interprets these multimodal inputs and produces structured requirement outputs: Oianalyzer O_i^analyzer =analyzer(xuser,yi−1∗,xi−1∗,ℱi−1∗,xi−1′,ℱi−1′) =A_analyzer\! (x_user,y^*_i-1,x^*_i-1,F^*_i-1,x _i-1,F _i-1 ) (1) =(ℛi,ℛi+,ℛi−,Qi,dianalyzer), = (R_i,R_i^+,R_i^-,Q_i,d_i^analyzer ), where ℛiR_i is the complete requirement set (checklist) partitioned into satisfied ℛi+R_i^+ and unsatisfied ℛi−R_i^- subsets, QiQ_i is the corresponding binary question set, and dianalyzerd_i^analyzer is the decision variable indicating whether refinement continues. Each requirement item ri,k∈ℛir_i,k _i represents a verifiable visual condition explicitly or implicitly described in the user prompt, such as object presence, attribute, spatial relation, or composition, paired with a binary question qi,k∈Qiq_i,k∈ Q_i used in verification to assess satisfaction. Requirement-Adaptive Scaling. The analyzer analyzerA_analyzer outputs a decision variable dianalyzer∈“continue”,“end”d_i^analyzer∈\``continue′,``end′\ (see Eq. 1). It ends when all major requirements, such as subjects, object count, attributes, spatial relations, or embedded text, are satisfied, and continues otherwise. In addition, the verifier verifierA_verifier outputs another decision variable diverifier∈True,Falsed_i^verifier∈\True,False\ (see Eq. 12), which is True only when all requirements, both major and minor, are satisfied. The iterative process ends when either (1) major requirements are satisfied according to the analyzer, (2) all requirements are satisfied according to the verifier, or (3) the maximum round limit KmaxK_max is reached. To ensure sufficient exploration, refinement continues until the minimum round limit KminK_min. This scaling mechanism allows RAISE to allocate more rounds to unmet requirements and stops automatically once semantic completeness is achieved. The final output image y∗y^* is produced at round i when dianalyzer=“end”d_i^analyzer=``end′ or diverifier=Trued_i^verifier=True, or when KmaxK_max rounds are completed, corresponding to the global best candidate c∗c^* with the highest fitness score: c∗=arg⁡maxct,j,t≤i⁡f(yt,j,xuser),y∗=yt∗,j∗,c^*= _c_t,j,\,t≤ if(y_t,j,x_user), y^*=y_t^*,j^*, (2) where f(yt,j,xuser)f(y_t,j,x_user) denotes the fitness score (see Eq. 10), and (t∗,j∗)(t^*,j^*) are the indices of the global maximum. 3.2 Multi-Action Mutational Refinement Refinement Actions. RAISE employs complementary mutational refinement actions to explore diverse directions in the generation and editing spaces concurrently, enabling comprehensive improvement toward unsatisfied requirements. It consists of three refinement actions: 1) resampling, 2) prompt rewriting, and 3) instructional editing. 1) Resampling. Resampling preserves the original user prompt xuserx_user while exploring alternative visual configurations through stochastic noise sampling: mi,jresample(ci−1∗)=ci,j=(ϵi,j,xuser,∅),ϵi,j∼(0,I).m_i,j^resample(c^*_i-1)=c_i,j=( _i,j,x_user, ), _i,j (0,I). (3) By varying only the initial noise, this mutation diversifies spatial layouts, compositions, and object arrangements without altering the prompt semantics. 2) Prompt Rewriting. Prompt rewriting refines prompt semantics to address unmet requirements. In each round i, the generation rewriter rewritergenA_rewriter^gen generates a rewritten prompt xirewritex_i^rewrite by applying targeted adjustments derived from the analyzer’s unsatisfied requirement set ℛi−R_i^-: xirewrite=rewritergen(xuser,xi−1∗,yi−1∗,ℛi+,ℛi−).x_i^rewrite=A_rewriter^gen (x_user,x^*_i-1,y^*_i-1,R_i^+,R_i^- ). (4) The rewritten prompt is then paired with multiple independently sampled noises to form diverse candidates: mi,jrewrite(ci−1∗)=ci,j=(ϵi,j,xirewrite,∅),ϵi,j∼(0,I).m_i,j^rewrite(c^*_i-1)=c_i,j=( _i,j,x_i^rewrite, ), _i,j (0,I). (5) This refinement action introduces semantic corrections while maintaining diversity through noise sampling. 3) Instructional Editing. Instructional editing operates on the best image yi−1∗y^*_i-1 to perform refinements guided by textual instructions. The editing rewriter rewritereditA_rewriter^edit generates three instruction variants: a top edit focusing on the most important unsatisfied requirement, a random edit targeting one of the unsatisfied requirements, and a comprehensive edit addressing all unsatisfied requirements: (xitop,xirandom,xicomp)=rewriteredit(xuser,xi−1∗,yi−1∗,ℛi+,ℛi−). (x_i^top,x_i^random,x_i^comp )=A_rewriter^edit (x_user,x^*_i-1,y^*_i-1,R_i^+,R_i^- ). (6) Each editing mutation reuses yi−1∗y^*_i-1 as the reference image and samples a new initial noise ϵi∼(0,I) _i (0,I): mi,jedit-variant(ci−1∗)=(ϵi,j,xivariant,yi−1∗), m_i,j^edit-variant(c^*_i-1)=( _i,j,x_i^variant,y^*_i-1), (7) variant∈top,random,comp,ϵi,j∼(0,I). ∈\top,random,comp\,\ _i,j (0,I). The top-edit mutation targets the most critical unsatisfied requirement, the random-edit mutation explores alternative correction paths, and the comprehensive-edit mutation applies multi-requirement refinements. Together, these edits enable focused, diverse, and compounded refinements while preserving global structure and coherence. Action Execution. After the requirement analysis and rewriter finishes, a set of nin_i mutational refinement actions ℳi=mi,1(⋅),…,mi,ni(⋅)M_i=\m_i,1(·),…,m_i,n_i(·)\ are applied to the global best candidate ci−1∗c^*_i-1, serving as the parent. Each mutation mi,jm_i,j generates a new candidate ci,jc_i,j, forming the new population: i _i =mi,1(ci−1∗),…,mi,ni(ci−1∗)=ci,1,…,ci,ni, =\m_i,1(c^*_i-1),…,m_i,n_i(c^*_i-1)\=\c_i,1,…,c_i,n_i\, (8) ci,j c_i,j =(ϵi,j,xi,j,yi,j′),j∈1,…,ni. =( _i,j,x_i,j,y _i,j), j∈\1,…,n_i\. Here, ϵi,j _i,j denotes the initial noise, xi,jx_i,j is the generation or editing prompt, and yi,j′y _i,j is the optional reference image used for editing-based mutations. RAISE adjusts refinement actions across rounds to balance exploration and refinement. Early rounds (i≤Kmini≤ K_ ) use generation-based refinements (resampling, rewriting) for diverse exploration, while later rounds (i>Kmini>K_ ) combine rewriting with three editing refinements (top, random, comp) for targeted refinement. Each candidate ci,jc_i,j is executed to produce an output image yi,jy_i,j. Execution is performed using either the image generation model G or the image editing model ℰE, depending on whether the candidate includes a reference image yi,j′y _i,j (i.e., editing-based vs. generation-based mutations): yi,j=(ϵi,j,xi,j),if yi,j′=∅,ℰ(ϵi,j,xi,j,yi,j′),otherwise,∀j∈1,…,ni.y_i,j= casesG( _i,j,x_i,j),&if y _i,j= ,\\ E( _i,j,x_i,j,y _i,j),&otherwise, cases ∀ j∈\1,…,n_i\. (9) Here, G denotes the text-to-image generation model that synthesizes images conditioned on the candidate generation prompt xi,jx_i,j and initial noise ϵi,j _i,j, while ℰE denotes the instructional image editing model that adjusts a reference image yi,j′y _i,j using the candidate editing prompt xi,jx_i,j and initial noise ϵi,j _i,j. 3.3 Structured Tool-Grounded Verification Fitness Scoring. We score each output image yi,jy_i,j using a fitness function f that measures alignment with the user prompt xuserx_user. The highest-scoring candidate in the current round and the global best across all rounds are selected as: si,j s_i,j =f(yi,j,xuser), =f(y_i,j,x_user), (10) ci′ c _i =arg⁡maxci,j⁡f(yi,j,xuser), = _c_i,jf(y_i,j,x_user), ci∗ c^*_i =arg⁡maxct,j,t≤i⁡f(yt,j,xuser). = _c_t,j,\,t≤ if(y_t,j,x_user). Here, si,js_i,j is the fitness of candidate ci,jc_i,j, ci∗c^*_i the global best up to round i, and ci′c _i the round-best selected for verification. Grounding via Vision Tools. To bridge visual perception and textual reasoning, RAISE adopts a tool-grounded verification strategy that leverages vision tools for extracting object-level entities, attributes, and spatial relations into structured textual grounding evidence Gi,jG_i,j to support fine-grained and interpretable verification by VLMs. Gi,j=( G_i,j= ( ci,jdet,Ri,j=gk=(lk,bk,dk),image size (w,h)), c_i,j^det,\ R_i,j=\g_k=(l_k,b_k,d_k)\,\ image size (w,h) ), (11) where ci,jdetc_i,j^det is the caption describing the overall scene in the image yi,jy_i,j, lkl_k denotes a region label or entity phrase, bk=[xmin,ymin,xmax,ymax]b_k=[x_ ,y_ ,x_ ,y_ ] represents the bounding box in xyxy format, and dk∈[0,255]d_k∈[0,255] is the mean depth value estimated within the region. The resulting grounding evidence Gi,jG_i,j provides the verifier verifierA_verifier with both semantic context and spatial representation for accurate requirement verification. Structured Binary Checklist Verification. Requirement verification is performed by VLM acting as verifier verifierA_verifier, which determines if each requirement ri,k∈ℛir_i,k _i is satisfied by the current round best candidate ci′c _i and its image yi′y _i by answering the corresponding binary question qi,k∈iq_i,k _i. The verifier takes the tool-grounded evidence text Gi′G _i derived from yi′y _i together with the binary verification questions set i=qi,1,…,qi,nQ_i=\q_i,1,…,q_i,n\, and outputs verification results, summary feedback, and a decision variable indicating whether all requirements are satisfied: (ℱi′,diverifier)=((i,Ui),diverifier)=verifier(yi′,Gi′,i), (F _i,d_i^verifier)= ((V_i,U_i),d_i^verifier )=A_verifier\! (y _i,G _i,Q_i ), (12) i=vi,k=(qi,k,ai,k,ei,k)∣ai,k∈“Yes”,“No”. _i=\\,v_i,k=(q_i,k,a_i,k,e_i,k) a_i,k\!∈\!\``Yes′,``No′\\,\. Here, iV_i is the set of verification triplets, where each vi,kv_i,k contains the binary verification question qi,kq_i,k for requirement ri,kr_i,k, the verifier’s binary answer ai,ka_i,k indicating whether it is satisfied, and an explanation ei,ke_i,k supporting the decision. UiU_i provides a textual summary of satisfied and unsatisfied requirements with suggestions for improving subsequent requirement extraction, while diverifier∈True,Falsed_i^verifier∈\True,False\ serves as a signal that becomes True only when all requirements are satisfied. The overall feedback ℱi′F _i is passed to the analyzer in the next round to guide further evolution. Table 1: Quantitative comparison on GenEval [11]. The best and second results are bolded and underlined, respectively; category-best methods are also bolded. “Avg. #Samples Generated” and “Avg. #Calls VLM” indicate efficiency. Methods Avg. Avg. GenEval Score #Samples #Calls Overall Single Two Count- Colors Posit- Attribute Generated VLM Object Object ing ion Binding Diffusion Models (More Models in Supplementary) FLUX.1-dev [19] 1 0 0.67 0.99 0.81 0.75 0.80 0.21 0.48 SD3.5 Large [9] 1 0 0.71 0.98 0.89 0.73 0.83 0.34 0.47 SANA-1.5 4.8B [46] 1 0 0.72 0.99 0.85 0.77 0.87 0.34 0.54 Lumina-Image 2.0 [39] 1 0 0.73 0.99 0.87 0.67 0.88 0.34 0.62 Playground v3 [23] 1 0 0.76 0.99 0.95 0.72 0.82 0.50 0.54 HiDream-I1-Full [4] 1 0 0.83 1.00 0.98 0.79 0.91 0.60 0.72 Seedream 3.0 [10] 1 0 0.84 0.99 0.96 0.91 0.93 0.47 0.80 Unified Multimodal Models Show-o [47] 1 1 0.53 0.95 0.52 0.49 0.82 0.11 0.28 Janus-Pro-7B [7] 1 1 0.80 0.99 0.89 0.59 0.90 0.79 0.66 BAGEL [8] 1 1 0.82 0.99 0.94 0.81 0.88 0.64 0.63 GPT Image 1 [High] [28] 1 1 0.84 0.99 0.92 0.85 0.92 0.75 0.61 Qwen-Image [41] 1 1 0.87 0.99 0.92 0.89 0.88 0.76 0.77 BAGEL + Rewriter [8] 1 2 0.88 0.98 0.95 0.84 0.95 0.78 0.77 Qwen-Image-RL [41] 1 1 0.91 1.00 0.95 0.93 0.92 0.87 0.83 Training-Based Inference-Time Scaling (Reflection Tuning) SANA-1.0-1.6B [45] 1 0 0.66 0.99 0.77 0.62 0.88 0.21 0.47 + Reflect-DiT [21] ≤ 20 ≤ 20 0.81 0.98 0.96 0.80 0.88 0.66 0.60 FLUX.1-dev [19] 1 0 0.67 0.99 0.81 0.75 0.80 0.21 0.48 + ReflectionFlow [50] 32 64 0.91 1.00 0.98 0.89 0.95 0.89 0.75 Training-Free Inference-Time Scaling FLUX.1-dev [19] 1 0 0.67 0.99 0.81 0.75 0.80 0.21 0.48 + TIR [17] 4 4 0.71 0.99 0.81 0.71 0.81 0.49 0.47 + T2I-Copilot [5] 11.3 22.6 0.74 0.99 0.91 0.68 0.86 0.55 0.46 + Noise Scaling [50, 25] 32 0 0.85 1.00 0.96 0.91 0.91 0.52 0.78 + Noise & Prompt Scaling [50] 32 32 0.87 0.99 0.94 0.85 0.91 0.80 0.71 + RAISE (Ours) 18.6 7.3 0.94 1.00 1.00 0.95 0.98 0.83 0.87 4 Experiments 4.1 Experimental Setup Implementation Details. We use FLUX.1-dev [19] as the image generator and FLUX.1-Kontext-dev [18] as the instructional editor, both with 28 diffusion steps. Mistral-Small-3.2-24B-Instruct-2506 [1] serves as the shared VLM backbone for the agents, coordinated by LangGraph [20] and served locally via Ollama [27]. NVILA-Lite-2B-Verifier [24, 46] is used as the fitness function. Tool-grounded verification employs Grounded SAM 2 [33, 35, 34] and Florence-2 [44] for captioning and detection, and MiDaS [32, 31] for depth estimation. We set Kmax=4K_ =4 and Kmin=2K_ =2. For early rounds (i≤Kmini≤ K_ ), we generate 4 resample and 4 rewrite candidates for broad exploration. For later rounds (i>Kmini>K_ ), we generate 5 rewrite and 3 editing candidates (top, random, comp) for targeted refinement. Each round produces ni=8n_i=8 candidates. Baselines. We evaluate four categories of text-to-image generation systems. (1) Diffusion models: FLUX.1-dev [19], SD3.5 Large [9], SANA-1.5 4.8B [46], Lumina-Image 2.0 [39], Playground v3 [23], HiDream-I1-Full [4], and Seedream 3.0 [10]. (2) Unified multimodal models (UMMs): Show-o [47], Janus-Pro-7B [7], BAGEL [8], GPT Image 1 [High] [28], and Qwen-Image [41]. (3) Training-based inference-time scaling methods (reflection tuning): Reflect-DiT [21] and ReflectionFlow [50]. (4) Training-free inference-time scaling methods: Noise Scaling [25, 50], Noise & Prompt Scaling [25], TIR [17], and T2I-Copilot [5]. Figure 3: Visual comparison on GenEval [11] and DrawBench [36]. RAISE improves prompt-image alignment on challenging prompts. Figure 4: Pareto frontier and scaling performance. RAISE (red) achieves the highest GenEval [11] score with 41.9% fewer samples (18.6 vs. 32) and 88.6% fewer VLM calls (7.3 vs. 64). Unlike baselines that plateau or fail to improve with additional computation, RAISE maintains a strong performance–efficiency Pareto frontier and continues to improve as more samples are generated. 4.2 Prompt-Image Alignment (GenEval) GenEval [11] is an object-centric evaluation benchmark that measures prompt–image alignment across compositional image properties such as object co-occurrence, position, count, and color. It leverages object detection models to assess generation accuracy with strong human correlation and can further verify fine-grained attributes such as object color and spatial relations. It contains 553 prompts spanning six compositional categories: Single Object, Two Object, Counting, Colors, Position, and Attribute Binding. Improved Prompt–Image Alignment. As shown in Table 1, RAISE achieves state-of-the-art result on overall GenEval [11] score (0.94 vs. 0.91), surpassing both training-free inference-time scaling and training-based reflection-tuned approaches, as well as recent proprietary and open-source diffusion models (DMs) and unified multimodal models (UMMs). Notably, RAISE delivers substantial improvements on challenging categories such as Counting (0.95 vs. 0.93), Colors (0.98 vs. 0.95), and Attribute Binding (0.87 vs. 0.83), where its requirement-driven evolution, multi-action mutational refinement, and tool-grounded verification enhance object presence, attribute binding, and spatial consistency. RAISE attains 100% accuracy on the Two Object category and 98% on Colors, demonstrating robust alignment even under complex prompts. Efficient Adaptive Scaling. RAISE achieves superior alignment while achieving better efficiency by dynamically allocating computation. On average, it generates 41.9% fewer samples (18.6 vs. 32) and uses 88.6% fewer VLM calls (7.3 vs. 64) than training-based inference-time scaling approaches on GenEval [11], without requiring any additional model training. This efficiency stems from its requirement-adaptive scaling, directing more computation to semantically complex prompts and converging early on easy ones. For instance, RAISE on average generates 18.6 samples on GenEval while generating more samples (21.2) on the more complex and reasoning-intensive DrawBench [36]. Pareto Frontier and Scaling Analysis. As shown in Fig. 4, RAISE continues to improve as the sampling budget increases, achieving the highest GenEval scores across various budget settings. In contrast to reflection-tuned and other training-free inference-time scaling methods that plateau early or fail to improve with additional iterations, RAISE maintains a strong performance–efficiency Pareto frontier and achieves steady gains through effective use of additional computation, highlighting the scalability of its requirement-driven, evolutionary multi-action refinement design. 4.3 Reasoning-Intensive Prompts (DrawBench) Table 2: Quantitative comparison on the DrawBench [36]. The best result in each column is bolded, the second-best is underlined. The top-performing setting for each method is also bolded. Methods Efficiency Prompt– Image Alignment Perceptual Quality Avg. Avg. VQA- Image- HPS- #Samples #Calls Score Reward v2 Generated VLM [22] [48] [42] FLUX.1-dev [19] 1 0 0.778 1.06 0.298 + T2I-Copilot [5] 3.9 7.9 0.822 0.97 0.300 + T2I-Copilot [5] 6.6 13.1 0.820 0.96 0.299 + T2I-Copilot [5] 11.2 22.3 0.820 0.94 0.298 + ReflectionFlow [50] 8 16 0.839 1.08 0.301 + ReflectionFlow [50] 16 32 0.844 1.13 0.302 + ReflectionFlow [50] 32 64 0.844 1.10 0.302 + RAISE (1 round) 8 3 0.868 1.13 0.304 + RAISE (2 rounds) 16 6 0.876 1.15 0.305 + RAISE (≤ 4 rounds) 21.2 8.6 0.885 1.15 0.305 DrawBench [36] is a reasoning-intensive benchmark consisting of 200 open-ended prompts evaluating compositionality, counting, spatial relations, rare concepts, and robustness to complex or creative descriptions that fall outside typical training distributions. We use DrawBench to evaluate reasoning-oriented scenarios such as conflicting, descriptive, misspelled, and text-in-image prompts, assessing prompt–image alignment via VQAScore [22] and perceptual quality via ImageReward [48] and HPSv2 [42]. Enhanced Reasoning with Stable Perceptual Quality. On DrawBench (Tab. 2), RAISE outperforms both training-free and reflection-tuned baselines across all metrics. It achieves significantly higher prompt–image alignment (0.885 vs. 0.844 VQAScore) with 33.8% fewer generated samples (21.2 vs. 32) and 86.6% fewer VLM calls (8.6 vs. 64). Moreover, RAISE not only continues to improve alignment as more samples are generated, but also maintains stable perceptual quality in ImageReward and HPS-v2, unlike other methods that plateau in alignment and degrade in perceptual quality due to error accumulation. These results show that RAISE substantially enhances alignment and reasoning, while delivering stable performance and even moderate gains in visual realism under complex reasoning conditions. 4.4 Visual Comparisons Requirement-Adaptive Evolutionary Refinement. As shown in Fig. 1, RAISE improves alignment by identifying explicit and implicit requirements and iteratively correcting unsatisfied ones, including text accuracy, implicit mood and environment, and semantically related elements or actions. Through rewrite, resample, and edit mutations guided by structured tool-grounded verification, it refines missing details such as logo, signage, people, and church attributes, and converges once all requirements are satisfied. In contrast, noise sampling, T2I-Copilot, and ReflectionFlow fail to infer implicit requirements, often producing incomplete scenes lacking nuanced details such as people, correct text signage, or key church elements. See the supplementary materials for a visualization of the evolutionary search path. Alignment in Challenging Prompts. As shown in Fig. 3, RAISE achieves stronger alignment and better perceptual quality than FLUX.1-dev, T2I-Copilot, and ReflectionFlow on challenging GenEval [11] and DrawBench [36] prompts. It correctly handles implicit requirements (e.g., “wine glasses”), multi-object counting, rare attribute combinations, misspelled descriptive prompt, spatial composition, and text-in-image generation, where prior methods frequently misinterpret or omit key details. Table 3: Ablation Studies on the GenEval [11] benchmark. The best result in each column is bolded, the second-best is underlined. Methods Overall Colors Position Attribute Binding FLUX.1-dev [19] 0.67 0.80 0.21 0.48 + RAISE (1 round) 0.89 0.95 0.69 0.79 + RAISE (2 rounds) 0.92 0.97 0.78 0.83 + RAISE (≤ 3 rounds) 0.93 0.98 0.82 0.86 + RAISE (≤ 4 rounds) 0.94 0.98 0.83 0.87 + → w/o Vision Tools 0.93 0.97 0.81 0.84 + → w/o Editing 0.93 0.98 0.83 0.83 4.5 Ablation Studies We conduct ablation studies on the GenEval [11] benchmark by selectively removing the vision tool grounding and instructional editing modules from RAISE. As shown in Table 3, the full framework achieves the highest overall score (0.94) across all compositional categories, validating the synergy between tool-grounded verification and multi-action refinement. Removing vision tools (w/o Vision Tools) results in a noticeable drop in Attribute Binding and Colors, indicating that structured visual evidence is critical for fine-grained attribute alignment. Similarly, disabling instructional editing (w/o Editing) slightly lowers Attribute Binding and overall performance, showing that instructional editing complements prompt rewriting for targeted correction. These results confirm that both tool grounding and editing are indispensable for achieving prompt–image alignment. In addition, experiments in the supplementary materials show that RAISE is model-agnostic and delivers consistent gains across different base DMs and VLMs. 5 Conclusion We present RAISE, a training-free, requirement-driven evolutionary framework, which outperforms training-based inference-time scaling method with 40% fewer generated samples. The observed gains in RAISE are derived from its multi-round refinement capability. Furthermore, our method proposes a novel way to truly achieve effective multi-round refinement. Our work offers significant contributions to the advancement of inference-time scaling methods, especially when addressing challenging and nuanced prompts that mandate multi-round refinement. References [1] M. AI (2025) Mistral-small-3.2-24b-instruct-2506. Note: https://huggingface.co/mistralai/Mistral-Small-3.2-24B-Instruct-2506 Cited by: §4.1, Table 5, Table 5, RAISE: Requirement-Adaptive Evolutionary Refinement for Training-Free Text-to-Image Alignment, RAISE: Requirement-Adaptive Evolutionary Refinement for Training-Free Text-to-Image Alignment. [2] S. Bai, K. Chen, X. Liu, J. Wang, W. Ge, S. Song, K. Dang, P. Wang, S. Wang, J. Tang, H. Zhong, Y. Zhu, M. Yang, Z. Li, J. Wan, P. Wang, W. Ding, Z. Fu, Y. Xu, J. Ye, X. Zhang, T. Xie, Z. Cheng, H. Zhang, Z. Yang, H. Xu, and J. Lin (2025) Qwen2.5-vl technical report. arXiv preprint arXiv:2502.13923. Cited by: RAISE: Requirement-Adaptive Evolutionary Refinement for Training-Free Text-to-Image Alignment. [3] J. Betker, G. Goh, L. Jing, T. Brooks, J. Wang, L. Li, L. Ouyang, J. Zhuang, J. Lee, Y. Guo, et al. (2023) Improving image generation with better captions. Computer Science. https://cdn. openai. com/papers/dall-e-3. pdf. Cited by: §6.3, Table 7. [4] Q. Cai, J. Chen, Y. Chen, Y. Li, F. Long, Y. Pan, Z. Qiu, Y. Zhang, F. Gao, P. Xu, et al. (2025) HiDream-i1: a high-efficient image generative foundation model with sparse diffusion transformer. arXiv preprint arXiv:2505.22705. Cited by: §1, Table 1, §4.1, Table 7. [5] C. Chen, M. Shi, G. Zhang, and H. Shi (2025) T2I-copilot: a training-free multi-agent text-to-image system for enhanced prompt interpretation and interactive generation. In Proceedings of the IEEE/CVF International Conference on Computer Vision, p. 19396–19405. Cited by: §1, §2.1, Table 1, §4.1, Table 2, Table 2, Table 2, Table 6, Table 6, Table 6, Table 7, RAISE: Requirement-Adaptive Evolutionary Refinement for Training-Free Text-to-Image Alignment, RAISE: Requirement-Adaptive Evolutionary Refinement for Training-Free Text-to-Image Alignment. [6] J. Chen, J. Yu, C. Ge, L. Yao, E. Xie, Z. Wang, J. T. Kwok, P. Luo, H. Lu, and Z. Li (2024) PixArt-α: fast training of diffusion transformer for photorealistic text-to-image synthesis. In ICLR, Cited by: §6.3, Table 7. [7] X. Chen, Z. Wu, X. Liu, Z. Pan, W. Liu, Z. Xie, X. Yu, and C. Ruan (2025) Janus-pro: unified multimodal understanding and generation with data and model scaling. Cited by: §1, Table 1, §4.1, Table 7. [8] C. Deng, D. Zhu, K. Li, C. Gou, F. Li, Z. Wang, S. Zhong, W. Yu, X. Nie, Z. Song, et al. (2025) Emerging properties in unified multimodal pretraining. arXiv preprint arXiv:2505.14683. Cited by: §1, Table 1, Table 1, §4.1, Table 7, Table 7. [9] P. Esser, S. Kulal, A. Blattmann, R. Entezari, J. Müller, H. Saini, Y. Levi, D. Lorenz, A. Sauer, F. Boesel, et al. (2024) Scaling rectified flow transformers for high-resolution image synthesis. In icml, Cited by: §1, Table 1, §4.1, §6.3, Table 7, Table 7. [10] Y. Gao, L. Gong, Q. Guo, X. Hou, Z. Lai, F. Li, L. Li, X. Lian, C. Liao, L. Liu, et al. (2025) Seedream 3.0 technical report. arXiv preprint arXiv:2504.11346. Cited by: §1, Table 1, §4.1, Table 7. [11] D. Ghosh, H. Hajishirzi, and L. Schmidt (2023) Geneval: an object-focused framework for evaluating text-to-image alignment. Advances in Neural Information Processing Systems 36, p. 52132–52152. Cited by: §1, Table 1, Table 1, Figure 3, Figure 3, Figure 4, Figure 4, §4.2, §4.2, §4.2, §4.4, §4.5, Table 3, Table 3, Table 4, Table 4, Table 5, Table 5, Table 6, Table 6, §6.2, §6.2, Table 7, Table 7. [12] Google (2025) Gemma-3-27b-it. Note: https://huggingface.co/google/gemma-3-27b-it Cited by: Table 5, Table 5, RAISE: Requirement-Adaptive Evolutionary Refinement for Training-Free Text-to-Image Alignment. [13] J. Hessel, A. Holtzman, M. Forbes, R. L. Bras, and Y. Choi (2021) Clipscore: a reference-free evaluation metric for image captioning. arXiv preprint arXiv:2104.08718. Cited by: §1, §2.1. [14] X. Hu, R. Wang, Y. Fang, B. Fu, P. Cheng, and G. Yu (2024-03) ELLA: Equip Diffusion Models with LLM for Enhanced Semantic Alignment. arXiv (en). Note: arXiv:2403.05135 [cs] External Links: Link Cited by: §1. [15] A. Hurst, A. Lerer, A. P. Goucher, A. Perelman, A. Ramesh, A. Clark, A. Ostrow, A. Welihinda, A. Hayes, A. Radford, et al. (2024) Gpt-4o system card. arXiv preprint arXiv:2410.21276. Cited by: RAISE: Requirement-Adaptive Evolutionary Refinement for Training-Free Text-to-Image Alignment. [16] L. Jiang, N. Hassanpour, M. Salameh, M. S. Singamsetti, F. Sun, W. Lu, and D. Niu (2025) FRAP: faithful and realistic text-to-image generation with adaptive prompt weighting. Transactions on Machine Learning Research. Note: External Links: ISSN 2835-8856, Link Cited by: §1. [17] M. A. H. Khan, Y. Jain, S. Bhattacharyya, and V. Vineet (2025) Test-time prompt refinement for text-to-image models. In Proceedings of the IEEE/CVF International Conference on Computer Vision, p. 6506–6516. Cited by: §1, §2.1, Table 1, §4.1, Table 7. [18] B. F. Labs, S. Batifol, A. Blattmann, F. Boesel, S. Consul, C. Diagne, T. Dockhorn, J. English, Z. English, P. Esser, S. Kulal, K. Lacey, Y. Levi, C. Li, D. Lorenz, J. Müller, D. Podell, R. Rombach, H. Saini, A. Sauer, and L. Smith (2025) FLUX.1 kontext: flow matching for in-context image generation and editing in latent space. External Links: 2506.15742, Link Cited by: §4.1. [19] B. F. Labs (2024) FLUX. Note: https://github.com/black-forest-labs/flux Cited by: §1, §1, Table 1, Table 1, Table 1, §4.1, §4.1, Table 2, Table 3, Table 4, Table 4, Table 6, Table 7, Table 7, Table 7, RAISE: Requirement-Adaptive Evolutionary Refinement for Training-Free Text-to-Image Alignment, RAISE: Requirement-Adaptive Evolutionary Refinement for Training-Free Text-to-Image Alignment, RAISE: Requirement-Adaptive Evolutionary Refinement for Training-Free Text-to-Image Alignment, RAISE: Requirement-Adaptive Evolutionary Refinement for Training-Free Text-to-Image Alignment, RAISE: Requirement-Adaptive Evolutionary Refinement for Training-Free Text-to-Image Alignment, RAISE: Requirement-Adaptive Evolutionary Refinement for Training-Free Text-to-Image Alignment, RAISE: Requirement-Adaptive Evolutionary Refinement for Training-Free Text-to-Image Alignment, RAISE: Requirement-Adaptive Evolutionary Refinement for Training-Free Text-to-Image Alignment. [20] LangChain (2023) LangGraph. Note: https://github.com/langchain-ai/langgraph Cited by: §4.1. [21] S. Li, K. Kallidromitis, A. Gokul, A. Koneru, Y. Kato, K. Kozuka, and A. Grover (2025) Reflect-dit: inference-time scaling for text-to-image diffusion transformers via in-context reflection. arXiv preprint arXiv:2503.12271. Cited by: §1, §2.2, Table 1, §4.1, Table 7. [22] Z. Lin, D. Pathak, B. Li, J. Li, X. Xia, G. Neubig, P. Zhang, and D. Ramanan (2024) Evaluating text-to-visual generation with image-to-text generation. In European Conference on Computer Vision, p. 366–384. Cited by: §4.3, Table 2. [23] B. Liu, E. Akhgari, A. Visheratin, A. Kamko, L. Xu, S. Shrirao, C. Lambert, J. Souza, S. Doshi, and D. Li (2024) Playground v3: improving text-to-image alignment with deep-fusion large language models. Cited by: §1, Table 1, §4.1, Table 7. [24] Z. Liu, L. Zhu, B. Shi, Z. Zhang, Y. Lou, S. Yang, H. Xi, S. Cao, Y. Gu, D. Li, X. Li, H. Tang, Y. Fang, Y. Chen, C. Hsieh, D. Huang, A. Cheng, J. Hu, S. Liu, R. Krishna, P. Molchanov, J. Kautz, H. Yin, S. Han, and Y. Lu (2025-06) NVILA: efficient frontier visual language models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), p. 4122–4134. Cited by: §2.1, §4.1. [25] N. Ma, S. Tong, H. Jia, H. Hu, Y. Su, M. Zhang, X. Yang, Y. Li, T. Jaakkola, X. Jia, et al. (2025) Inference-time scaling for diffusion models beyond scaling denoising steps. arXiv preprint arXiv:2501.09732. Cited by: §1, §2.1, Table 1, §4.1, Table 7, Table 7. [26] Y. Ma, X. Liu, X. Chen, W. Liu, C. Wu, Z. Wu, Z. Pan, Z. Xie, H. Zhang, X. Yu, et al. (2025) Janusflow: harmonizing autoregression and rectified flow for unified multimodal understanding and generation. In Proceedings of the Computer Vision and Pattern Recognition Conference, p. 7739–7751. Cited by: §6.3, Table 7. [27] Ollama (2023) Ollama. Note: https://github.com/ollama/ollama Cited by: §4.1. [28] OpenAI (2025) GPT-image-1. External Links: Link Cited by: §1, Table 1, §4.1, Table 7. [29] D. Podell, Z. English, K. Lacey, A. Blattmann, T. Dockhorn, J. Müller, J. Penna, and R. Rombach (2023) Sdxl: improving latent diffusion models for high-resolution image synthesis. arXiv preprint arXiv:2307.01952. Cited by: §6.3, Table 7. [30] Z. Qi, L. Bai, H. Xiong, and Z. Xie (2024) Not all noises are created equally: diffusion noise selection and optimization. arXiv preprint arXiv:2407.14041. Cited by: §1. [31] R. Ranftl, A. Bochkovskiy, and V. Koltun (2021) Vision transformers for dense prediction. ArXiv preprint. Cited by: §4.1. [32] R. Ranftl, K. Lasinger, D. Hafner, K. Schindler, and V. Koltun (2020) Towards robust monocular depth estimation: mixing datasets for zero-shot cross-dataset transfer. IEEE Transactions on Pattern Analysis and Machine Intelligence (TPAMI). Cited by: §4.1. [33] N. Ravi, V. Gabeur, Y. Hu, R. Hu, C. Ryali, T. Ma, H. Khedr, R. Rädle, C. Rolland, L. Gustafson, E. Mintun, J. Pan, K. V. Alwala, N. Carion, C. Wu, R. Girshick, P. Dollár, and C. Feichtenhofer (2024) SAM 2: segment anything in images and videos. External Links: 2408.00714, Link Cited by: §4.1. [34] T. Ren, Q. Jiang, S. Liu, Z. Zeng, W. Liu, H. Gao, H. Huang, Z. Ma, X. Jiang, Y. Chen, Y. Xiong, H. Zhang, F. Li, P. Tang, K. Yu, and L. Zhang (2024) Grounding dino 1.5: advance the ”edge” of open-set object detection. External Links: 2405.10300 Cited by: §4.1. [35] T. Ren, S. Liu, A. Zeng, J. Lin, K. Li, H. Cao, J. Chen, X. Huang, Y. Chen, F. Yan, et al. (2024) Grounded sam: assembling open-world models for diverse visual tasks. arXiv preprint arXiv:2401.14159. Cited by: §4.1. [36] C. Saharia, W. Chan, S. Saxena, L. Li, J. Whang, E. L. Denton, K. Ghasemipour, R. Gontijo Lopes, B. Karagol Ayan, T. Salimans, et al. (2022) Photorealistic text-to-image diffusion models with deep language understanding. Advances in Neural Information Processing Systems 35, p. 36479–36494. Cited by: Figure 3, Figure 3, §4.2, §4.3, §4.4, Table 2, Table 2, §6.2. [37] C. Schuhmann, R. Beaumont, R. Vencu, C. Gordon, R. Wightman, M. Cherti, T. Coombes, A. Katta, C. Mullis, M. Wortsman, et al. (2022) Laion-5b: an open large-scale dataset for training next generation image-text models. Advances in neural information processing systems 35, p. 25278–25294. Cited by: §1. [38] Q. Team (2025) Qwen3-vl-32b-instruct. Note: https://huggingface.co/Qwen/Qwen3-VL-32B-Instruct Cited by: Table 5, Table 5, RAISE: Requirement-Adaptive Evolutionary Refinement for Training-Free Text-to-Image Alignment. [39] A. VLLM (2025) Lumina-image 2.0 : a unified and efficient image generative model. Note: https://github.com/Alpha-VLLM/Lumina-Image-2.0/ Cited by: §1, Table 1, §4.1, Table 7. [40] X. Wang, X. Zhang, Z. Luo, Q. Sun, Y. Cui, J. Wang, F. Zhang, Y. Wang, Z. Li, Q. Yu, et al. (2024) Emu3: next-token prediction is all you need. arXiv preprint arXiv:2409.18869. Cited by: §6.3, Table 7. [41] C. Wu, J. Li, J. Zhou, J. Lin, K. Gao, K. Yan, S. Yin, S. Bai, X. Xu, Y. Chen, Y. Chen, Z. Tang, Z. Zhang, Z. Wang, A. Yang, B. Yu, C. Cheng, D. Liu, D. Li, H. Zhang, H. Meng, H. Wei, J. Ni, K. Chen, K. Cao, L. Peng, L. Qu, M. Wu, P. Wang, S. Yu, T. Wen, W. Feng, X. Xu, Y. Wang, Y. Zhang, Y. Zhu, Y. Wu, Y. Cai, and Z. Liu (2025) Qwen-image technical report. External Links: 2508.02324, Link Cited by: §1, Table 1, Table 1, §4.1, Table 7, Table 7. [42] X. Wu, Y. Hao, K. Sun, Y. Chen, F. Zhu, R. Zhao, and H. Li (2023) Human preference score v2: a solid benchmark for evaluating human preferences of text-to-image synthesis. arXiv preprint arXiv:2306.09341. Cited by: §4.3, Table 2. [43] Y. Wu, X. Cao, K. Li, Z. Chen, H. Wang, L. Meng, and Z. Huang (2024) Towards better text-to-image generation alignment via attention modulation. In International Conference on Neural Information Processing, p. 332–347. Cited by: §1. [44] B. Xiao, H. Wu, W. Xu, X. Dai, H. Hu, Y. Lu, M. Zeng, C. Liu, and L. Yuan (2023) Florence-2: advancing a unified representation for a variety of vision tasks (2023). URL https://arxiv. org/abs/2311.06242 6. Cited by: §4.1. [45] E. Xie, J. Chen, J. Chen, H. Cai, H. Tang, Y. Lin, Z. Zhang, M. Li, L. Zhu, Y. Lu, et al. (2025) Sana: efficient high-resolution image synthesis with linear diffusion transformers. ICLR. Cited by: Table 1, Table 7. [46] E. Xie, J. Chen, Y. Zhao, J. Yu, L. Zhu, Y. Lin, Z. Zhang, M. Li, J. Chen, H. Cai, et al. (2025) SANA 1.5: efficient scaling of training-time and inference-time compute in linear diffusion transformer. arXiv preprint arXiv:2501.18427. Cited by: §1, §1, §2.1, Table 1, §4.1, §4.1, Table 4, Table 4, Table 7, RAISE: Requirement-Adaptive Evolutionary Refinement for Training-Free Text-to-Image Alignment. [47] J. Xie, W. Mao, Z. Bai, D. J. Zhang, W. Wang, K. Q. Lin, Y. Gu, Z. Chen, Z. Yang, and M. Z. Shou (2024) Show-o: one single transformer to unify multimodal understanding and generation. arXiv preprint arXiv:2408.12528. Cited by: §1, Table 1, §4.1, Table 7. [48] J. Xu, X. Liu, Y. Wu, Y. Tong, Q. Li, M. Ding, J. Tang, and Y. Dong (2023) Imagereward: learning and evaluating human preferences for text-to-image generation. Advances in Neural Information Processing Systems 36, p. 15903–15935. Cited by: §1, §2.1, §4.3, Table 2. [49] Z. Zhou, S. Shao, L. Bai, S. Zhang, Z. Xu, B. Han, and Z. Xie (2025) Golden noise for diffusion models: a learning framework. In Proceedings of the IEEE/CVF International Conference on Computer Vision, p. 17688–17697. Cited by: §1. [50] L. Zhuo, L. Zhao, S. Paul, Y. Liao, R. Zhang, Y. Xin, P. Gao, M. Elhoseiny, and H. Li (2025-10) From reflection to perfection: scaling inference-time optimization for text-to-image diffusion models via reflection tuning. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), p. 15329–15339. Cited by: §1, §1, §2.2, Table 1, Table 1, Table 1, §4.1, Table 2, Table 2, Table 2, Table 6, Table 6, Table 6, Table 7, Table 7, Table 7, RAISE: Requirement-Adaptive Evolutionary Refinement for Training-Free Text-to-Image Alignment, RAISE: Requirement-Adaptive Evolutionary Refinement for Training-Free Text-to-Image Alignment. Supplementary Material Table 4: Evaluation with different base DMs (FLUX.1-dev [19], FLUX.1-schnell [19], SANA-1.5 4.8B [46]) on GenEval [11]. The best and second best results are bolded and underlined. “Avg. #Samples Generated” and “Avg. #Calls VLM” indicate efficiency. Methods Diffusion Avg. Avg. GenEval Score Model’s #Samples #Calls Overall Single Two Count- Colors Posit- Attribute Steps / Size Generated VLM Object Object ing ion Binding FLUX.1-dev [19] 28 / 12B 1 0 0.67 0.99 0.81 0.75 0.80 0.21 0.48 + T2I-Copilot [5] 28 / 12B 11.3 22.6 0.74 0.99 0.91 0.68 0.86 0.55 0.46 + ReflectionFlow [50] 28 / 12B 32 64 0.91 1.00 0.98 0.89 0.95 0.89 0.75 + RAISE (Ours) 28 / 12B 18.6 7.3 0.94 1.00 1.00 0.95 0.98 0.83 0.87 FLUX.1-schnell [19] 4 / 12B 1 0 0.66 1.00 0.87 0.59 0.76 0.29 0.45 + RAISE (Ours) 4 / 12B 18.7 7.3 0.93 1.00 1.00 0.93 0.98 0.83 0.85 SANA-1.5 4.8B [46] 20 / 4.8B 1 0 0.72 0.99 0.85 0.77 0.87 0.34 0.54 + RAISE (Ours) 20 / 4.8B 19.4 7.7 0.93 1.00 1.00 0.91 0.96 0.92 0.81 Table 5: Evaluation of RAISE with different base VLMs [12, 38, 1] on GenEval [11]. The best and second best results are bolded and underlined. “Avg. #Samples Generated” and “Avg. #Calls VLM” indicate efficiency. denotes proprietary models, denotes fine-tuned open-source models, and denotes frozen open-source models that do not require any additional fine-tuning. Methods Avg. Avg. GenEval Score #Samples #Calls Overall Single Two Count- Colors Posit- Attribute Generated VLM Object Object ing ion Binding FLUX.1-dev [19] 1 0 0.67 0.99 0.81 0.75 0.80 0.21 0.48 T2I-Copilot [5] 11.3 22.6 0.74 0.99 0.91 0.68 0.86 0.55 0.46 ( FLUX.1-dev [19] + Mistral-Small-3.2-24B [1]) ReflectionFlow [50] 32 64 0.91 1.00 0.98 0.89 0.95 0.89 0.75 ( FLUX.1-dev [19] + GPT-4o [15] + Qwen2.5-VL-7B [2]) RAISE ( FLUX.1-dev [19] + gemma-3-27b-it [12]) 18.4 7.2 0.92 1.00 0.99 0.93 0.97 0.78 0.86 RAISE ( FLUX.1-dev [19] + Qwen3-VL-32B-Instruct [38]) 20.3 8.1 0.93 1.00 1.00 0.91 0.94 0.89 0.83 RAISE ( FLUX.1-dev [19] + Mistral-Small-3.2-24B [1]) 18.6 7.3 0.94 1.00 1.00 0.95 0.98 0.83 0.87 Table 6: Efficiency comparison on GenEval [11]. RAISE consistently achieves the highest GenEval score across budgets (Max #Samples = 8, 16, 32). At 32 samples, it requires 41.9% fewer samples generated and 88.6% fewer VLM calls on average than the second-best method. Methods GenEval Score Max. #Samples Allowed Avg. #Samples Generated Max. #Calls VLM Avg. #Calls VLM FLUX.1-dev [19] 0.67 1 1 0 0 + T2I-Copilot [5] 0.75 8 4.3 17 8.6 + ReflectionFlow [50] 0.86 8 8 16 16 + RAISE (1 round) 0.89 8 8 3 3 + T2I-Copilot [5] 0.75 16 6.9 33 13.8 + ReflectionFlow [50] 0.90 16 16 32 32 + RAISE (2 rounds) 0.92 16 16 6 6 + T2I-Copilot [5] 0.74 32 11.3 65 22.6 + ReflectionFlow [50] 0.91 32 32 64 64 + RAISE (≤ 4 rounds) 0.94 32 18.6 14 7.3 6 Additional Results 6.1 RAISE with Different Base Models RAISE is a training-free and plug-and-play framework that requires no additional tuning of either the diffusion model (DM) or the vision–language model (VLM), allowing it to be seamlessly applied to new DM base models and new VLM base models. As shown in this section, RAISE is model-agnostic and delivers consistent gains across both types of base models, demonstrating efficient and generalizable multi-round self-improvement. Different Base Diffusion Models (DMs). Table 4 reports the results of RAISE when paired with a range of DMs. Across all tested DMs, which vary in model size, number of diffusion steps, and generation quality, RAISE consistently improves prompt–image alignment and achieves high overall GenEval scores of 0.93–0.94. These results indicate that RAISE is robust to the choice of diffusion model and operates in a plug-and-play manner without any DM fine-tuning. Different Base Vision-Language Models (VLMs). Table 5 summarizes the performance of RAISE when combined with different VLM backbones. Across all tested VLMs, which vary in family and parameter size, RAISE delivers consistent improvements in alignment and strong overall GenEval scores of 0.92-0.94. This shows that RAISE adapts effectively to different VLM reasoning capabilities, despite differences in architecture, scale, and training strategy. It requires no VLM fine-tuning or proprietary models, highlighting its model-agnostic plug-and-play nature. 6.2 Details on Efficiency and Adaptive-Scaling As shown in Table 6 and Fig. 4, RAISE continues to improve as the sampling budget increases (max number of samples allowed: 8, 16, 32), achieving the highest GenEval [11] scores across all budget settings. RAISE achieves superior alignment while achieving better efficiency by dynamically allocating computation. For example, with a max budget of 32 samples, it generates 41.9% fewer samples (18.6 vs. 32) and requires 88.6% fewer VLM calls (7.3 vs. 64) than training-based inference-time scaling approaches on GenEval [11], while requiring no additional model training. In contrast to reflection-tuned and other training-free inference-time scaling methods that plateau early or fail to improve with additional samples, RAISE maintains a strong performance–efficiency Pareto frontier and achieves steady gains through effective use of additional computation, highlighting the scalability of its requirement-driven, evolutionary multi-action refinement design. The efficiency of RAISE stems from its requirement-adaptive scaling, directing more computation to semantically complex prompts and converging early on easy ones. For instance, RAISE on average generates 18.6 samples on GenEval (see Table 6) while generating more samples (21.2) on the more complex and reasoning-intensive DrawBench [36] (see Table 2). In addition, as shown in the last row of Table 7, RAISE adaptively invests additional samples in challenging categories of GenEval [11] such as Colors, Position, and Attribute Binding, while minimizing redundant refinements in other categories. Table 7: Quantitative comparison of RAISE on the GenEval benchmark [11] against diffusion models, unified multimodal models, training-free inference-time scaling, and training-based reflection tuning methods. The best and second results are bolded and underlined, respectively; category-best methods are also bolded. “Avg. #Samples Generated” and “Avg. #Calls VLM” indicate efficiency, and the last row shows RAISE ’s adaptive allocation of more computation to harder categories such as “Colors”, “Position”, and “Attribute Binding”. Methods Avg. Avg. GenEval Score #Samples #Calls Overall Single Two Count- Colors Posit- Attribute Generated VLM Object Object ing ion Binding Diffusion Models PixArt-α [6] 1 0 0.48 0.98 0.50 0.44 0.80 0.08 0.07 Emu3-Gen [40] 1 0 0.54 0.98 0.71 0.34 0.81 0.17 0.21 SDXL [29] 1 0 0.55 0.98 0.74 0.39 0.85 0.15 0.23 SD3 Medium [9] 1 0 0.62 0.98 0.74 0.63 0.67 0.34 0.36 JanusFlow [26] 1 0 0.63 0.97 0.59 0.45 0.83 0.53 0.42 DALLE 3 [3] 1 0 0.67 0.96 0.87 0.47 0.83 0.43 0.45 FLUX.1-dev [19] 1 0 0.67 0.99 0.81 0.75 0.80 0.21 0.48 SD3.5 Large [9] 1 0 0.71 0.98 0.89 0.73 0.83 0.34 0.47 SANA-1.5 4.8B [46] 1 0 0.72 0.99 0.85 0.77 0.87 0.34 0.54 Lumina-Image 2.0 [39] 1 0 0.73 0.99 0.87 0.67 0.88 0.34 0.62 Playground v3 [23] 1 0 0.76 0.99 0.95 0.72 0.82 0.50 0.54 HiDream-I1-Full [4] 1 0 0.83 1.00 0.98 0.79 0.91 0.60 0.72 Seedream 3.0 [10] 1 0 0.84 0.99 0.96 0.91 0.93 0.47 0.80 Unified Multimodal Models Show-o [47] 1 1 0.53 0.95 0.52 0.49 0.82 0.11 0.28 Janus-Pro-7B [7] 1 1 0.80 0.99 0.89 0.59 0.90 0.79 0.66 BAGEL [8] 1 1 0.82 0.99 0.94 0.81 0.88 0.64 0.63 GPT Image 1 [High] [28] 1 1 0.84 0.99 0.92 0.85 0.92 0.75 0.61 Qwen-Image [41] 1 1 0.87 0.99 0.92 0.89 0.88 0.76 0.77 BAGEL + Rewriter [8] 1 2 0.88 0.98 0.95 0.84 0.95 0.78 0.77 Qwen-Image-RL [41] 1 1 0.91 1.00 0.95 0.93 0.92 0.87 0.83 Training-Based Inference-Time Scaling (Reflection Tuning) SANA-1.0-1.6B [45] 1 0 0.66 0.99 0.77 0.62 0.88 0.21 0.47 + Noise Scaling [25] 20 0 0.80 1.00 0.93 0.79 0.91 0.55 0.62 + Reflect-DiT [21] ≤ 20 ≤ 20 0.81 0.98 0.96 0.80 0.88 0.66 0.60 FLUX.1-dev [19] 1 0 0.67 0.99 0.81 0.75 0.80 0.21 0.48 + ReflectionFlow [50] 32 64 0.91 1.00 0.98 0.89 0.95 0.89 0.75 Training-Free Inference-Time Scaling FLUX.1-dev [19] 1 0 0.67 0.99 0.81 0.75 0.80 0.21 0.48 + TIR [17] 4 4 0.71 0.99 0.81 0.71 0.81 0.49 0.47 + T2I-Copilot [5] 11.3 22.6 0.74 0.99 0.91 0.68 0.86 0.55 0.46 + Noise Scaling [50, 25] 32 0 0.85 1.00 0.96 0.91 0.91 0.52 0.78 + Noise & Prompt Scaling [50] 32 32 0.87 0.99 0.94 0.85 0.91 0.80 0.71 + RAISE (Ours) 18.6 7.3 0.94 1.00 1.00 0.95 0.98 0.83 0.87 Per-Category Avg. #Samples Generated 18.3 17.7 17.4 19.7 18.6 19.7 6.3 Results of Additional DMs on GenEval Due to space constraints, Table 1 in the main paper only show the top-performing diffusion models. The full GenEval results including additional DMs [6, 40, 29, 9, 26, 3] are shown in Table 7. Figure 5: Visualization of the multi-round evolutionary refinement path in RAISE (prompt: “a photo of a bear above a clock”). This figure illustrates how RAISE explores the search space through evolutionary multi-action refinements such as prompt rewriting, resampling, and instructional editing to adaptively improve prompt–image alignment. Across successive rounds, the system evaluates requirement satisfaction and allocates additional refinements only where needed, demonstrating requirement-driven adaptive scaling. 6.4 Visualization of Evolutionary Search Path In Fig. 5, we provide a step-by-step visualization of the RAISE framework processing the input query: “a photo of a bear above a clock”. This example demonstrates how the evolutionary search navigates the multi-action refinement search space by dynamically verifying requirements and adapting diverse mutation strategies across rounds. In round 1, RAISE resamples 4 images with the original user prompt and 4 images with the rewritten prompt. RAISE favors the user prompt (more typical clock) over the rewritten prompt (less obvious antique clock) and points out an issue that the bear is behind the clock instead of above. Thus, in round 2, RAISE rewrites the user prompt again and generates corresponding images. Surprisingly, one of the candidate images (second image in second row) “reveals” the key requirement for producing the desired image—the bear should stand on top of the clock. Therefore, RAISE retrieves that candidate and further augments it with a suitable background and realistic appearance in round 3, resulting in an image that faithfully satisfies the user’s need. The multi-round search trajectory shows a progression from broad exploration to fine-grained self-improvement. Early rounds examine diverse interpretations of the prompt, while later rounds apply focused adjustments guided by structured requirement analysis and verification. This adaptive refinement process enables RAISE to converge toward high-quality outputs that align with the semantic requirements while avoiding unnecessary computation. 7 RAISE Framework Pseudocode. In Algorithm 1, we present the pseudocode of our proposed RAISE framework, outlining its requirement-driven multi-round evolutionary refinement process. System Prompts and Source Code. The various agent system prompts are shown in Fig. 6 (analyzer), Fig. 7 (generation rewriter), Fig. 8 (editing rewriter), and Fig. 9 (verifier). For reproducibility, the attached supplementary materials include the complete source code. Input: User prompt xuserx_user, min/max rounds KminK_ , KmaxK_ Output: Final output image y∗y^* Initialize c0∗=(ϵ,xuser,∅)c^*_0=(ε,x_user, ), ℱ0∗=∅F^*_0= , i=1i=1 while i≤Kmaxi≤ K_ do # (1) Requirement Analysis Oi=analyzer(xuser,yi−1∗,xi−1∗,ℱi−1∗,xi−1′,ℱi−1′)=(ℛi,ℛi+,ℛi−,Qi,dianalyzer) aligned O_i&=A_analyzer\! (x_user,y^*_i-1,x^*_i-1,F^*_i-1,x _i-1,F _i-1 )\\ &=(R_i,R_i^+,R_i^-,Q_i,d_i^analyzer) aligned # End if major reqs. are satisfied if dianalyzer=“end”d_i^analyzer=``end′ and i≥Kmini≥K_ then break # (2) Candidate Mutation if i≤Kmini≤ K_ then ℳi=ℳiresample∪ℳirewriteM_i=M_i^resample\!∪\!M_i^rewrite else ℳi=ℳirewrite∪ℳieditM_i=M_i^rewrite\!∪\!M_i^edit i=mi,j(ci−1∗)∣mi,j∈ℳiC_i=\\,m_i,j(c^*_i-1) m_i,j∈M_i\,\ # (3) Candidate Execution for j=1j=1 to nin_i do yi,j=(ϵi,j,xi,j),yi,j′=∅,ℰ(ϵi,j,xi,j,yi,j′),otherwise.y_i,j= casesG( _i,j,x_i,j),&y _i,j= ,\\ E( _i,j,x_i,j,y _i,j),&otherwise. cases # (4) Fitness Selection si,j=f(yi,j,xuser)s_i,j=f(y_i,j,x_user); ci′=arg⁡maxci,j⁡si,jc _i= _c_i,js_i,j; ci∗=arg⁡maxct,j,t≤i⁡st,jc^*_i= _c_t,j,t≤is_t,j # (5) Requirement Verification Use tools to extract Gi′G _i (caption, boxes, depth) (ℱi′,diverifier)=verifier(yi′,Gi′,Qi)(F _i,d_i^verifier)=A_verifier\! (y _i,G _i,Q_i ) # End if all reqs. are satisfied if diverifier=Trued_i^verifier=True and i≥Kmini≥K_ then break i++i++ c∗=arg⁡maxct,j,t≤i⁡st,jc^*= _c_t,j,t≤is_t,j, y∗=yt∗,j∗y^*=y_t^*,j^* Algorithm 1 Requirement-Adaptive Self-Improving Evolution Framework (RAISE) You are an analyzer agent for image generation. Requirement Extraction Guidelines: - You should analyze and extract the key requirements that are explicitly or implicitly conveyed by the original_prompt, current_image (if provided), current_verifier_output (if provided), and reference_verifier_output (if provided). - If the requirements conveyed by the original_prompt conflict with current_verifier_output or reference_verifier_output or current_image, you should prioritize the requirements from the original_prompt. - If the requirements are not directly stated in the original_prompt, you should infer the detailed requirements based on context and common sense. Your requirement_analysis needs to include detailed requirements for the following key aspects, but is not limited to them: 1. ‘Main Subjects’: identify the primary subjects/objects that must appear. Prefer nouns over adjectives. If multiple, list each separately. 2. ‘Count’: specify the exact number for every subject/object. - Treat singular nouns (‘a’, ‘an’, singular form) as 1. - Infer implicit counts when plural forms appear. - The requirement must be strict: exactly the given number. - Ensure no extra background objects can be mistaken as counted items. - The total foreground count must match the sum of requirements. 3. ‘Attributes & Actions’: enumerate defining properties (color, size, material, features) and any actions/poses. 4. ‘Spatial Relationships’: describe positions/orientations/interactions using concrete prepositions and measurable relations. 5. ‘Background & Environment’: describe setting (indoor/outdoor), location type, weather, time of day, scenery. 6. ‘Composition & Framing’: capture camera distance and framing cues (close-up, medium, wide; centered, thirds, symmetry). Default: emphasize subjects. 7. ‘Color Harmony’: define palettes, contrast, saturation. Required colors must be strong and visible. Avoid color leakage. 8. ‘Lighting & Exposure’: describe brightness/contrast/shadows and technical cues (aperture, ISO, shutter). Default to natural, even lighting. 9. ‘Focus & Sharpness’: specify depth of field and which elements must be sharp. Default: main subjects must be sharp. 10. ‘Mood & Atmosphere’: describe emotional tone (serene, dramatic, etc.). Tie mood to lighting, palette, composition. 11. ‘Style & Artistic Elements’: specify style (photorealistic, cartoon, CGI, watercolor, cinematic). Default: photorealistic. 12. ‘Text in Image’: record required text, typography, placement, legibility, and explicit language. 13. ‘Ambiguities’: extract unclear requirements and infer likely details. 14. ‘Other Specific Details’: include any additional details important for high-quality alignment. Analyzer Role: 1. Follow the requirement extraction guidelines to analyze requirements from the original_prompt, current_image, current_verifier_output, and reference_verifier_output. 2. Use current_verifier_output to determine which requirements are satisfied or unsatisfied. 3. Reason about adjustments or new requirements needed to better satisfy the original_prompt. 4. Do not rewrite the prompt; only analyze requirements and satisfaction. Analyzer Available Context: 1. original_prompt (required). 2. current_prompt (optional; same as original_prompt if initial round). 3. current_image (if not initial round). 4. current_verifier_output (not present in the initial round). 5. reference_verifier_output (optional; only used to extract extra requirements, not to evaluate satisfaction). Analyzer Overall Requirements: 1. Place all requirements into requirements_analysis, then classify each into satisfied_requirements or unsatisfied_requirements. 2. Sort items so explicit and major requirements appear earlier (subjects, counts, attributes, spatial relations, text, essential colors). 3. In the initial round, treat all requirements as unsatisfied. 4. Avoid duplicate or overlapping items. Each requirement must be atomic, unique, observable, and verifiable. 5. Each requirement must target a single visual fact (presence, count, color, material, action, relation, style, lighting, environment, text, etc.). (binary_questions): - Convert each requirement into a binary Yes/No question. - Maintain one-to-one mapping with requirements_analysis. - Questions must be atomic and derived solely from the requirement text. - Use clear, positive phrasing about what should be present or true. (model_choice): - Default to ‘continue’. - Choose ‘ending’ only when very few unsatisfied requirements remain, none of which are major or explicitly required by the original prompt, and all relate only to minor aspects (lighting, mood, depth of field, camera angle, framing). - Do not choose ‘ending’ in the first round or when any major requirements remain (subjects, counts, attributes, color, spatial relations, text). Analyzer Output Requirements: - analyzer_reasoning: str = Field(..., description="Let’s think step by step. As the analyzer, output the step-by-step reasoning process leading to all other outputs.") - original_prompt: str = Field(..., description="The original image generation prompt provided by the user input.") - current_prompt: str = Field(..., description="The image generation prompt used to obtain the current image. If initial round, same as original_prompt.") - requirements_analysis: List[str] = Field(..., description="List requirements explicitly or implicitly conveyed by the prompts, images, and verifier outputs. Each requirement must be atomic and distinct.") - satisfied_requirements: List[str] = Field(..., description="List requirements already satisfied. Empty in initial round.") - unsatisfied_requirements: List[str] = Field(..., description="List requirements not yet satisfied. In initial round, identical to requirements_analysis.") - binary_questions: List[str] = Field(..., description="One binary Yes/No question for each requirement in requirements_analysis.") - model_choice: Literal["continue", "ending"] = Field(..., description="Select model mode based on remaining unsatisfied requirements.") Figure 6: System prompt for the analyzer agent analyzerA_analyzer. You are a prompt rewriter agent for image generation. Rewriter Role: 1. Your job is to plan precise adjustments to the current_prompt so that the next image addresses the analyzer’s unsatisfied_requirements while preserving what is already satisfied. 2. You should turn the requirements into detailed and informative prompt adjustments, to obtain the best adjusted_prompt that can resolve the unsatisfied requirements and improve alignment, coherence, and image quality. Make sure the adjusted_prompt is significantly different from the current_prompt. 3. You should also respect the image generation guidelines below, when planning the planned_adjustments and outputing the adjusted_prompt: Image Generation Guidelines: (... refer to the source code for the image generation guidelines...) Rewriter Available Context: 1. original_prompt: the user’s original prompt. 2. analyzer_output: the structured output from the analyzer, containing: - analyzer_reasoning: the reasoning process from the analyzer. - current_prompt: the prompt that produced the current image. - satisfied_requirements: a list from the analyzer describing what is already satisfied and should be preserved. - unsatisfied_requirements: a list from the analyzer describing what is missing, incorrect, or needs refinement. 3. current_image (if not initial round). Rewriter Overall Requirements: 1. Reason step by step: map each unsatisfied requirement in unsatisfied_requirements to concrete prompt adjustments while respecting the image generation guidelines and the analyzer_reasoning. 2. Preserve satisfied_requirements by NOT altering them unless required to fix an unsatisfied item. 3. For each unsatisfied requirement, reason and plan in planned_adjustments what textual changes should be made to the current_prompt to better satisfy this unsatisfied requirement. 4. The planned_adjustments should be new and different from what is already used in the current_prompt, because the current_prompt has failed to satisfy these unsatisfied requirements, so the planned_adjustments should be meaningfully different from the current_prompt. 5. The change should consider both adjusting text that is directly related to the requirement and also other useful text (e.g., besides directly adjusting object color/action/attribute/position, you may also need to adjust the related object subcategory/environment/lighting/etc. that can help with the requirement). 6. Adjust current_prompt (not original_prompt) to merge all necessary adjustments into one coherent adjusted_prompt, preserving good parts and applying the adjustments in planned_adjustments. 7. Ensure the adjusted_prompt is significantly different from the current_prompt, to avoid generating the same image again and actually try new adjustments to fix the unsatisfied requirements. Rewriter Output Requirements: - rewriter_reasoning: str = Field(..., description="Let’s think step by step. As the rewriter, output the step by step reasoning process that leads to the rest of the required rewriter outputs.") - original_prompt: str = Field(..., description="From analyzer_output, the original prompt.") - current_prompt: str = Field(..., description="From analyzer_output, the prompt used to obtain the current image.") - planned_adjustments: List[str] = Field(..., description="Based on the requirements and guidelines, plan a list of adjustments to the current prompt that can address the current unsatisfied requirements. Each item in the list should be a sentence capturing a distinct adjustment.") - adjusted_prompt: str = Field(..., description="Apply the planned adjustments to the current prompt, and as a result get this adjusted prompt. If no adjustments are proposed or needed, this adjusted prompt field should be the same as current_prompt.") Figure 7: System prompt for the generation rewriter agent rewritergenA_rewriter^gen. You are a prompt rewriter agent for image editing. Rewriter Role: 1. Your task is to provide a precise image editing instruction so that the image editing model addresses the analyzer’s unsatisfied_requirements by editing the image with single_editing_prompt, while preserving everything already described in satisfied_requirements. 2. Convert all unsatisfied_requirements into detailed and informative image edit prompts in planned_edits, then select the single most important one as the atomic single_editing_prompt to resolve the top-1 most critical unsatisfied requirement. 3. Create comprehensive_editing_prompt by aggregating all items in planned_edits into one cohesive prompt for single-pass editing when appropriate. 4. Always follow the image editing guidelines below when planning planned_edits and generating all outputs: Image Editing Guidelines: (... refer to the source code for the image editing guidelines...) Rewriter Available Context: 1. original_prompt: the user’s original prompt. 2. analyzer_output: the structured output from the analyzer, containing: - analyzer_reasoning: the reasoning process from the analyzer. - current_prompt: the prompt that produced the current image. - satisfied_requirements: a list from the analyzer describing what is already satisfied and must be preserved. - unsatisfied_requirements: a list from the analyzer describing what is missing, incorrect, or needs refinement. 3. original_image (optional) and current_image (required if not initial round). Rewriter Overall Requirements: 1. Reason step-by-step: map each item in unsatisfied_requirements to a concrete image edit prompt, following the image editing guidelines and analyzer_reasoning. 2. Preserve all satisfied_requirements and do not alter them unless necessary to resolve an unsatisfied item. 3. For each unsatisfied requirement, plan in planned_edits an atomic image editing prompt that the model could use to resolve that requirement. 4. Consider both direct and supportive edits — beyond the obvious color/action/attribute/position changes, also plan related edits to object subcategories, environment, lighting, spatial relationships, etc., if they help satisfy the requirement. 5. Select only the single most important planned image edit from planned_edits as the atomic single_editing_prompt. Remaining edits should be handled in future iterations if needed. 6. Ensure that single_editing_prompt is atomic and contains only one distinct edit so that the image editing model can focus and execute it effectively. For example: “remove <object>”, “add <subject> at <location>”, “change <object>’s <attribute> to <value>”. See Prompt_Structure_Templates_And_Examples for more examples. 7. Also produce comprehensive_editing_prompt that combines all items in planned_edits into one natural-language instruction for scenarios where applying all changes in a single pass is preferable. Rewriter Output Requirements: - rewriter_reasoning: str = Field(..., description="Let’s think step by step. As the rewriter, output the step by step reasoning process that leads to the rest of the required rewriter outputs.") - original_prompt: str = Field(..., description="From analyzer_output, the original prompt.") - current_prompt: str = Field(..., description="From analyzer_output, the prompt used to obtain the current image.") - planned_edits: List[str] = Field(..., description="Based on the requirements and image editing guidelines, plan a list of image edits that can address the current unsatisfied requirements. Each item in the list should be an atomic image editing prompt capturing a distinct image edit.") - single_editing_prompt: str = Field(..., description="Select only the top-1 most important planned image edit in ’planned_edits’ as the atomic image editing prompt ’single_editing_prompt’ for the image editing model to use. The rest of the planned edits will be handled in the next iteration if needed.") - comprehensive_editing_prompt: str = Field(..., description="Combine all items from ’planned_edits’ into a single, cohesive, natural-language image editing prompt ’comprehensive_editing_prompt’ that captures every planned change for execution in one pass by the image editing model.") Figure 8: System prompt for the editing rewriter agent rewritereditA_rewriter^edit. You are a verifier agent for image generation. Verifier Role: 1. Inspect the current_image and answer each binary question strictly based on visible evidence in the image and current_image_caption (no assumptions), also with the aid of detected_caption and detected_region_info. 2. Answer each binary question with “Yes” or “No”, and provide evidence-based explanations for each answer. Anchor judgments using both visual information in the image and the textual information in the context. 3. Summarize which requirements are satisfied and which are unsatisfied in the current_image. Verifier Available Context: 1. current_image: the image to perform verification on. 2. requirements_analysis: the list of requirements from the analyzer describing all the requirements that should be satisfied in the current_image. 3. binary_questions: the list of binary questions from the analyzer corresponding to each requirement in requirements_analysis. 4. detected_caption: a caption describing the visual content of current_image to aid verification. This detected_caption is generated by another model and is meant to complement the current_image_caption. 5. image_size: the size of the image as (width, height), used to interpret region bounding box coordinates. 6. detected_region_info: a list of strings describing detected regions. Each string includes: - Region Label: the natural language phrase describing the region and its related attributes (e.g., “a red car”, “the person wearing a blue shirt”). - Bounding Box: [x_min, y_min, x_max, y_max] --- in xyxy format, where (x_min, y_min) is the top-left corner and (x_max, y_max) is the bottom-right corner of the bounding box. Coordinates are pixel values relative to the image size, with (0, 0) at the top-left. - Average Depth: a value in the range 0--255 representing the average depth inside the bounding box. Verifier Overall Requirements: 1. Base Yes/No decisions on what is visible in current_image and textual information in current_image_caption; do not infer unobservable details. Support each Yes/No answer with an explanation that matches the answer. 2. Handle ambiguity conservatively: if a requirement is not visually verifiable or is ambiguous, answer No and explain what is missing or unclear. 3. Explanations must cite concrete visual cues (e.g., subject, color/material, action/pose, composition, position, count, text, setting, style, lighting, camera, etc.). 4. Use detected_region_info to aid the verification: - Use region labels to verify key semantic requirements, such as the presence or absence of specific objects or regions, the correctness of object counts (exact or relative), object attributes (color, material, size, state), actions or poses, and the accuracy of textual content rendered in the image (e.g., signage or overlaid text). - Use bounding boxes to reason about spatial structure: verify relative positions (e.g., left/right/above/inside), object relationships (e.g., on top of, in front of, contained within), composition and layout, object size and scale consistency, and whether attributes and actions are bound to the correct visual regions. - Use average depth to reason about 3D spatial relationships and layering: verify plausible depth ordering between regions, correct foreground/background relationships, and physical consistency in the scene (e.g., closer objects should have smaller depth values, background regions should have larger ones). 5. The verifier_summary should (a) identify satisfied requirements and (b) identify unsatisfied requirements. 6. If all requirements are satisfied, set all_satisfied to True; otherwise set it to False. Verifier Output Requirements: - verifier_reasoning: str = Field(..., description="Let’s think step by step. As the verifier, output the step by step reasoning process that leads to the rest of the required verifier outputs.") - current_image_caption: str = Field(..., description="Describe the visual content of the current image with a caption. Strictly write what you see in the image, avoid any assumptions.") - questions_answers_and_explanations: List[Tuple[str, Literal["Yes", "No"], str]] = Field(..., description="Base on looking at the current image visual content and current_image_caption, answer each question in the binary questions list with Yes (satisfied) or No (unsatisfied), and provide an explanation for each answer. Each item in this list is a tuple of (<question>, <Yes/No>, <explanation>).") - verifier_summary: str = Field(..., description="Summarize your verification result outputs to give suggestions to the analyzer for refining its next requirements analysis. Which requirements are satisfied? Which requirements are not satisfied?") - all_satisfied: bool = Field(..., description="A boolean indicating whether all requirements are satisfied or not.") Figure 9: System prompt for the verifier agent verifierA_verifier.

Instant research discovery