acceptodds
Under review as a conference paper at ICLR 2027

HALo: Enabling Self-Improving Image Generation via A Hierarchical Agentic Loop

Abstract

Real-world image-generation queries are demanding and often underspecified. They often entail complex specifications, such as spatial layouts and rendered text, while requiring external knowledge that is beyond the generator's internal knowledge. Conventional feed-forward models struggle to handle these queries. Recent methods therefore make image generation agentic by adding reasoning, retrieval and repeated revision. However, they often employ a single loop to plan and revise the whole prompt. This design introduces two key limitations: first, requirements may be omitted or facts lost during planning, prior to image generation; second, correcting a single failed requirement necessitates rewriting the entire prompt, potentially disturbing constraints that have already been satisfied. We introduce HALo, a hierarchical agentic loop with three layers: layout specifies what the image should contain, draft prepares supporting material for constraints that a textual prompt alone cannot enforce, and render generates the image. HALo improves generation at two levels. An inter-layer loop establishes a bidirectional flow. Plans and supporting materials propagate upward from layout to rendering, while unresolved failures are routed downward to the drafting stage for local repair. Crucially, satisfied constraints remain fixed throughout this process, preventing regression in subsequent revisions. Within each layer, an inner loop checks and refines its output in a local context. Intermediate trial-and-error remains local, thus avoiding any rewriting of outputs already established by other layers. Consequently, failed constraints are rectified by updating only their associated supporting material, while the global plan and satisfied constraints remain invariant. Across four benchmarks spanning world knowledge, compositional generation, knowledge-intensive generation and image editing, HALo achieves the best overall performance among the compared methods.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
agentic image generation, text-to-image generation, iterative refinement

Reviews

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

The authors introduce HALo, a hierarchical agentic loop for image generation organized into three layers: the layout layer specifies what the image should contain via a structured plan of constraints, the draft layer prepares supporting material (e.g., sketches or references) for constraints that a textual prompt alone cannot enforce, and the render layer generates the final image. Self-improvement operates at two levels: an inter-layer loop that propagates plans and materials upward while routing unresolved failures downward for localized repair (with satisfied constraints held fixed), and an inner loop that enables each layer to check and refine its own output within a local context.

Critical strengths
  1. The motivation is well-founded. The three-layer workflow combined with the two-level self-revision mechanism addresses limitations of flat, single-loop agentic generation, particularly the risk of omitting requirements or disturbing already-satisfied constraints during revision.
  2. HALo achieves the best overall performance among the compared methods across four benchmarks spanning world knowledge, compositional generation, knowledge-intensive generation, and image editing.
Critical weaknesses
  1. The proposed inter-layer loop and inner loop introduce additional LLM calls, which increase token cost and latency. This may limit practical application value and constitutes an inherent drawback of a workflow-centric approach.
  2. The ideas of hierarchical and multi-level organization are not new and have already demonstrated effectiveness in prior works.
Questions for authors
  1. The authors note that GenClaw is particularly close to HALo, with a notable difference being the choice of backbone. Could the authors provide results obtained when using Claude-Opus-4.6 (as GenClaw did)?
  2. Could the authors share additional details on the design and implementation choices for the inter-layer loop and the inner loop? Clarifying whether these constitute a non-trivial module would help assess the insights they offer for future work.
6 comments
AuthorsOpenReview ↗

Response to Reviewer SGL2: Cost, Decomposition by Failure Source, and Loop Design

We thank the reviewer for the careful review. We will add the new results to the revised paper.

Q1. Cost and latency.

The overhead of the two loops is small relative to agentic baselines. Per-sample cost over the four benchmarks, compared with GenClaw:

MethodStatisticLLM callsOutput tokens (est.)Image callsLatency (s)
GenClawMean5.517321.28197
Median49861112
HALoMean6.719371.32213
Median511261128

HALo adds 1.2 LLM calls (+22%), 205 tokens (+12%) and 16 s (+8%) per sample on average, and the medians differ by one call and 16 s. With the same backbone and image model, this difference comes only from the self-check and repair loops. For both methods the mean exceeds the median, so a minority of difficult cases accounts for much of the cost.

This overhead is not a fixed cost of the workflow; it is incurred on demand:

  • The draft layer builds material only for entries that need support; other entries go directly to rendering.
  • Render retries occur only when the initial review fails, and 62.97–95.24% of cases pass it (Table 4).
  • Draft returns are rarer still (Table 4).

In exchange, HALo outperforms GenClaw on all four benchmarks (Q2).

Q2. Novelty and difference from GenClaw.

