acceptodds
Under review as a conference paper at ICLR 2027

DailyBrick: Language-Guided Synthesis of Brick Assembly Instructions

Abstract

Generating a LEGO model from a user request is more than a plausible 3D shape generation. LEGO models require physical support per brick, and each brick should be placed unblocked. Current methods address this issue by training an expert large language model. We reduce the problem of generating extremely long context on all brick connections to that of writing a program that builds LEGO models like a human, considering each intermediate step could be executed. We introduce DailyBrick, a multi-stage agentic system that produces a LEGO model together with a brick-by-brick assembly instruction for human building and robot assembly. We design a multi-stage harness with roles to help LLMs generate more effectively. A versioned construction SDK compiles multi-level decisions, from semantic subparts to individual bricks, into canonical operations. An external Meta-Reviewer agent replays and inspects the generated package, verifies the model and its construction process, identifies failures, traces them to the responsible stage, and routes them to bounded repairs or to editable candidates for later skill or tool updates. Extensive experiments demonstrate that DailyBrick generates LEGO models based on simple user requests better than recent agentic systems, and show its utility in downstream applications such as robot manipulations on model assembly from instructions and brick sets (https://anonymousauthors680.github.io/DailyBrick/).

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
Agentic 3D Modeling, Assembly Instruction, LEGO models

Reviews

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

This paper focuses on LEGO model generation, aiming to generate LEGO models and corresponding step-by-step assembly instructions from natural language requests. The proposed DailyBrick organizes the LEGO generation task into structured stages with intermediate outputs and feedback. It utilizes a Planner–Designer–Critic workflow to enable iterative refinement of the generated results. The experimental results demonstrate the effectiveness of DailyBrick.

Critical strengths
  1. The task of generating LEGO models and corresponding step-by-step assembly instructions from natural language requests is interesting.
  2. The design of the Planner–Designer–Critic workflow is reasonable.
  3. The experimental results demonstrate the effectiveness of the proposed DailyBrick.
Critical weaknesses
  1. As mentioned in Lines 97–106, decomposing long-context generation into structured stages and performing iterative refinement is a common practice in agent workflows. I am curious about whether DailyBrick introduces any task-specific designs for LEGO generation.
  2. In Table 4, adding the Meta-Reviewer improves performance. However, I wonder whether this improvement stems from the design of the Meta-Reviewer or simply from having an additional round of corrective refinement. I suggest adding a comparison between the Meta-Reviewer and a baseline with one additional round of correction and retry. Such a comparison would provide stronger evidence for the effectiveness of the Meta-Reviewer.
Questions for authors

What task-specific designs does DailyBrick introduce for LEGO generation?

3 comments
AuthorsOpenReview ↗

offical Response to Reviewer hVcZ

General Comment

Thank you for your thoughtful review. We appreciate your recognition of the importance of jointly generating LEGO models and assembly instructions, and your positive assessment of the PDC workflow. Your comments help us clarify how the design is tailored to LEGO construction and how the Meta-Reviewer should be evaluated against an additional correction opportunity.


Weakness 1: Task-specific designs beyond common agent workflows

Reviewer Comment:

As mentioned in Lines 97–106, decomposing long-context generation into structured stages and performing iterative refinement is a common practice in agent workflows. I am curious about whether DailyBrick introduces any task-specific designs for LEGO generation.

Response:

Thank you for raising this point. While DailyBrick builds on these general principles, its design emphasis is on adapting them to the specific requirements of LEGO construction, through task-specific intermediate representations, executable brick operations, and verification and repair mechanisms for jointly generating brick models and their assembly instructions. The distinction therefore lies not in staging or refinement alone, but in how these mechanisms address the constraints of the LEGO task, as detailed below.

1. A language description specifies an object, but not its brick-level support and connection structure. For example, asking for a house does not specify how its walls support the roof or how the subassemblies attach. These choices are coupled: visually plausible subparts do not necessarily form a compatible brick assembly. This motivates separating semantic design from structural planning before generating placements. Our structural blueprint explicitly represents support layout and brick connections, while partial assembly skills give subparts defined interfaces and preconditions rather than treating them as independent shapes (Secs. 3.1-3.2).

2. Visual proximity is not sufficient for a legal LEGO connection. Two parts can appear to touch while their connectors are incompatible or incorrectly oriented. Part identity, pose, connection choice, and placement dependencies therefore cannot be left as an informal geometric description. This motivates the brick-level SDK, whose operations explicitly specify brick ID, pose, connector, support dependency, and insertion direction. The purpose is to expose the construction decisions needed for executable placements, rather than simply providing a generic code-generation tool (Sec. 3.2).

3. A final arrangement does not determine a valid construction order or a faithful instruction sequence. A proposed placement may depend on a supporting part or attachment site that has not yet been introduced. Checking only the completed model cannot establish whether that step was valid when it occurred. This motivates replay over successive partial assemblies and their available attachment sites. Moreover, independently written instructions could describe a different order or placement from the generated model. We therefore derive both the model and instruction views from the same compiled placement trace, coupling instruction generation to the construction process being checked (Secs. 3 and 3.3).

4. The location of a rejected brick is not necessarily the location of the underlying error. An incompatible attachment may reflect an earlier blueprint decision, a subassembly interface, or its expansion into SDK operations, rather than only the latest placement. This motivates retaining dependencies across these levels and using the violated construction constraint to identify candidate revision targets. The Self Meta-Reviewer can therefore direct revision toward the relevant construction decision instead of treating every failure as a request to regenerate the last output. A revised program must still undergo complete replay (Sec. 3.3).

Thus, the task-specific contribution is not the use of staged generation or iterative refinement in isolation, but their realization through brick-level construction representations, executable connection-aware operations, a shared model–instruction trace, and replay-grounded revision targets.

AuthorsOpenReview ↗

offical Response to Reviewer hVcZ

Weakness 2: Meta-Reviewer versus an additional correction round

Reviewer Comment:

In Table 4, adding the Meta-Reviewer improves performance. However, I wonder whether this improvement stems from the design of the Meta-Reviewer or simply from having an additional round of corrective refinement. I suggest adding a comparison between the Meta-Reviewer and a baseline with one additional round of correction and retry. Such a comparison would provide stronger evidence for the effectiveness of the Meta-Reviewer.

Response:

Thank you for this suggestion. We agree that the cumulative comparison in Table 4 does not rule out the possibility that part of the gain comes from an additional opportunity to revise. We compare an ordinary correction round with Meta-Reviewer-guided targeted repair, using the same configuration. With the same allowed correction opportunities and resource ceilings, Meta-Reviewer-guided repair achieves better performance on final acceptance, compared with providing another round of correction.

Table R1. Meta-Reviewer and additional correction-round ablation.

DailyBrickValid (%)Stable (%)CLIPDINOv2P_invVQAScorePESigLIP2Replay exact (%)All-prefix passFailure pos.AcceptTokens/case
w/ an additional round100.099.860.3390.8990.0490.7240.3600.72294.80.9450.9560.6948.167k
w/ Meta-Reviewer100.0100.00.3400.9060.0490.7360.3620.724100.01.0000.9600.8347.760k

Question: What task-specific designs does DailyBrick introduce?

Reviewer Comment:

What task-specific designs does DailyBrick introduce for LEGO generation?

Response:

Thank you. The task-specific design of DailyBrick concerns translating a language request into brick placements with explicit support and connection information, while producing instructions for the same construction sequence. Accordingly, the structural blueprint specifies support layout and brick connections before the design is expressed as an assembly program (Sec. 3.1). To make these construction decisions executable, SDK calls specify brick identity, colour, pose, connector, support dependency, and insertion direction. Partial assembly skills compose these calls into reusable subpart procedures with defined interfaces and preconditions (Sec. 3.2).

To keep the generated model and instructions aligned, both are derived from the same compiled placement trace (Sec. 3). Verification also follows the construction sequence: before each placement, verify replay reconstructs the accepted partial assembly and available attachment sites, then checks pose validity, connector compatibility, and subpart assembly connections. If a placement is rejected, the Self Meta-Reviewer uses the failed action, violated constraint, last accepted state, and recorded generation dependencies to select candidate revision targets; the revised program undergoes complete replay (Sec. 3.3). Thus, the adaptation to LEGO lies in the construction information represented, the operations exposed, and the constraints checked, rather than in stage decomposition or iterative refinement alone.

Thanks for the responses. They have addressed my concerns, and I will keep my positive score.

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

the authors present DailyBrick as an agentic framework that is generating 3D brick models and assembly instructions from text requests by treating the problem as program synthesis and sequential construction . They also develop a brick construction SDK allowing a meta-reviewer to locate errors and assist in targeted updates. The framework is tested across a dataset of >350k LEGO models and on Qwen3.6-27B model. Metrics show the framework outperforms baselines over single shot generation in visual quality, text alignment and assembly sequence validity.

Critical strengths
  1. the distinction between geometric validity and assembly feasibility is identified by looking at intermediate assembly states and construction constraints instead of just looking at final geometry

  2. the self meta-reviewer's ability to trace the rejected step to the associated program operation, stage output or SDK operation is a good design decision as it can provide a way to bypass asking the LLM to do so.

Critical weaknesses
  1. the baseline comparisons in table 2 mention that "..scores combine published results and additional measurements under their respective evaluation protocols..." this raises concerns about the comparability of results across the methods.

  2. the paper mentions a large dataset is generated. but i do not see any information about how it was collected, origin/quality of text descriptions, any filtering, any overlaps. This is important to know because the size (number reported in the paper) alone does not guarantee reliable evaluation.

Questions for authors
  1. how many failures were due to the SDK?

  2. how was the dataset constructed? how did you get paired text descriptions? I dont see this information in the paper

  3. Are there other failure modes in larger assemblies that are not visible from the metrics?

3 comments
AuthorsOpenReview ↗

offical Response to Reviewer zkqF

General Comment

Thank you for your constructive review. We appreciate your recognition of the distinction between final geometric validity and sequential assembly feasibility, and of the design that connects a rejected step to its associated program operation, stage output, or SDK operation. We carefully address your concerns below.


Weakness 1: Comparability of Table 2

Reviewer Comment:

the baseline comparisons in table 2 mention that "..scores combine published results and additional measurements under their respective evaluation protocols..." this raises concerns about the comparability of results across the methods.

Response:

Thank you for highlighting the ambiguity in the Table 2 caption and your concerns on fair comparisons. We would like to clarify our experiment settings on Table 2.

Table 2 is the main comparison of generation outcomes. On revisiting the Table 2 caption, we recognize that our wording was ambiguous and did not accurately convey the intended distinction.

Specifically, we intend to describe that we use the evaluation metrics used by BrickGPT [1] and BrickNet [2] and we evaluate their methods on the same cases with the same evaluation metrics and rendering settings. In their experiment settings, BrickGPT [1] and BrickNet [2] use different metrics to prove their contributions on physical supportance and visual plausibility respectively. While DailyBrick concerns on both geometric validity and assembly feasibility, and plausible 3D model looking, baselines are re-evaluated following their original setups and protocols exactly. Combining metric choices does not mean combining copied numerical scores. We will clarify such ambiguous captions and will revise the corresponding paragraph accordingly.


Weakness 2: Dataset collection, description quality, filtering, and overlap

Reviewer Comment:

the paper mentions a large dataset is generated. but i do not see any information about how it was collected, origin/quality of text descriptions, any filtering, any overlaps. This is important to know because the size (number reported in the paper) alone does not guarantee reliable evaluation.

Response:

Thank you for highlighting the need for clearer dataset details. We agree that some information would help to improve its evaluation reliability. We expand the dataset description to distinguish model collection, text annotation, filtering, and overlap control.

Data collection. The collection contains 358,775 human-designed brick models collected from publicly available online sources in LDraw format. All underlying structures are human-designed. And the reported count is after the filtering. Text descriptions and pairing. We render each model from 8 viewpoints and provide the rendered images to GPT-5.5 to generate a text description, following the way in both BrickGPT [1] and BrickNet [2]. Each generated caption is paired with the model from which those images were rendered. Filtering. We exclude models with detected volumetric collision errors. Within each model, every brick are checked for its legal placement. Also models are verified in Blender for 3D bricks occlusion checking. Evaluation split and overlap. The evaluation uses a fixed held-out set of 18,653 model samples that is disjoint from the remaining samples in our collection. The separation is defined at model-sample level and construction sequence level.


Question 1: How many failures were due to the SDK?

Reviewer Comment:

how many failures were due to the SDK?

Response:

Thank you for raising this question. We will report two complementary audits: the fraction of all failed cases attributable to SDK implementation defects, and the fraction of all SDK routines with verified implementation defects. These quantify failure impact and implementation coverage, respectively.

1. Failure-case audit. We revisit all final failed cases for DailyBrick with Qwen3.6-27B and GPT 6-Astra from their respective evaluation runs on the full test split. We classify a case as SDK-attributable when a verified SDK implementation defect caused or contributed to its failure.

Table R1a. Failure-case audit.

DailyBrickSDK-attributable failed casesProportion of the test split (%)Proportion of failed cases (%)
DailyBrick (w/Qwen3.6-27B)1630.874%5.26%
DailyBrick (w/GPT 6-Astra)930.499%4.34%

2. SDK-routine audit. We fix the SDK version and enumerate its public callable routines, excluding private helpers and counting each routine once rather than counting call sites or repeated invocations. We report the total routine count, the number actually inspected, and the number with verified implementation defects. All routines implicated in the failure-case audit will be inspected.

Table R1b. SDK-routine audit.

Total SDKwith verified defectsProportion (%)
23672.97%
AuthorsOpenReview ↗

offical Response to Reviewer zkqF

Question 2: Dataset construction and paired text descriptions

Reviewer Comment:

how was the dataset constructed? how did you get paired text descriptions? I dont see this information in the paper

Response:

Thank you for pointing out this omission. Following the rendering-based annotation approach used in BrickGPT and BrickNet, we obtain paired descriptions from rendered views of the brick models. We collect human-designed models in LDraw format, render each model from eight viewpoints, and provide these images to GPT-5.5 to generate a corresponding caption. Each caption is paired with the exact model from which its images were rendered.


Question 3: Failure modes in larger assemblies

Reviewer Comment:

Are there other failure modes in larger assemblies that are not visible from the metrics?

Response:

Our metrics used in the manuscript follows the experoment settings in BrickGPT [1] and BrickNet [2], and would be not effected by the size of LEGO models. They would reflect violations of geometric, and construction-sequence constraints, no matter how large or small the assembly is.


References

[1] Ava Pun, Kangle Deng, Ruixuan Liu, Deva Ramanan, Changliu Liu, and Jun-Yan Zhu. Generating Physically Stable and Buildable Brick Structures from Text. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pp. 14798-14809, 2025.

[2] Peter Kulits and Cordelia Schmid. BrickNet: Graph-Backed Generative Brick Assembly. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 39252-39261, 2026.

i thank the authors for their rebuttal. i will be keeping my score

Reviewer_DyEmOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

DailyBrick frames language-guided LEGO generation as a coupled design-and-execution task: given a user request, the system must produce both a model and per-brick assembly instructions that remain structurally valid when replayed. It decomposes construction into Planner–Designer–Critic stages, exposes intermediate operations through a construction SDK and skills, records a versioned construction trace, and uses a verifier, Meta-Reviewer error localization, and targeted repair to update a stage or artifact. Across 18,653 cases, multiple base models, and cumulative ablations, the paper reports improvements in Valid/Stable, replay/prefix, and final Accept metrics, showing useful performance within its LDraw/discrete-verification scope. However, it does not yet identify an independent mechanism beyond composing planning, design, validation, and repair components; its request-alignment and physical/robotic claims also extend beyond what the evaluation establishes. The central question is whether DailyBrick presents a new construction mechanism or a well-engineered pipeline with empirical gains.

Critical strengths
  1. DailyBrick defines a coherent output contract: the model, per-brick instructions, and a replayable construction trace are linked through operations, intermediate states, brick identities, and validation results.
  2. Within the LDraw/discrete-verification scope, the multi-model results and cumulative ablation support improvements in structural validity and replay stability, while the paper acknowledges that verify replay is not physical robot execution and structural validity is not design quality.
Critical weaknesses
  1. The paper’s intended mechanism appears to be execution-grounded construction: high-level designs are compiled into canonical brick operations, construction traces and replay expose failures, and provenance routes them to a responsible stage, skill, or SDK for targeted repair. However, the paper does not extract this mechanism from the surrounding Planner–Designer–Critic, SDK/skills, verifier, and Meta-Reviewer components. The contribution therefore remains closer to pipeline integration than to a clearly defined and reusable construction method.
  2. The component effects are not cleanly isolated. Table 2 mixes published results with additional measurements, while Table 4 is cumulative rather than factorial; the independent roles of retries, repair, the guarded pipeline, and other components therefore remain unclear.
Questions for authors

Can the authors provide a capability-matched, component-isolating comparison that fixes the cases, base model, inventory, renderer/verifier, prompt, seed, retry budget, and evaluation protocol, and identify which parts of the construction trace/replay, provenance, and targeted-repair loop provide an independent gain beyond the underlying Planner–Designer–Critic pipeline?

5 comments
AuthorsOpenReview ↗

offical Response to Reviewer DyEm

General Comment

Thank you for your careful and constructive review. We particularly appreciate your recognition of DailyBrick's coherent output contract, where we link the model, per-brick instructions, and a replayable construction trace through operations, to intermediate states, brick identities, and validation results. We also appreciate your assessment that the multi-model experiments and cumulative ablation support improvements in structural validity and replay stability within the LDraw/discrete-verification scope. These observations capture the central motivation of our work. We respond to each weakness and question below.


Weakness 1: Distinguishing the construction method from general pipeline integration

Reviewer Comment:

The paper’s intended mechanism appears to be execution-grounded construction: high-level designs are compiled into canonical brick operations, construction traces and replay expose failures, and provenance routes them to a responsible stage, skill, or SDK for targeted repair. However, the paper does not extract this mechanism from the surrounding Planner–Designer–Critic, SDK/skills, verifier, and Meta-Reviewer components. The contribution therefore remains closer to pipeline integration than to a clearly defined and reusable construction method.

Response:

Thank you for highlighting this distinction. DailyBrick provides a defined and reusable construction method. Instead of the general agent collaboration pattern, DailyBrick organizes stages for LEGO bricks and models, compiling high-level LEGO designs into canonical brick operations. DailyBrick additionally specifies how construction decisions become executable brick operations, how the generated model and instructions remain consistent, and how execution failures are traced back to decisions that can be revised.

Specifically, a construction program is compiled through the SDK and partial assembly skills into canonical brick operations, with the originating program operation recorded for each placement. The model and instruction views are derived from this shared placement trace. Verify replay checks successive construction states and reports a rejected action, its violated constraint, and the last accepted state. Recorded provenance then connects this evidence to the associated program operation, stage output, skill, or SDK operation, enabling the Self Meta-Reviewer to select a revision target. The revised program is recompiled and undergoes complete replay before acceptance. These components implement distinct parts of the construction method: The construction SDK/skills connects semantic plans to executable brick operations, rather than asking the model to emit an unstructured sequence of placements. Self Meta-Reviewer verify the replayed assembly trace to locate errors targeted repair to update a stage or artifact. PDC organizes stage-level collaboration, whereas the construction method specifies the executable operations, consistency relationships, verification evidence, and revision targets used within that collaboration. The component-isolating study in Table R1 below evaluates the corresponding capabilities while retaining PDC.

AuthorsOpenReview ↗

offical Response to Reviewer DyEm

Weakness 2: The roles of individual components are unclear

Reviewer Comment:

The component effects are not cleanly isolated. Table 2 mixes published results with additional measurements, while Table 4 is cumulative rather than factorial; the independent roles of retries, repair, the guarded pipeline, and other components therefore remain unclear.

Response:

Thank you for highlighting this point and your concerns. We would like to clarify our experiment settings on Table 2 and Table 4.

1. Table 2 is the main comparison of generation outcomes. On revisiting the Table 2 caption, we recognize that our wording was ambiguous and did not accurately convey the intended distinction. The baseline methods were evaluated in our very first submission following their original method configurations. Specifically, we intend to describe that we combined the evaluation metrics used by BrickGPT [1] and BrickNet [2]. BrickGPT [1] and BrickNet [2] use different metrics to prove their contributions on physical support and visual plausibility respectively. While DailyBrick concerns on both geometric validity and assembly feasibility, and plausible 3D model looking. We retain each baseline's original generation configuration and evaluate its outputs on the same test cases using shared rendering and metric-computation procedures. Combining metric choices does not mean combining copied numerical scores. We will clarify such ambiguous captions and will revise the corresponding paragraph accordingly.

2. Table 4 is the ablation study on DailyBrick's components. As listed in Table 4, the components of DailyBrick, PDC, SDK/skills, are progressively build by the configurations on one another. All compared outputs are evaluated on the same test cases using the same rendering and metric-computation procedures. Retry opportunities and resource ceilings are fixed, construction guards and the final evaluator are retained, and targeted repair is compared with ordinary correction under the same budget. The purpose of this table is to examine how the overall pipeline changes as these components are introduced. For example, the comparison between baseline+(i) and baseline+(i)+(ii) measures the effect of adding the (ii) SDK/skills. We agree, however, that these cumulative comparisons do not fully isolate the contribution of each mechanism. To address this concern, we will supplement Table 4 with component-isolating comparisons under matched settings. Specifically, we will use the PDC pipeline as a common starting point.


Question: Capability-matched, component-isolating comparison beyond PDC

Reviewer Comment:

Can the authors provide a capability-matched, component-isolating comparison that fixes the cases, base model, inventory, renderer/verifier, prompt, seed, retry budget, and evaluation protocol, and identify which parts of the construction trace/replay, provenance, and targeted-repair loop provide an independent gain beyond the underlying Planner–Designer–Critic pipeline?

Response:

Thank you for specifying the comparison needed to isolate these contributions. Table R1 reports a subtractive ablation of the complete DailyBrick pipeline under fixed experimental settings. PDC is retained in every configuration, allowing us to assess the incremental contributions of construction-trace/replay diagnostic feedback, explicit provenance, and targeted repair beyond the shared PDC pipeline.

Ablation settings. We evaluate the complete DailyBrick pipeline and selectively disable three construction-specific capabilities on the 18,653 test split cases while providing all access to the brick inventory. We use DailyBrick (w/ Qwen3.6-27B) as the base model. And we keep the same rendering script, verifier, prompt, seed, retry budget on each ablation option. The evaluation protocol remains the same from the baseline methods. Compared to DailyBrick (full) pipeline. Planner–Designer–Critic (PDC) baseline retains the common pass/fail signal but withholds A's detailed diagnostics and B's explicit source links, and uses ordinary correction instead of C's targeted repair (without A, B and C) . It still retains the underlying PDC pipeline.

AuthorsOpenReview ↗

offical Response to Reviewer DyEm

Continue as Response to Question:

A: Construction-trace/replay. DailyBrick (full) pipeline provides the repair process with step-level execution evidence, including the rejected placement, the violated constraint, and the relevant intermediate assembly state. The w/o A configuration withholds this diagnostic feedback while retaining the common pass/fail signal. Trace generation for the model and instructions and independent replay for final evaluation are retained. As shown in TableR1, the performance states that traceable brick operations and verification replay provide actionable execution evidence for the Self Meta-Reviewer.

B: Provenance. DailyBrick (full) pipeline records links from placements to their originating program operations, stage outputs, skills, and SDK operations. The w/o B configuration withholds these explicit source links. The model may still inspect those artifacts and infer a revision target, but it cannot use the recorded provenance mapping or receive the same links through another feedback channel. The performance drops isolates the contribution of operation-level traceability to guiding targeted updates.

C: Targeted-repair loop. DailyBrick (full) pipeline directs revision to a selected program or stage scope and regenerates the affected downstream outputs. The w/o C configuration replaces this scoped repair with an ordinary correction round that regenerates the full candidate. Both configurations have the same allowed correction/retry opportunities, call/token ceilings, and stopping rules, and undergo the same subsequent compilation and verification. While disabling the target-update loop, the targeted updates by the Self Meta-Reviewer perform beyond an equally budgeted ordinary correction round.

Table R1. Subtractive ablation from the complete DailyBrick pipeline. A: construction-trace/replay; B: provenance; C: targeted-repair loop. All options share a fixed configuration.

VariantValid (%)Stable (%)CLIPDINOv2P_invVQAScorePESigLIP2Replay exact (%)All-prefix passFailure pos.AcceptTokens/case
DailyBrick (full)100.0100.00.3400.9060.0490.7360.3620.724100.01.0000.9600.8347.760k
w/o A99.999.830.3400.9010.0490.7240.3610.721100.00.9500.9510.7388.237k
w/o B99.999.920.3390.9040.0490.7300.3610.721100.00.9540.9580.7918.062k
w/o C100.099.860.3390.8990.0490.7240.3600.72294.80.9450.9560.6948.167k
PDC baseline100.099.840.3390.8970.0490.7210.3600.72095.620.9430.9490.6767.253k

References

[1] Ava Pun, Kangle Deng, Ruixuan Liu, Deva Ramanan, Changliu Liu, and Jun-Yan Zhu. Generating Physically Stable and Buildable Brick Structures from Text. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pp. 14798-14809, 2025.

[2] Peter Kulits and Cordelia Schmid. BrickNet: Graph-Backed Generative Brick Assembly. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 39252-39261, 2026.

Comments on the paper

2 comments
AuthorsOpenReview ↗

General Response (First-round)

General Response to AC and Reviewers

Dear Area Chair and all Reviewers,

We sincerely thank the Area Chair and all reviewers for your time, careful assessment, and constructive feedback. We appreciate your recognitions of the importance of our work. The comments also provide valuable guidance for clarifying the method and strengthening our work.

Three reviewers consistently describe DailyBrick as a language-guided framework that jointly generates LEGO models and step-by-step assembly instructions through structured construction and refinement. Their summaries acknowledge the reported empirical benefits of the overall framework across multiple base models, particularly in model quality and assembly-sequence validity within the stated LDraw/discrete-verification scope.

We introduce DailyBrick, an agentic pipeline that turns user requests into LEGO models and their step-by-step assembly instructions, rather than generation of final geometry alone. Our contributions are as follows: 1) we present DailyBrick, a multi-stage agentic pipeline that turns user LEGO requests into 3D models and step-by-step assembly instructions, where a Self Meta-Reviewer would locate errors and achieve target updates; 2) we develop a brick-construction SDK with reusable partial assembly skills and traceable brick operations. Combined with verify replay, these operations provide evidence for the Self Meta-Reviewer to locate errors and guide targeted updates.