HALo's contribution is not a multi-level structure as such, but how the task is decomposed: by the source of failure rather than by production stage. Agentic generation fails in two ways (Fig. 1): requirements are omitted or derived conclusions are lost before rendering, and fixing one failed requirement by rewriting the whole prompt disturbs requirements that already hold. HALo therefore separates three questions that decide whether a constraint is met: is it correctly specified (layout), does it have checkable support (draft), and does the image follow both (render). The plan is checked once and then kept fixed; a render failure is repaired in the render layer or, when its support is insufficient, in the draft layer, so repair touches only the failed entries.

GenClaw, on which HALo is built, organizes generation by stage, from conceptualization to a code canvas to rendering. The main difference is therefore the organization rather than the backbone: in HALo, the entry-level target is the unit of verification and repair, and code-rendered sketches are one type of supporting material, alongside retrieved facts and references, each attached to a specific entry.

The results support this decomposition:

  • HALo uses the default reasoning model of the released GenClaw codebase (GPT-5.5) and the same image model, and outperforms GenClaw on all four benchmarks: 93.7 vs. 89.3 on WISE, 89.6 vs. 87.9 on GenEval++, 0.60 vs. 0.57 on Mind-Bench and 54.7 vs. 46.7 Acc on RISEBench. We run GenClaw under this setting on WISE and RISEBench; on GenEval++ and Mind-Bench, its results are those reported in its paper.
  • The remaining differences follow the decomposition. GenClaw stays ahead on structural counting (GenEval++ P/Cnt 92.5 vs. 87.5), where its code canvas helps, while HALo gains most on derived conclusions (WISE Time 99.2 vs. 82.5) and preservation in editing (RISEBench appearance consistency 93.8 vs. 88.1, Acc 54.7 vs. 46.7).

Q3. Design of the two loops.

Inner loops. The layout layer reasons over the query and retrieves facts when needed; its plan is revised, within a bounded budget, until it passes a structural check against the schema and a semantic check for consistency and query coverage. The draft layer builds a code-rendered sketch or retrieves a reference for each entry that requires support, and rebuilds any item that fails its own check. The render layer checks the image entry by entry, records a correction for each failed entry, and retries once.

Inter-layer loop. Each layer passes its output upward only after its own checks pass, and later layers treat the plan as read-only. After the render retry, the reviewer diagnoses the cause of each remaining failure, and only failures attributed to insufficient support are returned to the draft layer. The draft layer rebuilds the material for those entries and keeps the rest; the image is then re-rendered, and every entry is re-checked, so a previously satisfied entry that regresses re-enters the failure set.

The module is non-trivial in two respects: the diagnosis that separates rendering noncompliance from insufficient support, and the fixed entry-level target that keeps repair and re-checking local. The routing is selective in practice: draft returns occur in 0–8.93% of initially failed cases, and 71.79–91.30% of initially failed cases pass after repair (Table 4). We will add pseudocode and the full routing rules to the appendix, and release the prompts and code.

We hope these clarifications address the reviewer's concerns and would appreciate it if the reviewer would reconsider the score.

Overall, the response addresses the cost and design-detail concerns. I am satisfied with the clarifications and look forward to the promised additions in the final version.

I appreciate the explanation of how the task is decomposed by the source of failure, which provides a reasonable motivation for the proposed organization. That said, the ideas of hierarchical and multi-level organization are not new, and it is unsurprising to see performance improvements from this classic design pattern.

AuthorsOpenReview ↗

Follow-up to Reviewer SGL2: Motivation and Design of Failure-Source Decomposition

Thank you very much for the thoughtful follow-up. We are glad the cost and design concerns are resolved and that decomposing by failure source is seen as a reasonable motivation. All promised additions will be included in the final version.

We would also note that HALo achieves the best overall results on all four benchmarks, with the largest gains where the division acts. Compared with GenClaw under the same models, recording physical laws and time-zone reasoning as explicit derived entries lifts WISE Physics (84.2 → 91.7) and Time (82.5 → 99.2), and explicit preserve entries raise RISEBench appearance consistency (88.1 → 93.8) and strict accuracy (46.7 → 54.7).

We agree that hierarchical organization is a general pattern and do not claim it as our contribution. What we hope to highlight is the problem it solves in this task. Constraint- and knowledge-heavy image generation fails for three different reasons, which a single loop rewriting one prompt cannot tell apart:

Problem in the taskWhy a single loop struggles
The target is underspecified: it depends on implicit knowledge or reasoningThe conclusion lives only in the prompt and can be lost or overwritten before rendering
Text cannot enforce exact counts, orderings or visual identitiesRewording does not supply the missing structure or reference
Fixing one constraint can break othersA global rewrite resamples every constraint, so repair is never local

The value of dividing generation here is that each failure becomes attributable to its cause and repairable where it arises. Our contribution is how the division is made:

  • By failure source, not production stage. The layout layer asks whether each constraint is correctly specified, the draft layer whether it has checkable support, and the render layer whether the image follows both.
  • A shared, entry-level target. Requirements become typed entries with provenance. A derived entry keeps its basis and the reading it rules out, so a counterintuitive conclusion is protected rather than "corrected". Once checked, the target is fixed and serves as the unit of verification and repair in every layer.
  • Support bound to entries. Sketches and references attach to the entries they support instead of being appended to the prompt.
  • Repair routed by cause. A failure is retried in the render layer, or returned to the draft layer when its support is insufficient; every entry is then re-checked against the same target.

We believe this principle, dividing generation where its failures arise, is a transferable insight for future agentic systems. Thank you again for your time and constructive feedback. We hope this clarification is helpful, and we would be truly grateful for your support of our work.

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

HALo proposes a hierarchical agentic framework for image generation that addresses two limitations of existing flat agentic pipelines: incomplete constraint specification and global prompt rewriting that may violate previously satisfied requirements. It consists of three layers: Layout constructs and validates a structured plan of scene, objects, attributes, and relations; Draft selectively prepares supporting materials, including code-rendered sketches and retrieved factual or visual references; and Render generates images and verifies constraint satisfaction using a vision-language model. Inner loops enable layer-specific refinement, while an inter-layer loop routes unresolved failures back to Draft for targeted repair, keeping the validated plan and satisfied constraints fixed. The authors evaluate HALo on WISE, GenEval++, Mind-Bench, and RISEBench, reporting the best overall performance among the compared methods. An ablation on 100 WISE cases shows improvements from 86 to 93 with the inner loop and to 97 with both inner and inter-layer loops.

Critical strengths
  1. Constraint-level decomposition and localized repair. HALo provides a coherent framework that separates target specification, supporting-material construction, and image rendering. By associating feedback with individual constraints and preserving satisfied requirements during repair, it addresses a concrete limitation of existing agentic image-generation pipelines. This is a meaningful systems-level contribution to improving constraint adherence.

  2. Evaluation across diverse generation tasks. The paper evaluates HALo on four benchmarks covering world knowledge, compositional generation, knowledge-intensive generation, and image editing. The reported results show consistent overall advantages over competitive agentic baselines, while the ablation study provides preliminary evidence for the complementary benefits of inner-layer refinement and inter-layer repair. This breadth lends support to the practical relevance of the proposed framework.

Critical weaknesses
  1. Irrecoverable planning errors. HALo freezes the target plan after layout validation, assuming that the plan adequately captures the user's intent. However, Appendix F.7 presents a concrete counterexample: an orange fruit is represented as a generic “red-orange object,” allowing the system to generate an image that satisfies the recorded color and presence constraints but violates the intended object identity. Since the plan cannot be reopened during the current run, downstream refinement cannot reliably correct such semantic omissions. This exposes a fundamental limitation of the proposed repair mechanism, whose effectiveness depends on the completeness and accuracy of the initial plan.

  2. Insufficient validation of the claimed regression-prevention mechanism. HALo retains supporting materials for previously satisfied constraints, but the image is regenerated after the materials for failed constraints are revised. Consequently, preserving symbolic constraints and their associated materials does not guarantee that those constraints remain satisfied in the regenerated image. Although Table 4 reports recovery rates for initially failed cases, the paper does not quantify how often previously satisfied constraints regress after repair. This leaves a central claim of localized repair insufficiently validated at the image level.

  3. Lack of human validation for model-based evaluation. The main results rely on automated evaluators across all four benchmarks, but the paper does not report human–evaluator agreement or a manually audited subset to establish the reliability of these judgments. This is particularly relevant because HALo's internal reviewer can accept semantically incorrect outputs when its checks fail to capture object identity, as illustrated in Appendix F.7. Without human validation, it remains unclear whether the reported improvements consistently reflect genuine instruction satisfaction rather than limitations or biases of automated evaluation.

Questions for authors
  1. Recovery from planning errors. In Appendix F.7, the intended orange fruit is underspecified in the frozen plan. How can HALo recover from such plan-level semantic errors within a run? Can the authors report the frequency of these errors and clarify whether the layout layer can be selectively reopened when downstream evidence indicates that the target plan is incorrect?

  2. Regression after localized repair. Can the authors report constraint-level transition statistics across rendering and repair iterations, including the rate at which previously satisfied constraints become unsatisfied? A comparison against global-prompt rewriting under matched image-generation models and generation-call budgets would help isolate whether HALo's localized repair actually reduces regression.

  3. Reliability of automated evaluation. Have the authors conducted a human evaluation or manually audited a subset of generated images to measure agreement with the automated evaluators? In particular, how reliably do the internal reviewer and benchmark evaluators identify semantic errors involving object identity, attribute binding, and spatial relations? Reporting human–evaluator agreement and representative disagreement cases would strengthen confidence in the reported gains.

  4. Component-level ablation. The ablation study compares a single-pass hierarchy, an inner-loop-only variant, and the full HALo framework, but does not isolate the effect of the inter-layer loop alone or the individual contributions of key components, such as structured constraint representation, code-rendered sketches, retrieved references, and entry-level visual review. Can the authors provide additional component-level ablations under controlled settings to clarify which design choices account for the reported improvements?

  5. Choice and Generalizability of Routing Heuristics. HALo uses hand-designed routing rules to determine when to invoke code-rendered drafts, including a hard threshold of four explicitly requested objects and unconditional routing for explicit ordering relations. Although these rules are stated to depend on constraint types rather than benchmarks, the paper does not establish whether the chosen criteria and thresholds generalize beyond the evaluated task distributions or how they were selected. Can the authors clarify how these rules were determined and whether they were fixed independently of benchmark evaluation? Evaluating alternative thresholds and routing policies on held-out or out-of-distribution tasks would help establish the generality of the proposed framework.