We present the first-round detailed, point-by-point responses below to each concern all reviewers have raised.

AuthorsOpenReview ↗

Rebuttal Summary

Dear ICLR 2027 Reviewers, AC, SAC, and PC,

We thank the Area Chair and all reviewers for their careful assessment and constructive feedback.

Following the rebuttal discussion, all three reviewers’ final scores are 3. The reviews recognised the value of DailyBrick’s goal of jointly generating LEGO models and executable, step-by-step assembly instructions, as well as the importance of evaluating both model quality and assembly-sequence validity. In response, we clarified the task-specific construction method, addressed questions about evaluation and dataset construction, and added analyses to better isolate the roles of the main components.

We provided the clarification and the additional matched ablation study. The new results substantially address Reviewer DyEm‘s main concern about DailyBrick's contributions beyond the underlying Planner–Designer–Critic pipeline.

Reviewer zkqF raised concerns about our experiment settings and collection details on our large dataset. We are glad that our rebuttal clarified the evaluation setup and provided further details and analyses addressing these questions.

Reviewer hVcZ asked what makes DailyBrick’s design specific to LEGO generation. We explained the LEGO-specific designs and addressed the concerns.

Overall, all three reviewers gave positive final ratings (3, 3, 3) following the rebuttal. We are grateful that the discussion helped us clarify the scope and contribution of DailyBrick: a framework that connects language-guided LEGO model generation with executable assembly instructions and construction-sequence verification.

Thank you very much for your time and support.

Sincerely,

The authors

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.