4 comments
AuthorsOpenReview ↗

Response to Reviewer 4Mc6: Plan Errors, Regression, Evaluation Reliability, Ablations and Routing

Q1. Recovery from planning errors (Appendix F.7).

The layout layer works in the cleanest context of the system: it sees only the query, performs only planning, and its plan passes structural and semantic checks before it is frozen. The frozen plan therefore represents the model's best reading of the query. Later layers cannot tell whether this reading is correct, because they receive no new information about intent: a render failure shows that the image misses an entry, not that the entry is wrong. F.7 is such a case: the plan described the fruit by its color, and every later check verified the entries as recorded. The draft layer differs: its sketches and references can be insufficient, which the rendered image exposes when an entry fails despite its material. Unresolved failures are therefore returned to the draft layer rather than the layout layer.

The only case in which revising the plan could help is a constraint that is too hard to realize. Across the four benchmarks, draft returns occur in 18 cases (5 / 0 / 4 / 9 on WISE / GenEval++ / Mind-Bench / RISEBench; Table 4), and 12 still fail afterwards. For these 12, the layout layer revises the failed entries by the diagnosed cause before re-rendering. Most still fail the internal check. The few that pass it are rejected by the benchmark evaluator: they satisfy the revised entries, which no longer match the original query. No case is recovered. This is the failure mode that a fixed plan prevents: relaxing the target until the image passes.

Q2. Regression after localized repair.

Retained material indeed does not guarantee that a satisfied entry stays satisfied in the regenerated image, so HALo does not assume it: after every re-rendering, the render layer re-checks all entries of the plan, and a regressed entry re-enters the failure set. We will revise the wording accordingly: satisfied constraints are kept as fixed targets and re-verified.

In Table 4, a case counts as recovered only if every entry passes the final review, including the entries that were satisfied before repair, and 71.79–91.30% of initially failed cases meet this condition.

Q3. Reliability of automated evaluation.

All reported scores come from each benchmark's official evaluator; HALo never sees these evaluators, and its internal reviewer only guides repair. F.7 shows this: the internal reviewer accepts the image against the recorded plan, while the benchmark evaluator rejects the wrong object identity. The reliability of these evaluators is validated in the benchmark papers:

  • RISEBench (Zhao et al., NeurIPS 2025) shows that its GPT-4.1 judge agrees with human experts: human means are 4.7–4.8 on outputs it scores 5 and 1.1 on those it scores 1 for reasoning (MAE ≤ 0.3).
  • WISE (Niu et al., ICML 2026) validates its judging protocol with five annotators per image, finding higher human agreement than other automated metrics; we use its maintained WISE_Verified release.
  • Mind-Bench (He et al., 2026) and GenEval++ (Ye et al., 2025) use binary checks of explicit checklist items and count an image as correct only if every item holds.

Q4. Component-level ablation.

Each variant changes one component of the full model; every benchmark uses 100 randomly sampled cases (scores in %):

VariantWISEGenEval++Mind-BenchRISEBench
Full HALo97876054
Single pass (no loops)86834947
Inner loops only93865853
Inter-layer loop only88835048
Free-form plan79845746
No code-rendered sketches95785553
No retrieved references97873954

Entry-level review drives the inner loops, so the loop variants measure its effect.

Each component matters most where its constraint type dominates: the structured plan on WISE (97 → 79) and RISEBench (54 → 46), sketches on GenEval++ (87 → 78), and retrieval on Mind-Bench (60 → 39), while removing retrieval leaves the other benchmarks unchanged. The two loops add 4–11 points over a single pass; the inter-layer loop changes less, as draft returns are rare.

Q5. Routing heuristics.

The routing rules are a design choice within the draft layer, not our contribution. They follow constraint characteristics: image models often miscount four or more objects and violate textual ordering, so such entries receive a sketch. The rules read only the entry types in the plan and are identical across benchmarks.

Our contribution is the decoupling that makes this choice local: since the plan already types each constraint, support is decided per entry, the policy can be replaced without touching other layers, and a routing miss is not final, because an unsupported entry fails the render check and can return to the draft layer.

We hope these clarifications address the reviewer's concerns and would appreciate it if the reviewer would reconsider the score.

Thank you once more for your time and thoughtful review. With the discussion period nearing its end, we would like to check whether our response has resolved your concerns. If anything is still unclear, we would be glad to elaborate.

Best regards, The Authors

Thank you for the detailed response and additional experiments. I appreciate the authors' efforts, particularly the expanded component-level ablations across all four benchmarks, which strengthen the empirical evaluation. The clarifications regarding the internal review process and benchmark evaluators are also helpful.

However, my main concerns remain only partially addressed. For Q1, the response explains the rationale for freezing the plan but does not resolve or quantify the problem of plan-level semantic errors. For Q2, while re-checking all constraints after regeneration is reasonable, the reported recovery rates do not directly measure constraint regression or demonstrate that localized repair reduces regression compared with global rewriting. This remains an important gap given the paper's central motivation.

Overall, I acknowledge the improvements provided by the rebuttal and recognize the practical value of the proposed framework. Nevertheless, I will maintain my original rating, as the evidence supporting the core repair mechanism remains insufficient.

AuthorsOpenReview ↗

Follow-up to Reviewer 4Mc6: Layer-Wise Error Analysis and Constraint Regression

Thank you for the careful follow-up. We are glad the ablations and evaluation clarifications are helpful, and we address the two remaining points with direct measurements.

Q1. Plan-level semantic errors: evaluating the layout layer directly.

We thank the reviewer for this valuable suggestion. HALo's division makes plan-level errors directly measurable: the plan is explicit and frozen before drafting and rendering, so every image is produced against one fixed reading of the query, and the plan can be evaluated on its own, separately from rendering. In a single loop, this reading is embedded in a prompt rewritten every round, so the two error sources are hard to separate.

Every benchmark provides a reference for the intended content. GPT-4.1 compares each frozen plan with it (text only), and crossing the result with the official evaluator's verdict on the final image attributes each failure to a layer:

Benchmark (cases)ReferenceRejectedIncorrect planRendering error
WISE (1,000)Intended content6349 (78%)14 (22%)
GenEval++ (280)Object counts and attributes291 (3%)28 (97%)
Mind-Bench (497)Key knowledge, checklist208158 (76%)50 (24%)
RISEBench (309)Expected edit result13870 (51%)68 (49%)

A plan counts as incorrect if it contradicts the reference or omits a detail the reference requires; RISEBench uses the cases with a text reference. On 50 randomly sampled plans the judge accepted, a human check agrees in 82% of cases. The benchmarks fail for different reasons:

  • WISE: incorrect plans are the main source, costing 4.9 of the 6.3 points lost. These are knowledge-inference errors, e.g., a generic bird instead of the Gallic rooster for "French heritage", or a mirror reflection that is not left-right reversed.
  • GenEval++: plans are almost never wrong; failures come from rendering the specified counts, positions and attributes.
  • Mind-Bench: plan errors arise where the query depends on external facts; half of the weather queries (25 of 50) fail because the plan records a wrong condition or temperature for the given city and date.
  • RISEBench: both sources contribute about equally; plan errors are wrong reasoning outcomes, e.g., 14 instead of 16 in a number puzzle, or a ginkgo that keeps its leaves after autumn.

This attribution shows where to optimize: plan-level errors on WISE, Mind-Bench and RISEBench point to knowledge grounding and reasoning in the layout layer, while GenEval++ failures point to the draft and render layers. Because the layers are decoupled, each improvement can be made in its own layer, and a layout-layer change can be validated by plan-level evaluation alone.

Q2. Regression after localized repair.

We agree that recovery rates show only the end result. Regression has two sources: the target sent to the image model becomes wrong, or the image model renders a correct target badly. Both strategies render with the same image model, so rendering errors are common to both, and the target is where the two strategies differ by design. This is exactly what decoupling controls.

We test this on the 306 repaired cases with a text reference, starting from each first rejected review. HALo keeps its frozen plan. Global rewriting lets the reasoning model re-plan from the review feedback, including new retrieval, and sends the new target to the same image model, as a single-loop agent does. Both are checked against the benchmark reference as in Q1:

Repair strategyAccuracy before repairAccuracy after repair
Global rewriting (re-planning)69.6%63.1%
Localized repair (HALo)69.6%69.6%

Re-planning lowers target accuracy from 69.6% to 63.1%, while HALo's stays unchanged by construction: its plan is frozen after checking, and repair changes only the material and the image. Review feedback reports what the image misses and carries no new information about intent. Where accuracy drops, re-planning goes beyond the reported problem: it "corrects" parts of the first plan that were right, or relaxes constraints to fit the failed image, so the new target no longer meets the reference.

The end results agree: the inner loops add 3–9 points over a single pass, and under the same models HALo exceeds GenClaw in RISEBench appearance consistency (93.8 vs. 88.1).

We will add both analyses to the final version. Thank you again for the constructive discussion. We hope these measurements address the remaining concerns, and we would be truly grateful for your support.

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

This paper proposes HALo, a hierarchical agentic framework for image generation consisting of three layers: layout, draft, and render. The framework introduces inner-layer self-correction and inter-layer feedback to preserve planning constraints and enable targeted repair of generation failures. Experiments on four benchmarks demonstrate competitive performance against existing image generation models and agentic approaches.

Critical strengths
  1. The paper addresses meaningful challenges in complex image generation, particularly constraint preservation and error correction during iterative generation. The hierarchical framework is clearly motivated and reasonably designed.

  2. The experiments cover four diverse benchmarks, and the results demonstrate consistent overall improvements over existing methods, particularly on knowledge-intensive generation and image editing tasks.

Critical weaknesses

W1. Insufficient experimental validation of the core mechanisms.

The ablation study is conducted on only 100 WISE samples, which is relatively limited given the four benchmarks used in the main experiments. Moreover, the contribution of the inter-layer loop remains unclear. Table 4 shows that only 0–8.93% of initially failed cases request draft-layer revision, suggesting that most failures are handled by render-level retries. Although the ablation reports an improvement from 93 to 97 after enabling the inter-layer loop, it remains unclear how much of this gain is directly attributable to targeted material revision rather than additional rendering attempts. More comprehensive ablations and comparisons under matched generation budgets are needed to establish the effectiveness of the proposed mechanisms. Furthermore, all experiments use the same image generation backbone (Gemini-3.1-Flash-Image), without evaluating whether the proposed framework generalizes to other image generators.

W2. Limited novelty over GenClaw and insufficient justification of the frozen-plan design.

GenClaw already introduces a multi-stage image generation framework with code-based structural guidance. Although HALo further introduces a frozen structured plan, entry-level material binding, and hierarchical feedback, their distinct contributions over existing approaches are not sufficiently demonstrated. Furthermore, freezing the plan may prevent the correction of errors introduced during the layout stage. As illustrated by the failure case in Supplementary Figure 7, an incorrect semantic interpretation can pass validation and remain fixed throughout subsequent generation. The authors should provide stronger evidence for the advantages of these design choices and further investigate the robustness of the frozen-plan mechanism.

Questions for authors
  1. Could the authors extend the ablation study to additional benchmarks and provide results across multiple runs to demonstrate the stability and generalizability of the improvements?
  2. Given the low frequency of draft-layer returns, could the authors quantify the actual contribution of inter-layer repair and provide representative successful trajectories? How does targeted material revision compare with additional render-level retries under the same generation budget?
  3. What are the key methodological advantages of HALo over GenClaw? Could the authors provide targeted comparisons or component-level ablations to isolate the contributions of the frozen plan and entry-level material binding?
  4. How does HALo handle incorrect or incomplete plans that pass layout validation? Since the plan remains frozen during subsequent generation, can the framework recover from such errors, and how frequently do they occur in practice?
  5. All experiments use Gemini-3.1-Flash-Image as the image generation backbone. Could the authors evaluate HALo with other image generation models, such as GPT-Image or Qwen-Image, to demonstrate the generalizability and robustness of the proposed framework across different backbones?
4 comments
AuthorsOpenReview ↗

Response to Reviewer adz8: Ablations, Inter-Layer Repair, GenClaw, Frozen Plan and Image Models

We thank the reviewer for the careful review.

Q1. Ablation on all four benchmarks.

We extend the ablation to all four benchmarks, each on 100 randomly sampled cases (scores in %):

VariantWISEGenEval++Mind-BenchRISEBench
Full HALo97876054
Single pass (no loops)86834947
Inner loops only93865853
Inter-layer loop only88835048
Free-form plan79845746
No code-rendered sketches95785553
No retrieved references97873954

Each component matters most where its constraint type dominates: the structured plan on WISE (97 → 79) and RISEBench (54 → 46), sketches on GenEval++ (87 → 78), and retrieval on Mind-Bench (60 → 39), while removing retrieval leaves the other benchmarks unchanged. The two loops add 4–11 points over a single pass. The main differences (8–21 points) are well beyond the sampling error of a 100-case subset (±2–5 points), and the full model on each subset is consistent with its full-benchmark score.

Q2. Contribution of the inter-layer loop.

Draft returns are rare by design: they are reserved for failures that a render retry does not resolve, so their effect is clearest on the cases that trigger them. Across the four benchmarks, 18 cases request a draft return (5 / 0 / 4 / 9 on WISE / GenEval++ / Mind-Bench / RISEBench; Table 4), and 6 of them pass after it. On these cases, a render retry with the existing material had already failed, and one generation with revised material succeeded. Figure 3 shows one such trajectory: the first image and the render retry both fail the eight-leg constraint, and a structural sketch from the draft layer fixes it. We will add more successful trajectories to the appendix.

Q3. Advantages over GenClaw.

HALo's contribution is not a multi-stage structure as such, but how the task is decomposed: by the source of failure rather than by production stage. GenClaw organizes generation from conceptualization to a code canvas to rendering. HALo separates whether a constraint is correctly specified (layout), whether it has checkable support (draft) and whether the image follows both (render). The entry-level target is the unit of verification and repair, and code-rendered sketches are one type of supporting material, alongside retrieved facts and references, each attached to an entry.

HALo uses the default reasoning and image models of the released GenClaw codebase and outperforms GenClaw on all four benchmarks: 93.7 vs. 89.3 on WISE, 89.6 vs. 87.9 on GenEval++, 0.60 vs. 0.57 on Mind-Bench and 54.7 vs. 46.7 Acc on RISEBench. Replacing the structured plan with a free-form plan costs 18 points on WISE and 8 on RISEBench (Q1). Q4 isolates the frozen plan.

Q4. Incorrect plans that pass validation.

The layout layer works in the cleanest context: it sees only the query, performs only planning, and its plan is checked before it is frozen. Later layers receive no new information about intent, so a render failure shows that the image misses an entry, not that the entry is wrong; F.7 is such a case. Draft errors are different, because the rendered image exposes insufficient material. Unresolved failures therefore return to the draft layer.

Revising the plan could help only if a constraint is too hard to realize. Of the 18 draft returns, 12 still fail; for these, the layout layer revises the failed entries by the diagnosed cause before re-rendering. Most still fail the internal check, and the few that pass are rejected by the benchmark evaluator because the revised entries no longer match the query. No case is recovered. Errors such as F.7 must therefore be caught before freezing. Their frequency is bounded: on WISE, 57 of 1,000 cases (5.7%) pass the internal review but are rejected by the benchmark evaluator. Errors of the F.7 type can only fall in this set, which also contains reviewer misses, so 5.7% is an upper bound on their frequency.

Q5. Other image generators.

The render layer accesses the image model only through the plan and the material, so it can be replaced without changing other layers. With GPT-Image-2.5-Sunburst, direct generation scores 81.7 on WISE, 4.9 points below Gemini-3.1-Flash-Image, with the largest drops on Time, Biology and Chemistry; a different image model alone does not resolve knowledge-dependent queries. With this image model, HALo obtains 94.3, 12.6 points above direct generation and on par with HALo using Gemini-3.1-Flash-Image (93.7).

We hope these clarifications address the reviewer's concerns and would appreciate it if the reviewer would reconsider the score.

Thank you once more for your time and thoughtful review. With the discussion period nearing its end, we would like to check whether our response has resolved your concerns. If anything is still unclear, we would be glad to elaborate.

Best regards, The Authors

I appreciate the authors’ detailed rebuttal and the additional experiments, which address some of my concerns, particularly regarding ablations and backbone generalization. However, I remain concerned about the limited independent contribution of the inter-layer loop and the methodological novelty over GenClaw. Therefore, I will maintain my original rating of Weak Reject.

AuthorsOpenReview ↗

Follow-up to Reviewer adz8: Novelty over GenClaw and the Role of the Inter-Layer Loop

Thank you for the follow-up. We are glad the ablations and the backbone experiment address part of the concerns, and we will include all promised additions in the final version.

Effectiveness. HALo achieves the best overall results on all four benchmarks, with the largest gains where the division acts:

Metric (same models)GenClawHALoMechanism
WISE Physics84.291.7Physical laws recorded as derived entries
WISE Time82.599.2Time-zone reasoning recorded as derived entries
RISEBench appearance consistency88.193.8Explicit preserve entries
RISEBench strict accuracy46.754.7Explicit preserve entries

With GPT-Image-2.5-Sunburst, HALo reaches 94.3 on WISE, 12.6 points above direct generation.

Q1. Novelty over GenClaw.

GenClaw orders its stages by production (conceptualization, code canvas, rendering). HALo divides generation by the source of failure, and each layer contributes a mechanism for one source:

Source of failureLayerWhat the layer contributes
Underspecified target (implicit knowledge or reasoning)LayoutTyped entries with provenance; derived entries keep their basis; plan fixed after checking
Text cannot enforce counts, orderings or identitiesDraftSketches and references bound to the entries they support
Fixing one constraint breaks othersRenderEntry-level review; repair targets only failed entries; all entries re-checked

The ablation supports this mapping: structured plan on WISE (97 → 79), sketches on GenEval++ (87 → 78), retrieval on Mind-Bench (60 → 39).

Q2. Role of the inter-layer loop.

The loop has two roles, each placed where an error can be detected:

  • Fixed propagation (upward) avoids new target errors. The checked plan and material reach rendering unchanged, so every repair works against the same target.
  • On-demand return (downward) repairs what rendering exposes. Only failures that persist after a render retry and lack support go down, so extra cost is spent only where needed.
  • The return stops at the draft layer by design. Rendering can expose insufficient support (in Figure 3, a failed eight-leg constraint leads to a structural sketch), but not a wrong plan: a failure shows that the image misses an entry, not that the entry is wrong.

Measured effect (our follow-up to Reviewer 4Mc6): on 306 repaired cases, re-planning from feedback lowers target accuracy from 69.6% to 63.1%, while the fixed target keeps it at 69.6%.

Contribution. Dividing generation where its failures arise makes each failure attributable to its cause and repairable in its own layer. Because the plan is explicit and fixed, the system is also diagnosable: the plan can be evaluated on its own and each failure traced to its layer, so each layer can be improved without changing the others.

Thank you again for your time and constructive feedback. We hope this clarification is helpful, and we would be truly grateful for your support of our work.

Comments on the paper

2 comments
Area_Chair_LsyaOpenReview ↗

Please reply to authors' rebuttal if you haven't done so

Dear Reviewers,

As the author–reviewer discussion deadline approaches, I would like to remind you to review the authors’ rebuttal and indicate whether your concerns have been adequately addressed. If you have any remaining concerns or questions, please share them as soon as possible to leave enough time for discussion.

Thank you again for your time and effort. AC

AuthorsOpenReview ↗

Summary of Contributions, Key Findings and Discussion

Dear AC and Reviewers,

We thank all reviewers for their constructive feedback. The reviewers found the design well motivated (SGL2: "well-founded"; adz8: "clearly motivated and reasonably designed"; 4Mc6: "a meaningful systems-level contribution") and noted the strong results across four benchmarks (SGL2: "impressive empirical results"). We summarize the contribution and main findings, the concerns addressed during the discussion, and our explanation of those that remain.

Core contribution. HALo divides agentic image generation by where failures arise, not by production stage:

  • Layout checks that each constraint is correctly specified: requirements become typed entries with provenance, and the checked plan is then fixed.
  • Draft gives constraints that text cannot enforce (counts, orderings, identities) checkable support, bound to their entries.
  • Render checks the image entry by entry, and repair targets only failed entries; failures that lack support return to the draft layer.

Key findings.

  1. Gains are largest where the division acts. HALo achieves the best overall results on all four benchmarks. Under the same models as GenClaw, WISE Time rises from 82.5 to 99.2 and Physics from 84.2 to 91.7, and RISEBench appearance consistency from 88.1 to 93.8.
  2. A checked target should stay fixed during repair. On 306 repaired cases, re-planning from review feedback lowers target accuracy from 69.6% to 63.1%; keeping the plan fixed avoids this loss.
  3. The division makes failures diagnosable. Evaluating the frozen plans directly attributes 78% of WISE and 76% of Mind-Bench failures to the plan, but 97% of GenEval++ failures to rendering, so each benchmark points to a different layer to improve.

Concerns addressed during the discussion.

  • Cost and loop design (SGL2): HALo adds 1.2 LLM calls and 16 s per sample over GenClaw, and the loop design is clarified.
  • Ablations (adz8, 4Mc6): the component-level ablation now covers all four benchmarks.
  • Other image models (adz8): with GPT-Image-2.5-Sunburst, HALo reaches 94.3 on WISE, 12.6 points above direct generation.
  • Evaluator reliability (4Mc6): WISE and RISEBench validate their evaluators against human judgments, and Mind-Bench and GenEval++ use binary checklists.

Remaining concerns and our explanation.

  1. Novelty of the hierarchy (SGL2, adz8). We agree that hierarchical organization is a general pattern and do not claim it. The contribution is how generation is divided: by the source of failure rather than by production stage as in GenClaw, with a checked entry-level target as the unit of verification and repair. The gains follow this division (Finding 1), and in the ablation each component matters most where its constraint type dominates.
  2. Independent contribution of the inter-layer loop (adz8). The loop decides where repair happens. Upward, it passes the checked plan unchanged, so repair cannot lower target accuracy (Finding 2). Downward, it returns a failure to the draft layer only when rendering shows that support is insufficient, and it stops there because rendering can expose missing support but not a wrong plan.
  3. Plan-level errors and regression (4Mc6). Because the plan is explicit and frozen, plan errors can be measured on their own (Finding 3) and improved in the layout layer, where a change can be validated by plan-level evaluation alone. For regression, repair strategies share the same image model and differ in the target: re-planning lowers target accuracy, while the fixed plan keeps it (Finding 2).

We will include all additions in the final version. Thank you again for your time and the constructive discussion.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.