ShapeCraft: LLM Agents for Structured, Textured and Interactive 3D Modeling
Authors: Shuyuan Zhang
Chenhan Jiang
Zuoou Li
Jiankang Deng
Venue: NeurIPS 2025 poster ()
Keywords: Text-to-3D Generation
LLM Agents
3D Modeling
Primary area: applications

Abstract: 3D generation from natural language offers significant potential to reduce expert manual modeling efforts and enhance accessibility to 3D assets. However, existing methods often yield unstructured meshes and exhibit poor interactivity, making them impractical for artistic workflows. To address these limitations, we represent 3D assets as shape programs and introduce ShapeCraft, a novel multi-agent framework for text-to-3D generation. At its core, we propose a Graph-based Procedural Shape (GPS) representation that decomposes complex natural language into a structured graph of sub-tasks, thereby facilitating accurate LLM comprehension and interpretation of spatial relationships and semantic shape details. Specifically, LLM agents hierarchically parse user input to initialize GPS, then iteratively refine procedural modeling and painting to produce structured, textured, and interactive 3D assets. Qualitative and quantitative experiments demonstrate ShapeCraft's superior performance in generating geometrically accurate and semantically rich 3D assets compared to existing LLM-based agents. We further show the versatility of ShapeCraft through examples of animated and user-customized editing, highlighting its potential for broader interactive applications.

ShapeCraft: LLM Agents for Structured, Textured and Interactive 3D Modeling
Shuyuan Zhang's Chenhan Jiang Zuoou Li' Jiankang Deng"
Equal Contribution Imperial College London Hong Kong University of Science and Technology
SHAPE EDITING
ShapeCraft
ANIMATION
Figure 1: Qualitative results of ShapeCraft. Our agentic (ext-to-shape framework generates bounding volumes, raw meshes and textured shapes, enabling advanced post-modeling interactions like shape editing and animation tasks. Project page is http:://aabbnggyyurrggggiuuuuuuu
Abstract
3D generation from natural language offers significant potential to reduce expert manual modeling efforts and enhance accessibility to 3D assets. However, existing methods often yield unstructured meshes and exhibit poor interactivity, making them impractical for artistic workflows. To address these limitations, we represent 3D assets shape programs and introduce ShapeCraft, novel multi-agent frame- work for text-to-3D generation. At its core, we propose a Graph-based Procedural Shape (GPS) representation that decomposes complex natural language into structured graph of sub-tasks, thereby facilitating accurate LLM comprehension and interpretation of spatial relationships and semantic shape details. Specifically, I.LM agents hierarchically parse user input to initialize GPS, then iteratively refine procedural modeling and painting produce structured, textured, and interactive 3D assets. Qualitative and quantitative experiments demonstrate ShapeCraft's 's superior performance in generating geometrically accurate and semantically rich 3D assets compared to existing LLM-based agents. We further show the versa- tility of ShapeCraft through examples of animated and user-customized editing, highlighting its potential for broader interactive applications.
*Corresponding authors: jcheyan @ gmail.com. j.deng 16 @e@@mmmrillaccc
39th Conference on Neural Information Processing Systems (NcurIPS 2025).

---

Introduction
3D modeling plays a pivotal role in domains ranging from immersive entertainment to embodied AI systems. While conventional workflows rely on professional artists using domain-specific tools like Blender 4 or Maya [2], this process is both time-consuming and costly. Recent advances have explored generative methods to democratize 3D content creation through natural language interfaces, yet significant challenges persist in producing production-ready assets.
Current text-to-3D generation systems primarily follow two paradigms. Optimization-basee based meth- 33
ods
25
leverage pre-trained 21) diffusion models [49] to create implicit 3D rep-
resentations like neural fields [39] and signed distance field [42). These require subsequent iso-
surfacing 37 1
32
to extract usable meshes, often resulting in dense tessellation, smoothing
[20]. Alternatively, autoregressive approaches [8, [57] directly generate surface meshes by modeling triangle sequences, often training from scratch on large-scale datasets (55 6 12]. However, these methods frequently lack semantic part segmentation and exhibit poor modifiability due to their monolithic representation. Both paradigms thus struggle to yield structured and highly editable 3D models for practical artistic workflows. To meet practical demands, an ideal generative modeling system should demand three essential capabilities: 1) produc- tion of well-structured geometry with plausible topology compatible with industry workflows; 2) use support for post- mose-nnnninng interaction, allowing shapes to be easily edited, animated, or argricult; and 3) comprehension of complex, lengthy natural language descriptions.
artifacts, and topologiaa inconsistencies
One promising approach to enable structured and interactive 3D shape generation is to represent shapes structured computer programs. Such procedural representations 100 67 68 not only produce geometry upon execution, but also allow users with basic programming knowledge to understand and modify the generated models (27]. However, conventional methods for shape program generation training on point clouds [3] or CAD modeling datasets [60] [9]. The more general task of text-to-shapp shape program generation remains largely underexplored. mainly due to the scarcity of annotated text- proo-ra pairs. Recently, LLM agents 1 6]] have shown potential for translating natural language into programs (26). leveraging their remarkable reasoning and understanding. While this has inspired exploration into using them for shape program generation, a major challenge arises from LLMs' limited ability to interpret complex textual inputs concerning spatial relationships and semantic shape details. Indeed, 3D-PREMISE [66), an initial effort to integrate LLMs with 3D modeling software for direct shape generation, often yield inaccurate programs. CADCode Verify [I] attempts to improve this with a visual question answering-basee self-correction strategy, but it's restricted CAD datasets and does not generalize open-domain 3D shapes.
To this end, we introduce a graph-based based procedural shape (GPS) representation that breaks down complex natural language descriptions into structured graph of sub-tasks, augmented with coarse bounding volumes to define their spatial relationships. This decomposition into simpler, inherently independent components significantly enhances the LLM's capacity understand user descriptions, serving as a shared memory in our generative system. Building upon GPS representation, we design multi-agent system ShapeCraft, comprising Parser, Coder, and Evaluator. The Parser agent is responsible for constructing the GPS from the initial user input. Subsequently, for the modeling phase, nodes in GPS enable Coder agent to employ multi-path sampling strategy, exploring alternative modeling sequences in parallel while collaborating with the Evaluator for validation and refinement. We further develop a component-awe aware BRDF-based shape painting module for surface appearance. Leveraging the component decomposition provided by GPS nodes, this module improves text alignment for user descriptions and enables realistic surface-light interactions in downstream tools. Qualitative results are showcased in Fig. T Extensive experimental evaluation demonstrates that our ShapeCraft can produce more accurate shapes following user input than existing LLLd-based and autoregressive 3D generation approaches, ShapeCraft
methods. Compared to optimization-bans possess superior geometric structure in quality and quantitative results.
Our contributions are summarized as follows:
Exploration of a traph-based procedural shape representation, facilitating efficient program- matic updates and flexible structure interaction for real-world applications.
Introducing ShapeCraft, multiple LLM agents system designed for 3D shape modeling and painting- Our approach leverages the innate multimodal reasoning capabilities of L.LMs, streamlining the efficiency of end-users engaged in procedural 3D modeling.

---

Empirical experiments demonstrate the substantial potential of LLMs in terms of their reason- ing. planning, and tool-using capabilities in 3D content generation.
2
Related works
Text-to-3D Generation.
Existing text-to-3D generation methods can be categorized into two
streams: optimization-baset methods and autogressive-basel methods. The former approaches
43
7
33
58
25 23 center around the Score Distillation Sampling (SDS) algorithm proposed by
43
which leverages 2D diffusion model priors[49) for optimizing unstructured 3D representations
39
30
extract usable meshes, often resulting in dense tessellation, smoothing artifacts, and topological inconsistencies [20].The latter one use auto-gressive architectures [ 23 to directly encode the sequence of triangles. These models are efficient in inference but often struggle with generalizability and training stability. attributed to the limited scope and complexity of available 3D datasets. One promising way is procedural modeling [27] to produce structure 3D shape. However, there is no sufficient text- text-program pairs for more general classes. In this work, we propose use the understanding and reasoning capacity of LLM 40 to generate python API for industrial tools.
However, These require subsequent iso-surfacing [37 13 32
LLM Agents. Recent advances in large language models (LLMs), such as LLaMA 54 and GPT-4 [41] have expanded their capabilities beyond natural language processing multimodal tasks, particularly in understanding and generation of vision languages. The emergence of LLMM-based agents, as seen in works like AutoGPT [8]. HuggingGPT [50), and InternChat [36), has demonstrated their ability to autonomously plan and execute complex workflows leveraging external tools, ranging from software development [44 48 (38) to image synthesis (56 45). In image generation, LLM agents have been applied to layout planning [5] 46), self-correction (56), and dynamic model selection 45
significantly improving controllability and adaptability in text-to-image pipelines.
However, compared their sophisticated applications in 2D counterparts, the adoption of LLM agents
in 3D remains relatively limited. Existing efforts primarily focus scene generation 63 22 34 B5
68 These methods demonstrate the potential of LLM agents for spatial understanding, translating
natural language descriptions into layouts 63 or scene graphs [22 34 They also highlight robust
tool integration, as 3D-GPT [53] models 3D scenes via function calls to an existing procedural function library. Nevertheless, these approaches predominantly retrieve and arrange existing 3D assets to populate scenes, capturing only coarse inter-object spatial relationships Critically, they lack direct support for fine-grinned shape modeling, which demands more complex semantic understanding and precise geometric detailing beyond simple layout generation or asset placement.
Preliminary efforts in shape modeling [66] 62] often suffer from the LLMs' limited ability to produce geometrically sound structures. Despite enhancements like CADCodeVerify [| VQA- based feedback and BlenderLLLM's [14] fine-tuning on specific instructive prompts and shape pairs, these methods primarily cater to specialized CAD modeling tasks. This specialization hinders their generalization to open-ended natural language prompts, which inherently involve greater geometric and semantic complexity. To bridge the gap, we propose a multi-agent system equipped with a novel graph-based procedural shape representation supporting more diverse and complex shape generation.
3 Method
3.1
Overview of ShapeCraft
The proposed ShapeCraft is a collaborative multi-agent system designed to tackle the complex text- to-3D generation task, as depicted in Figure The system's 's architecture features three specialized agents-a a Parser, a Coder, and an Evaluator- that interact by a central, shared data structure: the Graph-based Procedural Shape (GPS) representation. Each agent has distinct role in progressively constructing and refining this shared representation:
Parser agent is responsible for establishing the initial topology of the GPS representation by parsing the input text into the graph's nodes, edges, and their associated semantic descriptions (in Sec. 3.2
Coder agent populates the GPS representation with concrete attributes. For each node, it can generate the corresponding bounding volume or code snippet that defines its geometry (in Sec. 3.2 and 3.3
3

---

Modelling: todeng Smrbhp
Graph Regresentation
Painting:
Texturer Field Training
Coder
Shope Prometier lptip with tifs fat
Rendeed Irunge
soreet
Parser
Evaluator
Dovenie dtol
Graphi
Seyboard
Screen
Eveluntor
Lapsup
Touehadd
Thp Case
dim feedbock fimm
Node Properties (e.g. V3 "Keebbord"":
Cansmiin descriptaan of
Teduaa
Ibulodres equa sms araaged
plad"
Testurad Goneration
Fostonaal poppritionn of cowen.
sights how las sccupio coue
Bounding unluues E.
(ea Sa Now.))
m (2.M) putlo <e (0.7 13 steps
snlpoet
Figure 2: Overview of ShapeCraft system, multi-agent system to produce structured and post- modeling friendly 3d assets. Given shape description æ, the Parser agent hierarchically decomposes the shape and initializes Graph-based Procedural Shape representation G. Then, each node v; is iteratively modeled by updating its code snippet using multi-path strategy, with reinforcement from the Coder and Evaluator agents. Finally, component-awand score distillation learns texture field from the resulting mesh to produce textured results.
Evaluator agent acts as a quality control mechanism, assesses the outputs generated by the Coder, providing feedback the plausibility of the bounding volumes and the correctness of the code snippets to guide the self-correction process (in Sec. 3.2 and 3.3).
Once the GPS representation is updated or finalized, a procedural execution module Ω is invoked. This module executes the code snippets stored within the GPS for each node in Blender. It then assembles the geometry of the resulting primitives based on respective bounding volumes, forming the complete 3D shape. If a code snippet for node empty, the module defaults to generating a primitive cube parameterized by that node's bounding volume. When given specific node of GPS, Q bypasses the full assembly process and directly yields the corresponding partial geometry.
3.2 Graph-based Procedural Shape Representation
Central to our agentic framework is a GPS representation G = EV,E,A) serving as a shared memory for all agents. Although complex shape parsing follows hierarchical breakdown, the GPS representation employs a flat, single-level graph structure. This design facilitates parallel shape modeling by treating each geometric component as a self-contained task. The graph rooted in semantic virtual root node, Up E V. representing the global abstraction. All other nodes, {0;)ss Jiso C V, represent distinct geometric components, and are treated as direct children of the root. This results in depth-1 structure where the edges are defined as 3 = {11,, vo) 0}. Each component node v; is then characterized by four attributes A(v;) (ng, n bi, pi), where:
Geometric description nf: A upsampled textual description of component vs, emphasizing its specific geometric shape and features. By narrowing the LLM's attention to a component-level searching space, this enhances the accuracy of code generation.
Positional description nf: A textual description outlining the spatial relationships and relative placement of V; which guides the LLM in determining its bounding volume parameters.
Bounding volume by E R Defines the spatial extent of 2 with its center coordinates and size (ca. Cy. Cz. h, w. This geometric information is crucial for accurately positioning the component and normalizing its scale, ensuring overall consistency in the complete 3D shape.
Code snippet p:: An executable Blender API script, initially empty and ensuring accessibility and comprehensibility for LLMs.
Hierarchical shape parsing and graph initialization. Given the input s, Parser first instantiates the virtual root node vo, summarizing the core identity of the described object. Subsequently, the

---

agent iteratively decomposes this high-level concept into a conceptual hierarchy of components. Crucially, this hierarchy is then flattened conform to our GPS representation. Only the terminal nodes of these decomposition paths are retained to form the set of component nodes {1e hss For example, after summarizing x as "chair", the Parser might generate a reasoning path such as "chair->upper body- bocky-backrestt. And "backrest" is instantiated as a node 1i which is then connected directly to the root up-
Following hierarchical parsing and structural flattening, which establishes the graph's topology (V, Parser agent further generates geometric and positional descriptions n and nž respectively. Subsequently, the Coder agent utilizes positional description n to generate corresponding bounding volume b, for each component, thus completing the initialization of the skeleton graph Go.
Representation bootstrapping. To mitigate potential inaccuracies in the GPS representation arising from the inherent limitations or hallucinations of LLMs, propose representation boot- strapping process. We aim to enhance an initial representation Go to produce a more accurate final version G*. As mentioned above, initial representation Go Coder(Parser(z)). Then for each iteration i, the following two steps are performed:
1. Evaluation and feedback generation: The current representation G; is assessed by an Evaluator agent, which inspects the rendered bounding box images for components up E 9, to identify inconsistencies errors. It then produces textual feedback ft, outlining the necessary corrections: fi = Evaluator(Q((.)) (f)()))
Conditional graph update: The original description I , the feedback fi, and the last G. are used as combined context to generate an improved representation Gi+1 t- Coder (Palserrarrrr fi, G;)). In this step, the Parser re-interprets the input x conditioned on the previous information, and the Coder subsequently refines the bounding box parameters.
The process terminates after N iterations, yielding the final refined representation G" = Gv. Empiri- cally, we find N = 2 is a good trade-off between performance and computational efficiency.
3.3 Iterative Shape modeling with Multi-path Sampling.
To address the Coder agent's inherent limitations in spatial understanding and generate diverse and accurate 3D shapes, we propose an iterative shape modeling with multi-path sampling strategy. For capturing 3D modeling diversity and enabling broader exploration of design alternatives, multi-path sampling strategy is employed by configuring the Coder agent with higher temperature settings, thereby encouraging the generation of multiple, distinct modeling paths for each shape component. Iterative modeling aims to correct the Coder when unreasonable results are produced. The entire process is detailed in Algorithm
Initially, for each node {v) V within G*, we create copies of the node's state, denoted as (v. 1mm 1M where M is the number of modeling paths, superscript 0 indicates the initial iteration step. The Coder agent then populates each v.P.. with its corresponding initial code snippet, based on the node's geometric description nă supplemented by textual overview of g".
Subsequently, the multi-path modeling proceeds iteratively for refinement steps (or until early stopping). At each step E {O...., T 1}. Evaluator agent provides evaluations for of using the procedural execution module to assemble and render images of the resulting component from different viewing angles (detailed camera settings can be found in Appendix Section B) A feedback description fi.m and a quantitative quality score s are generated, formally expressed as:
fi f. Evaluatorr(Q(u
Following this evaluation, the Coder agent updates and refines these candidate nodes for the next iteration. This self-correction process for each node of in a path driven by its no and pf in conjunction with the Evaluator's 's feedback and g", leading to the updated node:
1+1 +- Coder(vi, G")
We also employ an early stopping mechanism to improve efficiency: if any candidate path achieves score sf,, higher than a preset threshold 8., its generation result deemed sufficient and the iterative process is terminated to conserve LLM computational resources. resourcs..
5

---

Algorithm 1: Iterative Shape Modeling with Multi-path Sampling
Input: GPS graph G*, number of paths M, maximum iterations T, score threshold
Updated GPS representation g for each node v E V, do
Output:
Create M initial node states: {u 1.
m==1
Initialize candidate scores: fst Jm=11 +-
Initialize best node states: (u Jmm1
M f-
for path m + to M do Generate initial code snippet from node attributes: v..m + -od)
for iteration 4- 0 to T
Execute program: mesh, [7] +- 9(vx))
Evaluate: fi.m= sf,m +- Evaluator (
if i..m s.m
then
11
iim t i.m
best + vi
12
1,m
13
8 i.m 2 then
break:
// Early stopping for this path
15
4.
[+1 Coder(uf, fi fi,m: g*):
// Refine program
m < arg maXm $i,
// Select best path
Update 9" with best
17
18 return g
Finally, for each node, the candidate path yielding the highest score s will be selected. The geometry corresponding to this chosen path will then be used to update the GPS representation g", thereby producing the final 9 for subsequent painting or post-modeling interaction.
3.4
Component-aware BRDF-based Shape Painting
We propose component-awes ccst-diisiillatinn sampling scheme, which enables mesh painting from complex prompts by leveraging the compositional structure inherent in GPS representations.
Texture Field vb. Let E R² denotes UV coordinates on the surface mesh. We define learnable texture field wia R + R mapping UV coordinates to BRDF parameters (kig, ky, km.) vh (p) where kJ R23 represents the diffuse albedo, k, E encodes surface roughness measuring the extent of specular reflection, and km IR denotes the metalness factor. All BRDF parameters are between [0, 1], which can seamlessly integrate into standard rendering pipelines and industrial tools.
Component-aware Score Distillation (CASD). We optimize 0 of the by distilling from a pre- trained text-to-image diffusion model through Score Distillation Sampling (SDS) 43) optimization. Given randomly sampled viewing direction w and predicted BRDF parameters, a render image I= L(vx((),, w) is obtained following the rendering equation [29). Then, the parameter 0 updated by minimizing the SDS loss, whose gradient is computed as:
0g(0, c)
VoLsns(I, x) Er,eo
00
where w(t) is weighting function depending on timestep t, and eq == (1+s)e t,,, seq, (Xe, t, is the modification of noise prediction with classifier-free guidance (CFG) as
Our component-aware optimization process integrates both global and component-level SDS to enhance alignment with the user input The process begins with the constructed GPS representation
ÿ First, global UV parameterization is computed for the entire shape surface by xatlas [64]. Concurrently, for each component 2 V, we isolate the corresponding set of surface points P,, Each set exclusively comprises the points on the externlly visible surface of its component, enabling

---

MVDream
ShapeCraft
resteeyske canditionur
rarb dire solor it off siitee mataraa bot rough, mukse Rroie
rechorophlr
vide, floe bos A sisner bot twn narrow, verted boree artrests forr cylonrical less syporronce
tell upriske rectenpuler the A nabtle kantaebel groom repanchar ehem and server bendle
Ridge
Figure 3: Qualitative comparison with optimization-based method. ShapeCraft consistently produces more structured meshes with better prompt following both geometry and texture (e.g. "rust and dirt spots" in air conditioner). Red and blue areas highlight specific zoom-in observations.
targeted optimization. The final component-awarr SDS loss is defined as follow:
CCASD (sDs(L((h(())ww))) (SDo(L((oo....). nz)
(4)
4 Experiments
4.1 Implement Details
We employ the same previous one focus decompose the user input into geometric description and positional description, latter one transfer geometric description and positional description to bonding box code and shape program. And Owen-VL-Max as the Evaluator agent. For shape modeling, set the number of path M = 3 and the iterative update step = for each node. More experiment settings can be found in Appendix Section B
with thinking disabled as Parser and Coder agents, but
Compared Baselines. We compare ShapeCraft against a diverse of baselines, encompassing different paradigms. Our compared methods include the optimization based method MVDream [51 (assessed with texture), the autoregressive-based method LLaMA-Mesh [57] and several LLM-based methods: 3D-PreMise (66), CADCode Verify [1] L3GO (62) and BlenderLLM [4]. As the original implementations were not open-source, we reproduced 3D-PreMise, which involves directly querying an LLM to generate entire shape program and iteratively refining it with visual feedback. Similarly, we reproduced CADCode Verfod incorporating its Visual Question-Anse Answering (VQA) mechanism to enhance the quality of visual feedback generation. For other methods, utilized their official codebases with default settings. To ensure a fair comparison, all LLM-basee methods that perform a similar function to ShapeCraft's LLM agents (e.g., code generation) employed the same underlying LLM model, specifically Qwen3-235B-A225 and Qwen-VL-Max VL.MMxx for VLM model.
4.2 Text-to-Shape Modeling
Qualitative Comparisons. (i) Compared to optimization-base method. We choose MVDream
as a representative optimization-basee method. shown Figure 3 MVDream struggles to produce structured geometry due to the inherent limitations of extracting surfaces from implicit
7

---

BlendarLLM
3D- ProMise
GADCudeVeniy
LaG0
LLaMA-Mesh
ShapeCraft
soliey d'yer Me cndicr The aubanl Anstkaak with daiing The futbomd los enedyy spried frets
par applone with téi, rastanaale Avoe The lawe ('jicly lager than che Romt, and cue tanple in de and key reheeyin camrenlyy speret degres viriilly
Reahsaa km). wrbeor Rueu conporel buo Bklt rectayukr ale pasi:: Herizsbel reelee avepó die Josp 1981
ailesper ophiowgghl
Figure 4: Qualitative comparison of raw mesh against LLM--based methods. ShapeCraft demon- strates superior performance for both intricate ("Banjo") and simpler ("hookshelf") cases. The black highlighted areas reveal ShapeCraft's 's capability to generate complex shape details, benefiting from component decomposition GPS representation.
Table Quantitative comparison geometry quality and text-3D consistency MARVEL subset.
Methods
loGT
Hausdorff dist.
CLJP Score
VQA Pass Rate
Run Time.
API Calls]
3D- 3D-PREMISE
65
0.385
0.527
26.76
0.33
2.81 min.
6
CADCode Vertify L
0.334
0.511
25.94
0.34
3.06 min.
9
BlenderLLM [4]
0.455
0.511
26.99
0.43
5.1 1 min.
N.A
LJaMA-Mesh [57
0.346
0.464
25.72
0.28
15.64 min.
N.A
MVDream [1
0.427
0.411
26.84
0.42
32.10 min.
N.A
ShapeCraft
0.471
0.415
27.27
0.44
11.68 min.
3D representations. This often leads to artifacts such holes, dense tessellation, and inconsistent topology, as observed in the zoom-in red area. In contrast, ShapeCraft produces accurate topology and smooth surfaces. Furthermore, it demonstrates superior prompt following for both shape modeling and texture generation, as exemplified by "short cylindrical legs, slightly" for sofa case and "dirt spots and rust" for air conditioner. (ii) Compared autoagressive and LLM-based methods. As shown in Figure 4 most methods can deliver acceptable meshes or simpler shapes like "bookshelf", but with increasing difficulty, the mesh generation results for "Stichter Banjo" and "eyeglasses" become inconsistent. We observe that LLM-based approaches have issues identifying organizing multiple components, or witha significant downgrade level of details, whereas autoagressive approaches L.MMA-Mesh are limited by training distribution, thus cannot generalize to arbitrary objects.
We conduct evaluations mesh quality and prompt alignment in Our method achieves the best loGT score, CLIP score and VQA Pass Rate, while also a close second to MVDream in Hausdorff Distance. This suggests ShapeCraft's superiority in terms of prompt following and alignment with shape description, as well as better mesh quality comparing to LLM-based and transformer based methods. Our method is also the only prompting based method that achieves comparable performance to optimization based method with huge advantage in terms of runtime and inference cost.
Quantitative Comparison.
Table I
4.3 Ablation Studies
Ablations on Multi-Path Sampling. We showcase sampled paths with distinct modeling strategies the right of F5 Each path is refined with VLM feedback independently increasing robustness and reducing sensitivity any single LLM failure. We also analyze the diversity of our multi-path

---

Calculabor
Suiecase
buttoms: collection smal squere prums arranged grid.
rectanguler prise body rounded edges
carnere: Hax top and hottom corfoces
(a)
(c)
Rorattve
Palit
Updities
(b)
(d)
Patid
heerotvve
Updatss
main thasiny: Rectangular prim body with rounded versical edges and conners, and a flee base
Figure 5: Showcases of iterative refinement for multi-path sampling. (a) Corrects z- z-fighting artifacts on extraneous buttons. (b) Eliminates redundant bevel operations. (c) Shows a trajectory degraded by poor initial sample, while (d) demonstrates alternative path that still yields acceptable geometry.
Table 2: Ablation studies on sampled paths M and iterative updates T in shape modeling.
Lower Hausdorff and runtime are better, and higher IoGT and CLIP Score are better. ShapeCraft demonstrates a strong balance between exploration and efficiency.
Metric
M=1, T=1
M=3, T=1
M=1, T=3
ShapeCraft (M=3, T=3)
M=3, T=5
Hausdorff +
0.485
0.444
0.494
0.415
0,360
loGT 1
0.436
0.535
0.492
0.471
0.431
CLIP Score f
25.75
25.90
26.20
27.27
26.39
Run Time (min) $
1.62
3.71
3.90
11.68
18.04
sampling strategy in the shape modeling process. Empirically, observe that for simple cases, paths tend to converge on similar modeling strategies due to low ambiguity. In contrast, for complex ambiguous prompts, distinet paths often produce different shape programs, especially under higher temperature settings. We generally observe 2-3 unique strategies across paths with intricate descriptions, reflecting ShapeCraft's capacity to explore diverse modeling alternatives thanks to multi-path sampling. Additionally, we conduct quantitative ablation studies for the first two columns in Table 2 These results show that multi-pate mallt--pthh&ee sampling significantly improves both geometry quality (IoGT, Hausdorff) and prompt alignment (CLIP), confirming its effectiveness.
Ablations on iterative updates within path We demonstrate the effectiveness of iterative updates guided by VLM feedback within each path on the left of Figure S For example, VLM feedback corrects a model clipping issue for calculator buttons and allowed for more natural modeling of the calculator's 's case by adjusting the beveling parameters. Additionally, we conduct quantitative ablation studies on sampling configurations, specifically the number sampled paths M and iterative updates T, detailed in Table [ Increasing the number of sampled paths M consistently shows continuous improvement across all quality metrics. While increasing T does improve the Hausdorff metric, doesn't guarantee better performance the other two metrics and introduces greater time overhead. Therefore, ShapeCraft balances performance and efficiency by selecting M and T 3.
Table 3: blation study hierarchical shape parsing in GPS representation. We compare with advanced LLMs operating with thinking mode. The results show our GPS representation constrains the reasoning space of LLMs, leading to more reliable and interpretable.
Metrics
CharGPT-o3
ChatGPT-o4-min-hiigh
Deepseck-R1-0522
Gemini-2.5-Pro
ShapeCraft
1
0.177
0.244
0.326
0.102
0.471
Hausdorff |
0.708
0.493
0.489
0.586
0.415
CLIP
25.48
26.30
29.01
27.31
27.27
Compile Rate
60%
80%
80%
60%
100%
Compared advanced LLMs with the thinking mode. To demonstrate the effectiveness of the Parser agent, which performs the explicit hierarchical shape parsing for GPS representation initialization, we compare its performance against advanced L.MMs that utilize thinking mode or Chain-of-Thouge (CoT) reasoning. We conduct experiments using the same prompts as in Table I enabling the thinking mode for the advanced L.LMs, including latest GPT models 24), Deepseek- RI [19 and Gemini-2.5 I] Beyond the metrics for assessing geometry quality, also report the

---

"Glven the shape program, please write Python method to add the following enimation and export videa:
"Glven follownggnnnee and Laptop screon turned degrees
write Python mathod
Figure 6: Demonstrating ShapeCraft's flexible post-modeling animation, where the LLM is prompted to directly generate animation operations based on the existing shape program.
compilation rate. This is defined as the percentage of prompts that successfully produce a valid and compilable 3D shape during single execution run. As shown in Table we empirically observe that LLMs employing free-form CoT reasoning often struggle to maintain spatial consistency across different components and frequently produce invalid results due to redundant steps hallucinated geometry operations. In contrast, our ShapeCraft leverages an explicit hierarchical shape parsing mechanism, initiated from semantic abstract representation. This approach effectively constrains the reasoning space of LLMs, leading to more reliable and interpretable initial shape generations.
Post-modeline animation. The programmable nature of our GPS representation makes it highly amenable to post-modeling interaction, including shape editing and animation. Rather than initially segmenting the holistic object into parts or iteratively optimizing the 3D representation at each timestep, our code snippet for all component nodes can be directly submitted to the LLM and serve as starting point for further interaction. Figure showcases the seamless export of direct animation from Blender. This achieved by simply prompting the LLM and provide with the underlying shape program derived from our GPS representation.
And guous
Prongp
spsaler
appl
Paroad Node::
Actual
Visual
Interto
Peeting
Interir
Ary.
Qoomaty
Figure 7: Failure cases primarily showcase issues arising from ambiguous, brief, and creative prompts. Ambiguous prompts prevent the Parser agent from achieving accurate node decompo- sition. Brief prompts compromise the Evaluator agent's visual signal, leading to invalid iterative updates. Creative prompts confuse the system, often resulting in suboptimal component placement.
5 Conclusion
In this work, we introduced ShapeCraft, a multi-agent framework that bridges the gap between text-to- 3D generation capabilities and the requirements of practical artistic workflows. Our core innovation is the Graph-based Procedural Shape (GPS) representation, which explicitly converts natural language into structured task graph. LLM agents within ShapeCraft leverage GPS to hierarchically parse and iteratively refine procedural modeling. Both qualitative and quantitative results demonstrate that ShapeCraft outperforms existing methods and successfully yields structured, textured, and interactive 3D assets, enabling language-centir 3D content creation for artists and developers alike.
Limitations and failure cases. One challenge is the impact of prompt quality on LLM agents, difficulty that persists even with hierarchical shape parsing and iterative visual feedback. As shown in Figure failure cases primarily arise from three prompt types: ambiguous prompts, which prevent Parser from achieving accurate node decomposition; brief prompts, which compromise the Evaluator's 's visual signal, leading to invalid updates; and creative prompts, which confuse the system and result in suboptimal component placement. The other main constraint of the current system the difficulty in producing complex organic geometry (e.g., tails or wings), restriction inherent to the Coder agent's library scope. We try address this by expanding the library to incorporate native models external components, shown in Appendix
10

---

References
[1] Kamel Alrashedy, Pradyumna Tambwekar, Zulfiqar Zaidi, Megan Langwasser, Wei Xu, and Matthew Gombolay, Generating cad code with vision-language models for 3d designs. ICLR, 2025.
[2] Autodesk, INC. Maya.
[3] Luigi Barazzetti. Parametric bs-built model generation of complex shapes from point clouds. Advanced Engineering Informatics, (0(3):28-311, 2016.
[4] Blender Development Team. Blender (version 3.1.0) [computer software], 2022.
[5] Ziang Cao, Fangzhou Hong. Tong Wu, Liang Pan, and Ziwei Liu. Large-vocabulary 3d diffusion model with transformer. In ICLR, 2024.
[6] Angel X Chang, Thomas Funkhouser, Leonidas Guibas, Pat Hanrahan, Qixing Huang, Zimo Li, Silvio Savarese, Manolis Savva, Shuran Song, Hao Su, et al. Shapenet: An information-rich 3d model repository. arXiv preprint 15x1v./51..03012, 2015.
[7] Rui Chen, Yongwei Chen, Ningxin Jiao, and Kui Jia. Fantasia3d: Disentangling geometry and appearance for high-quality text-to-3d content creation. ICCV, pages 22246-22256, 2023.
[8] Sijin Chen, Xin Chen, Anqi Pang, Xianfang Zeng. Wei Cheng, Yijun Fu, Fukun Yin, Billzb Wang, Jingyi Yu, Gang Yu, et al. Meshxl: Neural coordinate field for generative 3d foundation models. Advances in Neural Information Processing Systems, 37:97141-97166, 2024.
[9] Weize Chen, Yusheng Su. Jingwei Zuo, Cheng Yang, Chenfei Yuan, Chi-Min Chan, Heyang Yu, Yaxi Lu, Yi-Hsin Hung, Chen Qian, al. Agentverse: Facilitating multi-agent collaboration and exploring emergent behaviors. The Twelfth International Conference on Learning Representations, 2023.
[10] Xuweiyi Chen and Zezhou Cheng. Learning 3d representations from procedural 3d programs. arXiv preprint Xiv:2411 17467, 2024.
[11] Gheorghe Comanici, Eric Bicher, Mike Schackermann, Ice Pasupat, Noveen Sachdeva, Inderjit Dhillon, Mareel Blistein, Ori Ram, Dan Zhang, Evan Rosen, et al. Gemini 2.5: Pushing the frontier with ad- vaneed reasoning, multimodality, long context, and next generation agentic capabilities. arXiv preprint arXiv:2507.06261, 2025.
[12] Matt Deitke, Dustin Schwenk, Jordi Salvador, Luca Weihs, Oscar Michel, Eli VanderBilt, Ludwig Schmidt, Kiana Ehsani, Aniruddha Kembhavi, and Ali Farhadi. Objaverse: A universe annotated 3d objects. In CVPR, pages 13142-13153, 2023.
[13] Akio Doi and Akio Koide. An efficient method of triangulating equi-valued surfaces by using tetrahedral cells. IEICE TRANSACTIONS Information and Systems, 74(1):214-224, 1991.
[14] Yuhao Du Shunian Chen, Wenbo Zan, Peizhao Li, Mingxuan Wang, Dingjie Song, Bo Li, Yan Hu, and Benyou Wang. Bleuderlim: Training large language models for computer-aided design with self- improvement. arXiv preprint arXiv:2412.1 142003, 2024.
[15] Weixi Feng, Wanrong Zhu, Tsu-jui Fu, Varun Jampani, Arjun Akula, Xuchai He, Sugato Basu, Xin Eric Wang, and William Yang Wang. Layoutgpt: Compositional visual planning and generation with large language models. Advances in Neural Information Processing Systems, 36: 11882-112200 2023.
[16] Rao Fu, Jingyu Liu, Xilun Chen, Yixin Nie, and Wenhan Xiong. Scene-llm: Extending language model for 3d visual understanding and reasoning. arXiv preprint arXiv:2403.1 11011, 2024.
[17] Aaron Grattafiori, Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al- Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Alex Vaughan, et al. The Ilama 3 herd of models. arXiv preprint arXiv:2407.2178. 2024.
[18] Significant Gravitas. Autogpt, 2023.
[19] Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song. Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang. Xiao Bi, et al. Deepseek-rl: Incentivizing reasoning capability in llms via reinforcement learning, arXiv preprint a50iv: 12948, 2025.
[20] Zekun Hao, David W Romero, Tsung Yi Lin, and Ming-Ye Yu Liu. Meshtron: high-fidelity, artist-like 3d mesh generation scale, arXiv preprint Xxxv:2412.005544 2024.

---

[21] Jack Hessel, Ari Holtzman, Maxwell Forbes. Ronan Le Bras, and Yejin Choi. CLIPScore: a reference-free evaluation metric for image captioning, In EMNLP, 2021.
[22] Ziniu Hu, Ahmet Iscen, Aashi Jain, Thomas Kipf, Yisong Yue, David Ross, Cordelia Schmid, and Alireza Fathi. Scenecraft: An Ilm agent for synthesizing 3d scenes as blender code. In Forty-first International Conference on Machine Learning, 2024.
[23] Yukun Huang, Jianan Wang, Yukai Shi, Boshi Tang, Xianbiao Qi, and Lei Zhang. Dreamtime: An improved optimization strategy for diffusion-guides 3d generation. In ICLR, 2023.
[24] Aaron Jacch, Adam Kalai, Adam Lerer, Adam Richardson, Ahmed EI- El-Kishky, Aiden Low, Alec Hel- yar, Aleksander Madry, Alex Beutel, Alex Camey, et al. Openai system card. arXiv preprint arXiv:2412. 16720, 2024.
[25] Chenhan Jiang, Yihan Zeng, Tianyang Hu, Songcun Xu, Wei Zhang. Hang Xu, and Dit- Yan Yeung. Jointdreamer: Ensuring geometry consistency and text congruence in text-to-3d generation via joint score distillation. In ECCV, 2025.
[26] Juyong Jiang, Fan Wang. Jiasi Shen, Sungju Kim, and Sunghun Kim. A survey large language models for code generation. arXiv preprint 2400022400000555. 2024.
[27] R Kenny Jones, Theresa Barton, Xianghao Xu. Kai Wang. Ellen Jiang, Paul Guerrero, Niloy J Mitra, and Daniel Ritchie. Shapeassembly: Learning to generate programs for 3d shape structure synthesis. ACM Transactions on Gruphics (TOG), 1-(6):1220, 2020.
[28] Heewoo Jun and Alex Nichol. Shap-e: Generating conditional 3d implicit functions. arXiv preprint arXiv:2305.02463 2023.
[29] James T Kajiya. The rendering equation. In Proceedings of the 13th annual conference on Computer graphics and interactive techniques, pages 143-150, 1986.
[30] Bernhard Kerbl, Georgios Kopanas, Thomas Leimkühler, and George Drettakis. 3d gaussian splatting for real-time radiance field rendering. ACM Transactions on Graphics, 42(4): 14, 2023.
[31] Zeqiang Lai, Yunfei Zhao, Haolin Liu, Zibo Zhao, Qingxiang Lin, Huiwen Shi, Xianghui Yang. Mingxin Yang, Shuhui Yang. Yifei Feng. Sheng Zhang. Xin Huang. Di Luo, Fan Yang. Fang Yang. Lifu Wang. Sicong Liu, Yixuan Tang, Yulin Cai, Zehin Hc, Tian Liu, Yuhong Liu, Jic Jiang. Linus, Jingwei Huang, and Chunchao Guo. Hunyuan3d 2.5: Towards high-fidelity 3d assets generation with ultimate details, 2025.
[32] Yiyi Liao, Simon Donne, and Andreas Geiger. Deep marching cubes: Learning explicit surface repre- sentations. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 2916 2925, 2018.
[33] Chen-Hsuan Lin, Jun Gao, Luming Tang. Towaki Takikawa. Xiaohui Zeng. Xun Huang, Karsten Kreis, Sanja Fidler, Ming-Yo Liu, and Tsung- Yi Lin. Magic3d: High-resolution text-to-3d content creation. In CVPR, 2023.
[34] Gabrielle Littlefair, Niladri Shekhar Dutt, and Niloy J Mitra. Flairgpt: Repurposing Ilms for interior designs. arXiv preprint arXiv:2501.048 2025.
[35] Xinhang Liu, Chi-Keung Tang, and Yu-Wing Tai. Worlderaft: Photo-realistic 3d world creation and customization via I1m agents. arXiv preprint arXiv:2502.15601 2025.
[36] Zhaoyang Liu, Yinan He, Wenhai Wang, Weiyun Wang. Yi Wang. Shoufa Chen, Qinglong Zhang, Yang Yang, Qingyun Li, Jiashuo Yu, Kunchang Li, Zhe Chen, Xue Yang. Xizhou Zhu, Yali Wang. Limin Wang. Ping Luo, Jifeng Dai, and Yu Qiao. Internchat: Solving vision-centric tasks by interacting with chatbots beyond language. https: //ar:////xxvv argg/bss/3300
2023.
[37] William E. Lorensen and Harvey E Cline. Marching cubes: A high resolution 3d surface construction algorithm. In Seminal graphics: pioneering efforts that shaped the field, pages 347-353. 1998.
[38] Sanwal Manish. An autonomous multi-agent Ilm framework for agile software development. International Journal of Trend in Scientific Research and Development, 8(5):892 298, 2024.
[39] Ben Mildenhall, Pratul P Srinivasan, Matthew Tancik, Jonathan T Barron, Ravi Ramamoorthi, and Ren Ng. Nerf: Representing scenes as neural radiance fields for view synthesis. Communications of the ACM, 65 (1):99 106, 2021.
12

---

[40] Daye Nam, Andrew Macvean. Vincent Hellendoorn, Bogdan Vasilescu. and Brad Myers. Using an Ilm to help with code understanding. In Proceedings of the IEEE/ACM 46th International Conference on Software Engineering, pages 1-13, 2024.
[41] R OpenAl. Gpt-4 technical report. arxiv 2303.08774. View in Article, 2(5), 2023.
[42] Jeong Joon Park, Peter Florence, Julian Straub, Richard Newcombe, and Steven Lovegrove. Deepsdf: Learning continuous signed distance functions for shape representation. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 165 174, 2019.
[43] Ben Poole. Ajay Jain, Jonathan T Barron, and Ben Mildenhall. Dreamfusion: Text-to-3d using 2d diffusion. In ICLR, 2023.
[44] Chen Qian, Xin Cong. Cheng Yang, Weize Chen, Yusheng Su, Juyuan Xu, Zhiyuan Liu, and Maosong Sun. Communicative agents for software development. arXiv preprint arXiv:2307.0992 6(3), 2023.
[45] Jie Qin, Jie Wu, Weifeng Chen, Yuxi Ren, Huixia Li, Hefeng Wu, Xucfeng Xiao, Rui Wang. and Shilei Wen. Diffusiongpt: LIm-driven text-to-image generation system. arXiv preprint arXiv:2401.1000 2024.
[46] Leigang Qu, Shengqiong Wu, Hao Fei, Liqiang Nie, and Tat-Seng Chua. Layoutlmm-12i: Eliciting layout guidance from Ilm for text-to-image generation. In Proceedings of the 31st ACM International Conference on Multimedia, pages 643-654, 2023.
[47] Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. Learning transferable visual models from natural language supervision. In International conference on machine learning, pages 8748-8763. PMIR, 2021.
[48] Zeeshan Rasheed, Muhammad Waseem, Mika Saari, Kari Systä, and Pekka Abrahamsson. Codepori: Large scale model for autonomous software development by using multi-agents. arXiv e-prints, pages 2024.
[49] Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, and Bjöm Ommer. High-resolttion image synthesis with latent diffuusion models. In CVPR, pages 10684-10695, 2022.
[50] Yongliang Shen, Kaitao Song, Xu Tan, Dongsheng Li, Weiming Lu, and Yueting Zhuang. Hugginggpt: Solving tasks with chatgpt and its friends in hugging face. Advances in Neural Information Processing Systems, 36:381544 144-88888,, 2023.
[51] Yichun Shi, Peng Wang, Jianglong Ye, Mai Long, Kejie Li, and Xiao Yang. Mvdream: Multi-view diffusion for generation. In ICLR, 2024.
[52] Sankalp Sinha, Mohammad Sadil Khan, Muhammad Usama, Shino Sam, Didier Stricker, Sk Aziz Ali, and Muhammad Zeshan Afzal. Marvel-40m+:: Multi-level visual claboration for high-fidelity text-to-3d content creation. arXiv preprint arXiv:2411.17945 2024.
[53] Chunyi Sun, Junlin Han, Weijian Deng, Xinlong Wang, Zishan Qin, and Stephen Gould, 3d-gpt: Procedural 3d modeling with large language models, 2024.
[54] Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie Anne Lachaux, Timothée Lacroix, Baptiste Rozière, Naman Goyal, Eric Hambro, Faisal Azhar, et al. Llama: Open and efficient foundation language models. arXiv preprint arXiv: 13971, 2023.
[55] Aaron Van Den Oord, Oriol Vinyals, et al. Neural discrete representation learning. Advances in neurul information processing systems, 30, 2017.
[56] Zhenyu Wang, Aoxue Li, Zhenguo Li, and Xihui Liu. Genartist: Multimodal I1m as an agent for unified image generation and editing. Advances in Neural Information Processing Systems, 2024.
[57] Zhengyi Wang, Jonathan Lorraine, Yikai Wang, Hang Su, Jun Zhu, Sanja Fidler, and Xiaohui Zeng. Llama-mesh Unifying 3d mesh generation with language models. arXiv preprint arXiv:2411.099 2024.
[58] Zhengyi Wang, Cheng Lu, Yikai Wang, Fan Bao, Chongxuan Li, Hang Su, and Jun Zhu. Prolificdreamer: High-fidelity and diverse text-to-3d generation with variational score distillation. In NewrIPS, 2024.
[59] Karl DD Willis, Yewen Pu, Jieliang Luo, Hang Chu, Tao Du, Joseph G Lambourne, Armando Solar- Lezama, and Wojciech Matusik. Fusion 360 gallery: A dataset and environment for programmatic cad construction from human design sequences. ACM Transactions Graphics (TOG), 1-,4, 2021.
13

---

[60] Rundi Wu, Chang Xiao, and Changxi Zheng. Deepcad: A deep generative network for computer-aided design models. In Proceedings of the IEEE/CVF International Conference Computer Vision, pages 6772-6782, 2021.
[61] Shirley Wu. Shiyu Zhao, Qian Huang, Kexin Huang, Michihiro Yasunaga. Kaidi Cao, Vassilis loannidis, Karthik Subbian, Jure Leskovec, and James Y Zou. Avatar: Optimizing Ilm agents for tool usage contrastive reasoning. Advances in Neural Information Processing Systems, 37:25981-26010, 2024.
[62] Yutaro Yamada, Khyathi Chandu, Yuchen Lin, Jack Hessel, llker Yildirim, and Yejin Choi. L3go: Language agents with chain-of of aaf-3d-thore sd-thoughts for generating unconventional objects. arXiv preprint arXiv:2402.09055 2024.
[63] Yue Yang, Fan-Yun Sun, Luca Weihs, Eli VanderBilt, Alvaro Herrasti, Winson Han. Jiajun Wu, Nick Haber, Ranjay Krishna, Lingjie Liu, et al. Holodeck: Language guided generation of 3d embodied ai environments. In Proceedings the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 16227-16237, 2024.
[64] Jonathan Young. xatlas: Mesh parameterization / uv unwrapping library. httpa://github.cem jpcy/ xatlas 2025.
[65] Zeqing Yuan, Haoxuan Lan, Qiang Zou, and Junbo Zhao. 3d Ad-premise: Can large language models generate shapes with sharp features and parametric control? arXiv preprint arXiv:2401.064 2024.
[66] Zeqing Yuan, Haoxuan Lan, Qiang Zou, and Junbo Zhao. 3d-premise: Can large language models generate 3d shapes with sharp features and parametric control?, 2024.
[67] Shougao Zhang. Mengqi Zhou, Yuxi Wang. Chuanchen Luo, Rongyu Wang. Yiwei Li, Zhaoxiang Zhang, and Junran Peng. Cityx: Controllable procedural content generation for unbounded 3d cities. arXiv preprint 24v: 17572, 2024.
[68] Mengqi Zhou, Yuxi Wang, Jun Hou, Shougao Zhang, Yiwei Chuanchen Luo, Junran Peng, and Zhaoxiang Zhang, Scenex: Procedural controllable large-scale scene generation. Proceedings of the AAAI Conference on Artificial Intelligence, pages 10806-108 14, 2025.
14

---

NeurIPS Paper Checklist
1. Claims
Question:
Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?
Answer: [Yes]
Justification: we present a training-free free LLM-assisted pipeline to automatically produce structured, interactive and textured 31D shape. The title, abstract, introduction and contribu- tion summary are aligned with this contribution.
Guidelines:
The answer NA means that the abstract and introduction do not include the claims made in the paper.
The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or
NA answer to this question will not be perceived well by the reviewers.
The claims made should match theoretical and experimental results, and reflect how much the results
be expected generalize to other settings.
It is fine to include aspirational goals as motivation long it is clear that these goals are not attained by the paper.
2. Limitations
Question:
Does the paper discuss the limitations of the work performed by the authors?
Answer: [Yes]
Justification:
We create separate section for the discussions on limitations.
Guidelines:
The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper.
The authors are encouraged to create a separate "Limitations" section in their paper.
The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g.. independence assumptions, noiseless settings, model well-specification. asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be.
The authors should reflect on the scope of the claims made, c.g. the approach was only tested a few datasets with few runs. In general, empirical results often depend on implicit assumptions, which should be articulated.
The authors should reflect on the factors that influence the performance of the approach. For example, facial recognition algorithm may perform poorly when image resolution low or images are taken in low lighting. Or a speech-to-text system might be used reliably to provide closed captions for online lectures because it fails to handle technical jargon.
The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size.
applicable, the authors should discuss possible limitations of their approach to address problems of privacy and faimess.
While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, a worse outcome might be that reviewers discover limitations that aren't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor transparency play important role in developing norms that preserve the integrity of the commu- nity. Reviewers will be specifically instructed to not penalize honesty concerning limitations.
3. Theory assumptions and prool's
Question: For each theoretical result, does the paper provide the full set of assumptions and complete (and correct) proof?
15

---

Answer:
[NA]
Justification:
Does not involve theory.
Guidelines:
The answer NA means that the paper does not include theoretical results.
All the theorems, formulas, and proofs in the paper should be numbered and cross- referenced.
All assumptions should be clearly stated or referenced in the statement of any theorems.
The proof' can either appear in the main paper or the supplemental material, but they appear in the supplemental material, the authors are encouraged to provide short proof sketch to provide intuition.
Inversely, any informal proof provided in the core of the paper should be comple- mented by formal proofs provided in appendix or supplemental material.
Theorems and Lemmas that the proof relies upon should be properly referenced.
4. Experimental result reproducibility
Question: Does the paper fully disclose all the information needed to reproduce the main ex- perimental results of the paper to the extent that affects the main claims and/or conclusions of the paper (regardless whether the code and data are provided or not)?
Answer: [Yes]
Justification:
We provide implementation details in the main paper and the appendix.
Guidelines:
The answer NA means that the paper does not include experiments.
If the paper includes experiments, No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not.
If the contribution is dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable.
Depending on the contribution, reproducibility can be accomplished in various ways. For example, if the contribution a novel architecture, describing the architecture fully might suffice, or if the contribution is specific model and empirical evaluation, it may be necessary to either make possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also provided via detailed instructions for how to replicate the results, access to a hosted model (e.g.. in the case of a large language model), releasing of a model checkpoint, or other means that appropriate to the research performed.
While NeurIPS does not require releasing code, the conference does require all submissions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example
(a) If the contribution is primarily a new algorithm, the paper should make clear how reproduce that algorithm.
(b) If the contribution is primarily new model architecture, the paper should de- scribe the architecture clearly and fully.
(c) If the contribution should either be way to access this model for reproducing the results or way to reproduce the model (e.g., with an open-source dataset or instructions for how to construct the dataset).
new model (e.g., large language model), then there
(d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome to describe the particular way they provide for reproducibil- ity. In the case of closed-source models, it may be that access to the model is limited in some way (e.g., to registered users), but should be possible for other researchers to have some path reproducing verifying the results.
5. Open access to data and code
16

---

Does the paper provide open access to the data and code, with sufficient instruc- tions faithfully reproduce the main experimental results, as described in supplemental material?
Question:
Answer: [No]
Justification:
will be released after acceptance.
Guidelines:
The answer NA means that paper does not include experiments requiring code. cc/
Please see the NeurIPS code and data submission guidelines
for more details.
While we encourage the release of code and data, we understand that this might not be possible, so "No" is an acceptable answer. Papers cannot be rejected simply for not including code, unless this central to the contribution (e.g., for a new open-source benchmark).
The instructions should contain the exact command and environment needed to run to reproduce the results. See the NeurlPS code and data submission guidelines (https hatsscccpbblc/uuiie
dttp/eee//oooeubmmii CodeSubmi onnolicy for more details.
The authors should provide instructions on data access and preparation, including how access the raw data, preprocessed data, intermediate data, and generated data, etc.
The authors should provide scripts reproduce all experimental results for the new proposed method and baselines. If only a subset of experiments are reproducible, they should state which ones are omitted from the script and why.
At submission time, preserve anonymity, the authors should release anonymized versions (if applicable).
Providing as much information as possible in supplemental material (appended to the paper) is recommended, but including URLs data and code is permitted.
6. Experimental setting/details
Question: Does the paper specify all the training and test details (e.g., data splits, hyper- parameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?
Answer: [Yes]
Justification:
They described in the experiment section and more details in appendix.
Guidelines:
The answer NA means that the paper does not include experiments.
The experimental setting should be presented in the core of the paper a level of detail that is necessary to appreciate the results and make sense of them.
The full details can be provided either with the code, in appendix, or supplemental material.
7. Experiment statistical significance
Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?
Question:
Answer: [Yes]
Justification:
We report results on part of an open public dataset objaverse.
Guidelines:
The answer NA means that the paper does not include experiments.
The authors should answer "Yes" if the results are accompanied by error bars, con- fidence intervals, statistical significance tests, least for the experiments that support the main claims of the paper.
The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall run with given experimental conditions).
17

---

The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap. etc.)
The assumptions made should be given (e.g., Normally distributed errors).
It should be clear whether the error bar is the standard deviation or the standard emror the mean.
It is OK to report 1 I-sigma error bars, but one should state it. The authors should preferably report 2-sigma error bar than state that they have a 96% CI, if the hypothesis of Normality of errors is not verified.
For asymmetric distributions, the authors should be careful not to show in tables or figures symmetric error bars that would yield results that are out of range (e.g. negative error rates).
error bars are reported in tables or plots, The authors should explain in the text how they were calculated and reference the corresponding figures tables in the text.
8. Experiments compute resources
For each experiment, does the paper provide sufficient information on the puter resources (type of compute workers, memory, time of execution) needed to reproduce the experiments?
Question:
Answer: [Yes]
Justification:
We check the list and do not find any contradiction.
Guidelines:
The answer NA means that the paper does not include experiments.
The paper should indicate the type of compute workers CPU GPU, internal cluster, or cloud provider, including relevant memory and storage.
The paper should provide the amount of compute required for each of the individual experimental runs as well as estimate the total compute.
The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't it make it into the paper).
9. Code of ethics
Question: Does the research conducted in the paper conform, in every respect, with the NeurlPS Code of Ethics
Answer: [Yes]
Justification: we check the list and do not find any contradiction.
Guidelines:
The answer NA means that the authors have not reviewed the NeurIPS Code of Ethics.
the authors answer No, they should explain the special circumstances that require deviation from the Code of Ethics.
The authors should make sure to preserve anonymity (e.g.. there is a special consideration due to laws regulations in their jurisdiction).
10. Broader impacts
Question: Does the paper discuss both potential positive socictal impacts and negative societal impacts of the work performed?
Answer: [Yes]
Justification:
is discussed in the appendix due to limit of space in the main text.
Guidelines:
The answer NA means that there is societal impact of the work performed.
If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact.
18

---

Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance). fairness considerations (e.g.. deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations.
The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, is legitimate point out that improvement in the quality of generative models could be used to generate deepfakes for disinformation, On the other hand, is not needed to point out that generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster.
The authors should consider possible harms that could arise when the technology is being used intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional unintentional) misuse of the technology.
If there are negative societal impacts, the authors could also discuss possible mit- igation strategies (e.g.. gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms monitor how system learns from feedback over time, improving the efficiency and accessibility of ML).
11. Safeguards
Does the paper deseribe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?
Question:
Answer: [NA]
Justification: Our paper focuses on simplifying the artist modeling workflow.
Guidelines:
The answer NA means that the paper poses no such risks.
Released models that have high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines restrictions to access the model or implementing safety filters.
Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images.
We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make a best faith effort.
12. Licenses for existing assets
Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected?
Answer: [Yes]
Justification: cited.
Guidelines:
The answer NA means that the paper does use existing assets.
The authors should cite the original paper that produced the code package dataset.
The authors should state which version of the asset used and, if possible, include URL.
The name of the license (e.g., CC-BY 4.0) should be included for each asset. For scraped data from a particular source (e.g.. website), the copyright and terms of service of that source should be provided.
assets are released, the license, copyright information, and terms of use the pack- age should be provided. For popular datasets, paperswi thcode. com com/datasets has curated licenses for some datasets. Their licensing guide can help determine the license of dataset.
19

---

For existing datasets that are ee-pakaaedd both the original license and the license of the derived asset (if it has changed) should be provided.
If this information not available online, the authors are encouraged to reach out to the asset's creators.
13. New assets
Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?
Answer: [NA]
Justification: [NA]
Guidelines:
The answer NA means that the paper does not release new assets.
Researchers should communicate the details of the datasee/code/model as part of their submissions via structured templates. This includes details about training, license, limitations, etc.
The paper should discuss whether and how consent was obtained from people whose asset used.
At submission time, remember to anonymize your assets (if applicable). You can either create anonymized URL include anonymized zip file.
14. Crowdsourcing and research with human subjects
Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well as details about compensation (if any)?
Answer: [NA]
Justification: [NA]
Guidelines:
The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.
Including this information in the supplemental material is fine, but if the main contribution of the paper involves human subjects, then as much detail as possible should be included in the main paper.
According the NeurIPS Code of Ethics, workers involved in data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector.
15. Institutional review board (IRB) approvals or equivalent for research with human subjects
Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or equivalent approval/review based the requirements of your country or institution) were obtained?
Answer: [NA]
Justification: [NA]
Guidelines:
The answer NA means that the paper does not involve crowdsourcing nor research
with human subjects.
Depending the country in which research is conducted, IRB approval (or equiva-
lent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper.
We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the NeurIPS Code of Ethics and the guidelines for their institution.
For initial submissions, not include any information that would break anonymity (if applicable), such as the institution conducting the review.
20

---

16. Declaration of LLM usage
Question: Does the paper describe the usage of LLMs if it is an important, original, or non-standard component of the core methods in this research? Note that if the LLM is used only for writing, editing, or formatting purposes and does not impact the core methodology. scientific rigorousness, originality of the research, declaration is not required.
Answer: [Yes]
Justification: we propose LLM agents for automatically 3D modeling. We design a LLM friendly representation and self-correction mechanism.
Guidelines:
The answer NA means that the core method development in this research does not involve LLMs as any important, original, or non-standard components.
Please refer to our LLM policy (https:/ /tapa:///eurippee ips. cc/Coofferences/2225//11.. for what should should not be described.
21

---

A Appendix
This supplementary material consists of five parts, including technical details of the experiment and evaluation (Sec. B). additional ablation analysis (Sec. C additional quality results (Sec. D) and the prompts design (Sec. E
B Technical Details
Experiment Details. Apart from set-up discussed in Section we provide the following additional details: set uniform sampling temperature of 0.5 across all L.M and VLM queries, allowing up to three retries in terms of network failure; the visual evaluation score is ranged from O to 10 and an carly-stopping threshold of 9 is applied: we allow up one update of the GPS representation G during representation bootstrapping, effectively setting N = 1. Beyond shape modeling, bounding volume generation during GPS representation initialization also undergoes iterative update process by the Coder agent. For this part, we set M = and T = 3 for its iterative refinement. To provide visual feedback, we render bounding boxes, component shapes and global shapes from preset camera angles 2 three-quarter views from front-left and front-right, and top-down view from the rear.
Evaluation Setup. All evaluations performed the exported meshes. We benchmark 26
long-form functional prompts from MARVEL-40M+ [52), itself derived from Objaverse [12]. To
quantify mesh fidelity, we report Intersecttoon-vve--Gruu-----
(IoGT) and Hausdorff Distance (HD) against both sampled point clouds between ground-truth meshes and generated meshes, following M. For text-3D aligmment, we adopt the CLIP ViT-B/32 [47] as the feature extractor and average the CLIPScore [21] across ten rendered views. We also introduce VQA-based alignment metric: for each prompt, author five yes/no/unelear questions, render multi-view images for each method, and compute VQA pass rate by querying a disual-language model on those questions.
venta
rablan
Mosh
Testured Madel
Biox Frome
Bãox
Flg
Gio Gdl
light (MG)
leght. INpe
mach quinc)
Wodk
H7
Figure 8: Example of GPS representation for commercial airplane.
22

---

Wrapped Blender Libraries. To constrain the LLM agent's action space, we craft suite of thin- min-wrapper methods atop the Blender API that encapsulate frequently used operations, of which the documentation and method signature is illustrated as Prompt 7 The resulting utility library significantly narrows the API surface the L.M must explore.
C
Additional Ablation Analysis
Showcase of GPS Representation. We illustrate sample GPS representation for commercial airplane in Figure g The visualization highlights the hierarchical layers and leaf nodes; for se- lected components, we annotate their geometric parameters, bounding-volue volume descriptions, and the corresponding shape-generation code (including both modeling and bounding-box routines).
Bootstrapped Update of GPS representation. We show the effectiveness of representation bootstrapping through one example in Figure For the initial graph representation, the agent intend to model two fridge doors together, which a valid design decision however, when it tries to set the height of the handle bar, there is no clear indication of where it should go, as the gap between two door panels not set until the node modeling phases. This may result in mismatched handle bar position and can only be corrected during global optimizations. Our bootstrapped representation spots and solves this issue via a more detailed shape decomposition, modeling two door panels separately and thus the handle bar has set height independent of subsequent shape modeling processes, guaranteeing a valid shape. At the same time chooses to model each face of the fridge body individually, allowing for more detailed features to be presented.
The Effectiveness of Iterative Shape Modeling. Figure5aalraad presents additional examples of iterative refinement, in addition, Figure I0 illustrrae the impact of our global-update procedure, showing how a pronounced axis misalignment automatically corrected in subsequent refinement steps.
Ablation Study on Wrapped Library. By providing our coding agent with wrapper methods library and its documentation, we observe that the code generated is significantly shorter and without most boilerplate code, thus more context length will be available for holding reasoning content instead of repeated Blender Python code. This is visualized in Figure II with single node generation task.
Ablation Study on Hierarchical Shape Parsing. To study the effectiveness of hierarchical shape parsing procedure, we carry out controlled experiments to compare the performance of our pipeline with and without hierarchical parsing step on a small set of marvel [22 functional prompts. For the base parsing method without hierarchical parsing, the agent is prompted to produce the final node listing directly without decomposing the shape into hierarchical layers first. Specifically, removing hierarchical shape parsing damaged mesh generation quality in all aspect, including VQA pass rate, point cloud distance and intersection over ground truth. The result shown in Table
Fridge: A tall, upright rectangular box with smooth, flat surfaces Two thinner rectangles form the doors, stacked vertically one for the fridge, one for the freezer A subtle horizontal groove separates them and serves handle:
Fridge body Door panels Handle
Fridge cabinet Faces Freezer door Handle
Fridge door
Updated Graph & Bounding
Figure 9: Impact of bootstrapped graph structure and bounding volumes component alignment. By anchoring the handle node to the positions of both door panel nodes, the model avoids height discrepancies that arise when panels and handle generated independently with arbitrary gaps.
23

---

MeginiMeli
Sefieed Mesh
Fing e buei pulitters smatt
Lid saucieg stag sai Cerrtsal)
Cod callngg Agent
Seippet
The dinuctural innegiity compecmtion oue to the salignntent of the taeding mag rotetook, rega shroud lireed dbes not nolirlegrae them property with rotetick sioucuue.
bum.
Feodback
Original
Figure 10: Showcase of global update step solving an axis alignment issue.
Standing Lamp cylindeical lamp shode top
thane sucettry
destartio
56
guevtry
the wite
boote hertosnnally
ryltater befull pa
Treecate salonde puiiion O. Farm marsetee
colare digllyy rementy
Kith library
Withost library
Figure 11: Comparison of code generated with and without library method provided.
Table 4: Comparison of ShapeCraft performance with and without hierarchical parsing.
Method
VQA Pass Rate
Hausdorff Distance..
ToGT
No Hicrarchical Parsing
0.48
0.564
0.297
ShapeCraft
0.56
0.447
0.396
D Additional Qualitative Results
From components to global mesh. Figure 12 illustrates example shape modeling workflow of ShapeCraft, from iterative updates of individual node shapes, to fitting them into corresponding bounding volumes and obtaining the global raw mesh. Note also the effectiveness of our iterative shape modeling pipeline, updating the Wi-Fi antenna to "slightly angle outward" and fixing the model clipping issue for the buttons.
CAD modeling. Although not designed specifically for CAD modeling, ShapeCraft can accept CAD modeling prompts and model typical CAD shapes either as entire shape program or component geometry, as shown in Figure 13
Post- post-modeling shape editing. To showcase the advantage of our shape program representation, we provide an example of prompting agents further based on more shape editing requests based on existing shape program in Figure 14

---

with aedl, raad buttow cot reult spiniit LEP indlueer Firs ancerts in dki opiiaric and seteeted loo from belod evetly rpieed quort
Antenno
2sl
Buttons
ECC
LED
Base
Figure 12: Illustration of the iterative modeling workflow of ShapeCraft using the Wi-Fi rotter example.
Nlhened cuba, 40me per ride with 5mm files edger
ballow oy sylinder with sn ouber dimmter of tonur diameter of 30mm, beight
recharpslor bor with dimensions 60mm 90mm 20mm, foataring ciraler hols of 10me through
bright-
Figure 13: Qualitative CAD Modeling Results: ShapeCraft demonstrates generalizability CAD modeling tasks despite not being designed specifically for CAD modeling, benefiting from the fact that CAD shapes relatively sipmler than daily objects but require higher precision note that our system does not incorporate accurate measurements into the feedback loop so may produce suboptimal CAD designs.
</>
shape progran
Given the followäng
that generates "A
vertitally positioned
o', please modify user request: Reduce number setal rings
the retal binding
binding, rings" paraneter updated. SpectFically, change Modifiers.ande call from 5 to 3, Hore's the aodified version of that function: python
anay nottiiee renate rinos aith prosee serttest sparing countrs,
Updated shape progran
Figure 14: Example post-modeling shape editing conducted by prompting LLM with existing shape programs directly.
Integration with native generation methods. As mentioned the limitations (Section 5). ShapeCraft struggles in modeling shapes with highly complex topology organic details, however, this can be mitigated by delegating certain tasks native generation methods which are more suitable to express these geometric features in this way, ShapeCraft is still advantageous in terms of
25

---

drasonfly
With and wing generated by Hunywan3D
ShapaCraft
Figure 15: Example of using native 3D generation methods as local shape modeling tool to handle complicate, complex and organic shapes.
scalability due to shape decomposition in the GPS representation. We show in Figure 13 an example where the modeling of a dragonfly's 's head and wings are done by calling an external API, Hunyuan3D [1], and then fitted to corresponding bounding boxes in the GPS.
Showcase of ShapeCraft workflow. As part of our workflow, an example chat history of shape modeling task for single node constructed in Figure [T] where we showease how error messages are propagated for bug fixes and how visual feedback is applied.
Single shape nodeling task:
"rode_rame": cyiinder""
"tees decorpptiio" Myliadicca voluse costaned above the stee, radiee sotes, helght J
srita, positioned botton 2120.1, ortanted tericostally (retated degress around aada)"
laep
cylindeel
cylinder"" pasitionsiCs 5, 10.1) sotton of the shade at 2010.1
codting agent:
mutatfnse(S, 1.5085, 10, Retate on degnees around moauts to artent
asaten(3, 2, 12, * Radiua of 3 unita on and y. height nermalized =
adee defailt height
vorticaen1>,
depthez Height
blender
Your code produced the folloving error message in Blender:
fixing
see enror there was conrected code:
Here*' s the
soding agent:
blender
provided images your
to provide evaluation and feedback for
("criterion"s "Structural Integrity. "score": "Feebbckk" "The structural composition
evaluation agent:
You need to Isprove code snippet based on evaluation feedback on generation
steps
python adjust the
coding agent:
blender
provided with the images and your task is provide evaluation and feedback for
ovaluation agent:
("criterion..
Figure 16: Example chat history for individual shape modeling task.
E
Prompts Design
provide selection crucial prompts to our pipeline. Specifically, prompt is for shape parsing, prompt and 3 for bootstrapping shape representation. Prompt 4 shows the instruction of generating shape program as bounding boxes based on DAG (an alias for our graph-based representation), and prompt [ shows the evaluation criteria used in visual feedback for all shape program generation
26

---

tasks, For node generation. we use the instruction shown as prompt 6 and provide it with the wrapper method library documentation attached as prompt 7
Prompt 1: Hierarchical Shape Parsing
Given shape description, decompose the shape into hierarchical representation whore upper layers are semantic sactions and lover down is actual physical conpenents that representation in a Directed Acyyeli Graph format with purely lesf nodes, accompanied
30 modelad.
hierarchical
bounding volume. You may to help your group the layers at first, but in the fimal made representations, corraspanda actual 3D models. Nake
descriptions
concepte
please thinge that not be represented properly ao that thay are suitable for use as Python nethod names direstly. The DAG should
every
physical companent, not concepts or you nodes
Return only wrapped jsonl code block that containe all the jaonl lines. When there are repeated mirrored elements, please greup conbined hounding volume as rell as their shared individual shape do not enumerate create lot of nodes.
represents
together
their
Use the follaving fornat:
the hierarchical layers root: <section 1 name?, <gection 2 name>... <section name>:
name?,
<oubsection nane>: <actual physical component name?...
<section
vritten conpenent_nane which is suitable for use as Python method nanes directly) sssjoon
representatione: (note "Copponnent
("node*: <component_nanee manee
deaape_description <ahape description>,
bbounding.volume" <description its position, orientation and size, etc.>
Shape: <shape deacription>
Prompt 2: Visual Feedback for Bootstrapping GPS
python script has been generated with respect to the nodes in your DAG representation that generates bounding boxes fer each node, and the generated bounding boxes has been rendered into an inage with different colours. Please try sdentifying issues relationchips, etc.) and provide feedback on how could the DAG be improved.
your DAG decomposition (a.g. missing
incorrect
Bounding Box Colours
ccolor nappinge>
Your Feedback
Prompt 3: Updating Shape Representation
pythen acript has been generated with respect to the nodes in your DAG regresentation
generates bounding boxes generated by looking at these bounding boge regarding hov to improve the DAG. Please provide an updated D&G representation in the sane hierarchical layers +> Jaonl nodes fornst regarding the feedback. Please return the full updated DAG instead of just the changed parts.
Feedback
cieedback>
Your Updated DAG Representation
27

---

Prompt 4: Bounding Box Generation (without boilerplate formatting instructions)
Bounding Box Generation Instruction
You given shape description
object and Directed Acyclic Grapa rapresentation af the object's componenta and their relationshipa Each nade in the object, and is acconpanied with deacriptions
the DAG represente component of their shape and bounding volune. Your task is write Python nethods for each node that generates a descriptions defined in suitable bounding bex based on the bounding volume whole and alvays ganerate only
each node one single bounding box in each node's method. when node contains repeated instances, follov bounding that contains all of then. Focus geonetry and ignore other properties 11ke texture or materisl in the shape description.
instructione generate single bounding
You may use the folloving erapper methed directly to create cube as bounding box: cecubb_bonnding.b (orandn (nane="node_
position=(D, 0), acala=(1, x)) Generates cube. The tuples are in x-y-2 order and 2-axia pointa upward. Paraneter use the suffix it with "_bbox", returns the object reference of the created cube and make sure you retura too.
mame
Prompt 5: Evaluation Criteria (For bounding boxes, the visual quality criterion is removed
(significant
score generally acceptable
perfect examples score 10):
srStructural Integrity*::
generated shape structurally sound?
miasing broken parta?
**Geonetric Rccuracy**: Does the generated shape accurately represent the geonetric properties of the node? Are the dimensions and proportions correct? **Alignnent with Deacriptions:: Does the generated shape match the description provided in
Code Validity Does the code work intended, that you can locate and make sanse betueen the *4Visual Quality*e: How visually appealing is the generated shape? Does it look realistic and vell forned?
ganerated shape?
Prompt 6: Node Shape Program Generation
Python nethod create shape Blender. Specifically, object has been decomposed into Directed Acyclic Graph (DAG) representation and you are charge of writing the code for a specific node in the DAG. The node represents component of the object and cones with descriptions and its bounding volune, and you need to create the geonetry for that companent only reprasentation
need
its
shape
You will ba given the overall shape description of the node you are vorking on. Note that you don 't need to adjust poeitione based aftervards. Your code can use set of vrapper nethods to create shapes and apply modifiers, their documentation is provided belov. Focus on geonetry and ignore other properties like texture naterial in the shape description.
object along with the
bounding volunes,
autonatically
28

---

Prompt 7: Wrapped Blender Libraries
Gonerates cube. cube (name, (o,))))n=00;,,0),, (t, (c,1e=(1,1,1))
Creates WV-aphere with customizable sagnenta and rings. sphere positien-(0,0,00 rotation-(O,000) scale=(1,1,1), s8gmente=32, rings-16)
Adda cylinder with adjustable cylinder (name, (paition=(0,0,000 rofation=(0,0,0) scale=(1,1,1), vertices-32, depth-2)
and height.
Creates cone with apecified base radius, height, and vertex count. cone (name, position=(0.0.0)) (0tation=(O,0.0) (cale= vertices-32, radius=1, depth-2)
Adda plane with adjustable size. plane positien- t0t,)ion=(0,0..),. sc,1e=(1,1,1), size-2)
fill_cape closes top/botton when beveling. bezier_curva (name, points, bevel_depth extrade=0.0, capl.cps=aaaaee to_neab=True)
Creates 3D Bezier
with specified caanee (00,tion((0,0,0), radius=1.0, segnents=32, bovel_depth-O.0, extrude=O.O, to_mech-True)
Generates
and resolution.
Creates atraight - line segmanta. cloaed links enda; rill_caps closes enda. polyline (name, pointe, closed-False, berel_depth-0.0, extrude=0.0,, fill_caps=Palse, to_mesh-True)
# Cenerates 30 text with LEFT, CENTER, or RIGHT alignnent. text (name, text="Text", location=(O,0,0) size=1.0, align=>CENTER', extruda=0.0, bevel_depth=0.0, to_nesh-frue)
square-bared pyramid vertex pyramiddaane. position=(0,0.00) 100atica=(0,,,00) scale-(1,1,1). base_size=2, height-2)
Creates capsule by combining henispheres and a cylinder. (name, positiin=(0,00) (0,0,0), rotation=(0,0,0)) sc,le-(1,1,1), radius-1, height-2, segnente-32)
Gonerates an n-sided prism configuring cylinder. prism (name, posttion=(0,0,00) rotation=(0,0,00) scale=(1,1,1), sides-3, radiua-i, height-2)
Perforus TATNRSCCT//ITOODDIEEEEER Modifiers modifiers.bbolleee (objes, obj_b, perstion-"DIFFEREK remove-True)
a Adds subdivision modifier; levels for viesport, render_levell for render.
Modifiera. (obb) lavela=2, render_lavelsse,
Adda havel modifier; affect=EDGES or VERTICES. Modifiers. bevel (obj, width-0.1, segnents-3, EEDGGE=)EDGES")
Duplicates object linearly Modifiera. array (obj, count=b, oelattve_offset=(12.. 0, 0))
Nirrors object scrose X/1/Z axes; use_clip prevents crossing plane.
Modifiers Hodifiers.airror (abj. (True, False, False), cre_clip=True)
mirror
a Deforms obj along curve_ab] Modifiers. currerrsccurcoooooooe (ob), curve_obj, drform_ariss
solidity: Adda thickness to mesh. califiers.eolidie. (obj, thickness-0.2)
to_nesh: Applies modifiers and Modifiers. Hodifiore.to_nethhe (obb)
29


Reviews:
[{"review_id": "2Gvyixo4ys", "reviewer": "Reviewer_nYcR", "summary": "This paper introduces ShapeCraft, an LLM agent system that generates structured, textured, and interactive 3D models from text. Its core innovation is a Graph-based Procedural Shape (GPS) representation, where an LLM decomposes an object into a graph of components, each defined by a description, bounding box, and a procedural code snippet. An agentic workflow with Vision-Language Model (VLM) feedback iteratively generates and refines the geometry for each part. The resulting models are well-aligned with the prompt, structured, and editable, a significant advantage over existing methods. Experiments show ShapeCraft outperforms a range of text-to-3D approaches.", "questions": "- During the initial GraphInit phase, how are the bounding boxes (Bi) for each component determined? Does the LLM generate numerical coordinates and dimensions, and if so, how does it reason about the spatial coherence of the overall layout before the VLM-based bootstrapping step?\n- Could you elaborate on the design of the Blender Wrapper Library? For instance, what level of abstraction does it provide? How significant is the role of this library in constraining the search space and simplifying the task for the LLM?\n- Regarding the multi-path sampling in Algorithm 1, what were the typical values used for the number of paths (P) and steps (T) in your experiments? How much diversity did you observe across the generated paths? Did they explore genuinely different modeling strategies or tend to converge to similar final shapes?", "limitations": "yes", "rating": 4, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 2, "clarity": 3, "significance": 2, "originality": 2, "strengths_and_weaknesses": "Paper strengths:\n\n- The Graph-based Procedural Shape (GPS) representation design allows for the generation of structured and editable assets. \n- The experimental evaluation is strong. ShapeCraft shows superiority over a wide range of state-of-the-art methods in both raw mesh and textured mesh generation. \n\nPaper weaknesses:\n\n- Lack of deeper analysis: The system's success is heavily reliant on the capabilities of powerful, and likely proprietary, LLMs and VLMs. The paper would benefit from a more detailed analysis of failure modes related to these models (e.g., API hallucination, misinterpretation of geometric instructions). Furthermore, more quantitative ablation studies of each design are needed, such as the Blender Wrapper Library and different hyperparameters of multi-path sampling.\n- Scalability to complex topologies: The examples presented (e.g., furniture) are primarily compositions of relatively simple geometric primitives. It is unclear how well the approach would scale to generating objects with highly organic or intricate topologies, such as animals, human characters, or complex mechanical parts, where procedural generation from primitives might be insufficient.\n- Complexity and computational cost: The overall pipeline is quite complex, involving multiple feedback loops and parallel sampling paths. A more thorough discussion of the computational cost (in terms of runtime and, more importantly, the number of API calls to LLMs/VLMs) would be valuable; understanding its cost relative to other agentic systems is important.", "was_revised": true, "final_justification": "Most of my earlier concerns have been addressed through the rebuttal and additional clarifications, and the work demonstrates clear novelty and robustness. However, uncertainties remain regarding its scalability to extremely complex topologies, so I will maintain the borderline accept score.", "rebuttal": "Thank you for your careful reading and valuable feedback. Below please find our clarification regarding your comments.\n\n**W1.1 Concern on LLM/VLM Dependency and Failure Modes**\nTo address potential issues such as LLM hallucination and geometric misinterpretation, we designed two core mechanisms: \n1. **Representation Bootstrapping** As shown in [Appendix Fig.2](), initial LLM parsing misses components (e.g., \"freezer\" in the fridge example). Our bootstrapping mechanism (Sec. 3.1) introduces a VLM-based visual verification loop: the LLM’s output is rendered as bounding-box geometry and compared to the textual input. Feedback from the VLM guides the correction of omissions, hallucinations, and spatial inconsistencies. \n2. **Multi-Path Sampling with Iterative Updates**  Instead of relying on a single deterministic program, we adopt multi-path sampling (Sec. 3.2), which explores diverse shape programs in parallel. Each path undergoes iterative refinement with VLM feedback to correct execution errors or misalignments (as shown in [Fig. 5(A) and Appendix Fig.3]()). This redundancy (lowers the risk of not having any compiled shape programs in the end) improves robustness **against LLM/VLM inaccuracies and API hallucinations**. As a result, ShapeCraft achieves a significantly higher compile success rate compared to baseline methods and even strong CoT-based reasoning models.\n\n**Failure Modes** \nEven equipped with above functions, ShapeCraft may fail when provided with ambiguous or underspecified prompts. In such cases, shape parsing may produce hallucinated or incomplete node descriptions, making downstream modeling unreliable. For instance, prompts like _“an amazing chair with complicated decoration”_ cannot be decomposed into actionable components.\n\n---\n\n**W1.2 & Q2: Blender Wrapper Library and Its Quantitative Ablation Study**\nQualitative ablation study of wrapper library can be found in [Appendix Fig. 5](). We further conducted a quantitative ablation study over 10 prompts subset below:\n\n| Method                          | Avg. Code Length ↓  | Median Code Length ↓ | Hausdorff ↓ | CLIP Score ↑ |\n| ------------------------------- | ------------------- | -------------------- | ----------- | ------------ |\n| w/o Wrapper Library             | 189.57              | 111.00               | 0.424       | 27.1         |\n| ShapeCraft (w/ Wrapper Library) | **168.40 (-11.2%)** | **77.50 (-30.2%)**   | **0.447**   | **27.3**     |\n\nOur Blender Wrapper Library is designed to reduce the complexity of the API space exposed to the LLM. And results show that Blender Wrapper Library provide better shape results and produce more concise program. It abstracts frequent modeling operations—such as primitive creation, Boolean ops, and modifiers—into a curated set of consistent, high-level commands. Instead of raw Blender Python calls (e.g., `bpy.ops.mesh.primitive_cube_add` with multiple parameters), we use simplified wrappers like `cube(location, rotation, scale)`. These abstractions align better with LLM priors and reduce trial-and-error programming during code generation. Detailed API can be found in [Appendix prompt 6]().\n\n---\n\n**W1.3 & Q3: Ablation on Multi-Path Sampling**\nThank you for pointing this out. We provide more quantitative ablations and clarifications below.\nIn our experiments, we used **P=3 and T=3** for shape modeling, and **P=1, T=3** for bounding box generation mentioned in [Appendix Sec. A, L7–9](). These settings strike a balance between performance and efficiency.\n\nTo analyze diversity, we visualize multiple sampled paths in [Appendix Fig. 3](). Empirically, we observe that: 1) For simple shapes, paths tend to converge to similar modeling strategies due to low ambiguity. 2) For complex or ambiguous prompts, different paths often explore genuinely distinct decomposition strategies and shape programs, especially under higher temperature settings. In general, we observe 2–3 unique strategies across 3 paths for complex cases, demonstrating the system's capacity to explore modeling alternatives.\n\nWe also conduct quantitative ablation with varying (P, T) to evaluate the benefit of multi-path sampling. Results below:\n\n| Sampling Setting          | Hausdorff ↓ | IoGT ↑    | CLIP Score ↑ | Run Time (min)↓ |\n| ------------------------- | ----------- | --------- | ------------ | --------------- |\n| P=1, T=1                  | 0.485       | 0.436     | 25.75        | **1.62**            |\n| P=1, T=3                  | 0.494       | 0.492     | 26.20        | 3.90            |\n| P=3, T=1                  | 0.444       | **0.535** | 25.90        | 3.71            |\n| P=3, T=5                  | **0.360**   | 0.431     | 26.39        | 18.04           |\n| **ShapeCraft (P=3, T=3)** | 0.415       | 0.471     | **27.27**    | 11.68           |\n\nThese results show that multi-path sampling significantly improves both geometry quality (IoGT, Hausdorff) and prompt alignment (CLIP), confirming its effectiveness. \n\n---\n\n**W2. Scalability to complex topologies.**\nWe appreciate the reviewer’s concern. While many examples focus on furniture, ShapeCraft is not restricted to simple primitives. As shown in [Fig. 4](), our _Stichter Banjo_ example includes curved surfaces and interlocking parts, illustrating the system’s ability to model non-trivial geometries.\n\nImportantly, our Blender Wrapper Library is extensible, supporting advanced operations like subdivision, bevel, and boolean. Since our agent generates tool-based programs, ShapeCraft can scale to any backend modeling API, given appropriate documentation.\n\nMoreover, ShapeCraft’s hierarchical decomposition and modular program structure naturally support complex assemblies such as CAD parts or articulated components. In revisions, we will include qualitative results on CAD-style shapes.\n\n---\n\n**W3. Complexity and computational cost.**\nOur method scales well with increasing shape complexity and number of parsed components, due to the parallel execution of per-node modeling tasks. The use of our Blender Wrapper Library also reduces the overall program length by abstracting frequent operations, which helps conserve context window compared to native Blender APIs. This is supported by code length comparisons in [Appendix Fig. 5]() and discussed in [W1.2 & Q2]().\n\nWe also report the number of API calls and runtime for the methods in [Tab.1](). API calls are mainly related to code generation $\\mathcal{C}$, feedback $\\mathcal{F}$ and question generation $\\mathcal{Q}$ (only used in CADCodeVertify). ShapeCraft consists of GPS representation initialization and iterative shape modeling. GPS representation initialization needs 3 API calls with one trajectory of three updates for bounding box generation mentioned in [Appendix Sec. A, L7–9](). The number of Iterative shape modeling depends on the $P$ and $T$. Under a minimal configuration (P=1, T=1), it outperforms previous LLM-based methods both in quality and computational cost:\n\n| Method                        | Hausdorff dist.↓ | IoGT↑     | Num. of API Calls↓                                     | Run Time (min) ↓ |\n| ----------------------------- | ---------------- | --------- | ------------------------------------------------------ | ---------------- |\n| 3D-PREMISE (update 3)         | 0.527            | 0.385     | 6: $3\\times (\\mathcal{C}+\\mathcal{F})$                 | 2.81             |\n| CADCodeVertify <br>(update 3) | 0.511            | 0.334     | 9: $3\\times (\\mathcal{C}+\\mathcal{Q}+\\mathcal{F})$     | 3.06             |\n| **Ours (P=1, T=1)**           | 0.485            | 0.436     | **5**:  $3+P\\times T \\times (\\mathcal{C}+\\mathcal{F})$ | **1.62**         |\n| **ShapeCraft (P=3, T=3)**     | **0.415**        | **0.471** | 21: $3+P\\times T \\times (\\mathcal{C}+\\mathcal{F})$     | 11.68            |\n\n  We will include this analysis in the revised paper to clarify the trade-offs between program complexity and execution efficiency.\n\n---\n\n**Q1. Bounding Box Generation and Spatial Coherence in GraphInit**\nThank you for the thoughtful question. During the GraphInit phase, bounding boxes $B_i$ are generated by the LLM through an upsampled node description $x_i$ that supply relative spatial relationships. The LLM uses a wrapper method in [Appendix Prompt 4]():\n\n`cube_bounding_box(name=\"node_name_bbox\", position=(x, y, z), scale=(sx, sy, sz))`\n\nAlthough no visual feedback is available at this stage, LLMs exhibit basic spatial reasoning due to their pretraining. We do not impose fixed value ranges, allowing the model to freely choose a coordinate scale; normalization is applied afterward to ensure consistent layout.\n\nNotably, the bounding box agent generates all  $B_i$ in a single autoregressive run. This implicitly conditions each box on previous ones (i.e., models  $P(B_i|B_{<i})$), helping maintain global spatial coherence even before visual grounding.\n\nSubsequently, the bootstrapping phase [Eq. 2]() integrates VLM feedback to further refine placements. This two-stage design—coarse layout via LLM, fine adjustment via vision—strikes a balance between reasoning efficiency and geometric fidelity."}, {"review_id": "lNW7NajR2W", "reviewer": "Reviewer_wFFw", "summary": "ShapeCraft proposes a procedural 3D generation pipeline using a multi-agent framework. It presents Graph-based Procedural Shape Representation (GPS) for expressing 3D shapes as programs. The method decomposes objects into components as individual nodes with description, bounding volume and an attached code snippet. When generating an objects, the LLM parses the instruction hierarchically into various components to build the complete object. It further applies bootsrapping using a VLM as a judge to correct for errors in the generated shape. The authors also propose to iteratively sample multiple possible creative paths in parallel to capture the full diversity. To add texture to the generated shape, the method follows score distillation sampling and focuses on it at component level as well as global view. The method is comapred against 4 recent baselines as well as an ablation is conducted to show the need for iterative updates which allows better instruction following by correcting errors.", "questions": "* Can the authors compare the average token cost of ShapeCraft against other baselines?\n* The method says it uses a pre-defined chain of thought and the authors choose to disable the thinking module. Given the advances in thinking models, is an explicit chain of thought model needed and is the improvement substantial?\n* How does the LLM understand the proportion ratios?", "limitations": "Limitations can be expanded such as token cost and generation fidelity compared to generative methods such as Trellis, reliance on SDS for texture", "rating": 4, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 2, "clarity": 2, "significance": 2, "originality": 2, "strengths_and_weaknesses": "## Strengths\n* The paper is mostly well-written and all components are explained. \n* The results show good gains in generation quality compared to baselines (both qualitative and quantitative)\n\n## Weaknesses\n* Limited novelty-- Decomposition using LLM and graph representation has already been studied quite extensively. The related work also fails to mention many papers doing very similar things- Holodeck, LayoutGPT, FlairGPT, etc. FlairGPT in particular (and many others) decomposes a scene, builds a graph, calls code snippets to build the scene, which is quite similar and hence should be mentioned in related work. \n* The iterative refinement based on visual feedback is expensive and also explored before (3D-GPT, SceneCraft: An LLM Agent for Synthesizing 3D Scene as Blender Code [different from this paper although they have the same name], BlenderAlchemy). These references should also be added. \n* The texture is generated separately using a SDS based pipeline. I find the author's naming of component-aware SDS a bit gimmicky since it's a simple gathering of node points and there is no real novelty here. \n* While the method sees stronger results compared to baselines, the underlying LLM used in these earlier works are weaker. ShapeCraft uses the newly released Qwen3-235B and it becomes very tricky to understand if the performance gains come from the underlying LLM/prompts or the method in question.", "was_revised": true, "final_justification": "Most of my concerns have been adressed by the authors and I think the method will be useful to the community. However, I think the authors should revise the related work to properly cite past work done in this area.", "rebuttal": "Thank you for your careful reading and valuable feedback. Below please find our clarification regarding your comments.\n\n**W1. Novelty and Comparison with Scene Generation Works**\n\n**We respectfully disagree with the claim that our GPS representation is similar to prior scene generation approaches** such as Holodeck, LayoutGPT, FlairGPT, or SceneCraft. These methods focus on scene layout construction using LLMs to generate graphs over object bounding boxes and then retrieve pre-existing 3D assets (e.g., from Objaverse). Their graph representations encode coarse inter-object spatial relationships, but are not designed for procedural shape modeling.\n\nIn contrast, ShapeCraft focuses on generating novel 3D shapes from scratch. Our Graph-based Procedural Shape (GPS) representation encodes component-level semantics, where each node includes both a bounding volume $B_i$ and an executable modeling program $P_i$. Unlike layout graphs, $P_i$ captures fine-grained geometric construction logic, not just object placement.\n\nWe also argue that shape decomposition is inherently more challenging than scene decomposition, as it requires semantic and functional understanding of substructures within a single object, rather than arranging independent entities in space.\n\nWe will clarify this distinction in the revised Related Work section under \"LLM Agents for Scene Layout\" and include a focused discussion of the above methods.\n\n---\n\n**W2.1 Iterative refinement based on visual feedback is expensive.**\n\n**We respectfully disagree that our refinement strategy is \"expensive.\"** ShapeCraft is designed to be efficient and lightweight:\n1. We use open-source LLMs/VLMs (e.g., Qwen3-235B), enabling low-cost, local deployment without reliance on GPT-4.\n2. Our multi-path sampling supports parallelized component modeling, as nodes are independent post-decomposition.\n3. We employ early stopping based on VLM feedback scores to avoid unnecessary queries.\n4. Despite being training-free, ShapeCraft outperforms fine-tuned methods like LLaMA-Mesh on both geometry and alignment metrics.\n\n---\n\n**W2. 2 Comparison with 3D-GPT, SceneCraft and BlenderAlchemy**\n- 3D-GPT builds scenes using the Infinigen function library; it does not support shape modeling or procedural decomposition.\n- SceneCraft **(distinct name from our ShapeCraft)** performs scene-level layout generation using a constraint satisfaction algorithm and retrieves assets.\n- BlenderAlchemy focuses on material optimization through visual feedback loops, rather than structural modeling.\n  \nIn contrast, ShapeCraft decomposes shape descriptions into fine-grained components and introduces a node-level multi-path sampling strategy. Our VLM feedback loop operates at the per-node level, comparing rendered geometry and component descriptions—not full-scene images—thereby improving both feedback specificity and modeling granularity. We will clarify this discussion in the revised Related Work section.\n\n---\n\n**W3. Clarification on painting module**\nThe diffusion model is invoked as a callable module within our pipeline, it is tightly integrated into the LLM-driven agentic workflow—triggered after shape modeling and conditioned on the GPS structure. Thus, the painting module is not separate, but a downstream step in the procedural generation process.\n\nOur method differs from optimization-based pipelines (e.g., MVDream) that regress entire textures. Instead, we learn a BRDF field over global and local UV coordinates, enabling a physically meaningful and post-editing-friendly texture.\n\nCompared to original SDS, which optimizes the texture globally, our component-aware Score Distillation also introduces node-level conditioning: each component’s geometry and textual description guides rendering and optimization for its corresponding region. This improves semantic alignment, as shown in the following ablation over 10 prompts:\n\n| Metric          | Original SDS | Component-aware Score Distillation |\n| --------------- | ------------ | ---------------------------------- |\n| CLIP Score ↑    | 27.1         | **28.7**                           |\n| VQA Pass Rate ↑ | 0.39         | **0.47**                           |\n\n---\n\n**W4. Fairness for comparison.**\nTo ensure a fair and controlled comparison, we explicitly re-implemented all baselines using the same LLM/VLM setup as ShapeCraft, specifically Qwen3-235B-A22B and Qwen-VL-Max (as stated in [Appendix A Line 5]()). This isolates the performance gain to our GPS representation and multi-path sampling strategy for iterative modeling, not LLM scaling or instruction tuning. We will make this clarification more explicit in the main paper to avoid confusion.\n\n---\n\n**Q1 & Limitation. Computational resource and token cost.**\nWe report the average token cost, runtime and the number of API calls for all methods in [Tab.1](). ShapeCraft incurs higher token usage due to its generation of more detailed, component-wise programs, including multiple code snippets per object.\n\nHowever, token count alone does not reflect actual computational cost. We also report runtime and API call counts. Despite modest increases in these metrics, ShapeCraft delivers up to 41% IoGT improvement over CADCodeVerify, demonstrating a favorable trade-off. Moreover, under a minimal configuration (P=1, T=1), ShapeCraft achieves both better performance and lower runtime than other LLM-based baselines.\n\n**Limitation: Compared to Trellis**\nCompared to TRELLIS-text-large (diffusion-based native 3D model trained on 500K shapes using 64 A100 GPUs) in [Tab.1](), ShapeCraft is **training-free** yet approaches its performance. Notably, our evaluation set (Objaverse-MARVEL) is included in TRELLIS's training set, whereas ShapeCraft generalizes without task-specific fine-tuning. And ShapeCraft produces procedural generation, which is more structured (in  [Fig. 3]() and [Fig. 4]()) and editable meshes ([Fig. 5(B)]() and [Appendix Fig. 6]()), whereas Trellis outputs often suffer from marching-cube artifacts and topological noise\n\n|                               | Hausdorff dist.↓ | IoGT↑     | Token Cost (K)↓ | Num of API Calls↓ | Run Time (min)↓ | Train Time (min)↓ |\n| ----------------------------- | ---------------- | --------- | --------------- | ----------------- | --------------- | ----------------- |\n| 3D-PREMISE (update 3)        | 0.527            | 0.385     | 14.4            | 6                 | 2.81            | 0                 |\n| CADCodeVertify <br>(update 3) | 0.511            | 0.334     | 16.2            | 9                 | 3.06            | 0                 |\n| TRELLIS (diffusion-based)     | **0.411**        | **0.573** | -               | -                 | **1.05**        | >7200             |\n| **Ours (P=1, T=1)**           | 0.485            | 0.436     | 61.3            | **5**             | **1.62**        | 0                 |\n| **ShapeCraft (P=3, T=3)**     | **0.415**        | **0.471** | 669.1           | 21                | 11.68           | 0                 |\n  \n\n---\n\n**Q2. Compared to LLM with the “thinking” module.**\nAs described in [Line 144](), we adopt a hierarchical CoT strategy during shape parsing: the LLM first infers a global semantic root node $H_0$, then recursively decomposes it into component-level nodes $H_i$ based on semantic and structural relationships. This structured CoT constrains the reasoning space and leads to more reliable and interpretable initialization.\nHowever, we disable verbose or unconstrained CoT (indicate \"thinking\" module in LLM/VLM) to ensure efficiency and determinism. This decision is based on our observation that free-form CoT often introduces redundant steps or hallucinated geometry operations.\n\nTo evaluate our hierarchical CoT strategy, we conducted an ablation using open-ended “thinking” models for prompts in [Tab.1](). As shown below, free-form CoT reasoning fails to maintain spatial consistency across components and often produces invalid results. We report compile rate as the percentage of prompts yielding a valid result in a single run:\n\n| Metrics      | ChatGPT-o3 | ChatGPT-o4-mini-high | Deepseek-R1-0528 | Gemini-2.5-Pro | Ours      |\n| ------------ | ---------- | -------------------- | ---------------- | -------------- | --------- |\n| IoGT↑        | 0.177      | 0.244                | 0.326            | 0.102          | **0.471** |\n| Hausdorff↓   | 0.708      | 0.493                | 0.489            | 0.586          | **0.415** |\n| CLIP↑        | 25.48      | 26.3                 | **29.01**        | 27.31          | 27.27     |\n| Compile Rate | 60%        | 80%                  | 80%              | 60%            | **100%**  |\n\n---\n\n**Q3. How does the LLM understand the proportion ratios?**\nIf the concern relates to how the LLM determines component scale and proportion, we clarify as follows: The LLM infers relative proportions based on its pretrained spatial priors (position embedding) and component descriptions (e.g., “a thin screen above a wide base”). During GraphInit, it generates all bounding boxes in an autoregressive run, so later boxes are conditioned on earlier ones, ensuring internal proportional coherence.\n\nWe allow the LLM to freely choose coordinate scales and apply normalization to a unit cube post-hoc to maintain consistency across shapes. Further refinement via VLM feedback ensures spatial accuracy when needed."}, {"review_id": "GzTgsYdeZK", "reviewer": "Reviewer_C1ui", "summary": "This paper introduces ShapeCraft, a novel system that leverages Large Language Model (LLM) agents to autonomously generate structured, textured, and interactive 3D models from natural language instructions. The core innovation is the Graph-based Procedural Shape (GPS) representation, which decomposes 3D shapes into hierarchical components represented as nodes in a directed acyclic graph (DAG). Each node contains a natural language description, bounding volume, and code snippet, enabling flexible programmatic updates and post-modeling edits. Experiments demonstrate that ShapeCraft outperforms existing LLM-based and optimization-based methods in geometric accuracy, semantic richness, and editability. The system also supports post-modeling interactions like animation and customization, making it practical for real-world applications.", "questions": "Overall, I think this is a nice try of how to combine VLM agent with text-to-3D task. Please check for my concerns as listed below:\n(1) The iterative refinement depends on VLM feedback for error correction. What happens if the VLM fails to detect geometric flaws (e.g., intersecting meshes, incorrect proportions)? Is there a risk of error propagation?\n(2) The paper claims efficiency gains from parallel sampling, but no concrete runtime comparisons are provided. How does the computational cost scale with shape complexity compared to end-to-end diffusion-based methods?\n(3) The BRDF-based texturing is conditioned on rendered images, but does it handle complex material interactions (e.g., transparency, subsurface scattering) or only simple reflectance properties?\n(4) The paper shows successful examples but does not analyze where the method fails (e.g., ambiguous prompts, complex topology). A thorough discussion of limitations would strengthen the work.", "limitations": "Yes.", "rating": 4, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 3, "significance": 3, "originality": 4, "strengths_and_weaknesses": "ShapeCraft represents a notable advancement in text-to-3D generation by combining LLM agents with a structured procedural representation. The strengths and weaknesses are listed as follows:\n\n** Strength\n(1) The GPS representation bridges the gap between natural language instructions and procedural 3D modeling, enabling structured, editable outputs compatible with industry tools like Blender. Besides, hierarchical decomposition and bounding volumes simplify spatial reasoning for LLMs, improving accuracy.\n(2) Multi-path sampling and VLM feedback loops enhance robustness, allowing the system to explore diverse solutions and correct errors iteratively.\n(3) The system supports post-modeling edits and animations, making it valuable for artists and developers. It also demonstrates the superiority over existing methods in quantitative metrics (IoGT, CLIP score) and qualitative results (e.g., fewer artifacts).\n\n** Weakness\n(1) The system's performance hinges on the reasoning and coding capabilities of underlying LLMs, which may introduce inconsistencies or failures for complex or ambiguous prompts.\n(2) While the GPS representation is flexible, its effectiveness for highly abstract or novel shapes (e.g., fantastical designs) is not thoroughly evaluated. The paper focuses on static objects; dynamic or deformable shapes (e.g., animated characters) are not addressed.\n(3) The iterative refinement process, though efficient, may still require significant computational resources for high-quality outputs. The paper lacks detailed analysis of computational costs compared to baseline methods.", "was_revised": true, "final_justification": "Thanks for the rebuttal. The authors did address my concerns, and this is a good work. Although the reliance on LLMs may reduce some performance, as demonstrated, there are methods to minimize the impact. Therefore, I will keep my score.", "rebuttal": "Thank you for your careful reading and valuable feedback. Below please find our clarification regarding your comments.\n\n**W1. LLM Dependency for complex or ambiguous prompts**\nWe thank the reviewer for raising this important point. To mitigate LLM inconsistencies under complex or ambiguous prompts, ShapeCraft integrates several mechanisms:\n1. **Hierarchical Decomposition + Graph-Based Representation**  \n\tWe first decompose the input prompt into semantically coherent components using structured chain-of-thought (CoT) reasoning. To further reduce ambiguity, we **augment each node's description with geometry-level details** (e.g., shape, size cues), which improves the LLM’s ability to reason about structure and generate accurate shape programs.\n\tThis hierarchical strategy narrows the search space by assigning each component a well-scoped modeling subtask. As discussed in [Lines 131–132](), each node maintains its own component-level search space, enabling the generation of more precise and consistent code. These geometry-aware sub-prompts serve as clear and focused entry points for downstream modeling.\n    \n2. **Representation Bootstrapping with VLM Feedback**  As shown in [Appendix Fig. 2](), initial LLM outputs (e.g., missing the “freezer” component) are visually verified via rendered bounding boxes. Feedback from the VLM guides corrections of hallucinations, omissions, and spatial errors, improving reliability.\n    \n3. **Multi-Path Sampling and Iterative Refinement**  \n    Rather than relying on a single output, we explore multiple modelling paths (Sec. 3.2). Each is refined with VLM feedback independently (as shown in [Fig. 5A, Appendix Fig. 3]()), increasing robustness and reducing sensitivity to any single LLM failure.\nTogether, these design choices convert complex prompts into manageable sub-tasks, enhance alignment with visual semantics, and significantly improve stability across varied prompt scenarios.\n\n---\n\n**W2. Effectiveness of GPS representation for abstract, fantastical and dynamic shapes**\nWe thank the reviewer for this thoughtful question. ShapeCraft is designed primarily for static, structured shapes, which already present a significant challenge for current LLMs. Our system is most effective when prompts describe geometrically grounded, component-based objects. For highly abstract or fantastical shapes, current LLMs often fail to parse meaningful structure, limiting the reliability of GPS representation. We acknowledge this limitation and plan to explore hybrid approaches (e.g., native 3D model add-on) for such cases in future work.\n\nThat said, our Blender wrapper library is modular and extensible, allowing integration with various add-ons or simulation toolkits. This flexibility lays a foundation for handling abstract, fantastical components, given the right parsing operations and prompt design.\n\nFor dynamic or articulated shapes, we provide a preliminary demonstration in [Fig. 5(B)]() and in the [Appendix video](), where animations are applied directly to generated components (e.g., opening/closing laptop). This is made possible by our explicit component-based GPS representation, which avoids the need for post-hoc mesh segmentation.\n\n---\n\n**W3 & Q2. Computational cost**\nWe report the average number of API calls and runtime for the methods evaluated in [Tab. 1](). API calls in our setup are categorized into code generation $\\mathcal{C}$, feedback $\\mathcal{F}$, and question generation $\\mathcal{Q}$. We follow this taxonomy to compare against 3D-PREMISE ($\\mathcal{C}$+$\\mathcal{F}$) and CADCodeVerify ($\\mathcal{C}$+$\\mathcal{Q}$+$\\mathcal{F}$), both evaluated with 3 update steps.\nShapeCraft consists of two phases: **GPS initialization** and **iterative modeling**. As detailed in [Appendix Sec. A L7–9](), GPS initialization involves 3 API calls for bounding box generation. The iterative modeling phase issues $P\\times T$ modeling attempts. Thus, the total API calls for ShapeCraft are: $3+P×T×(\\mathcal{C}+\\mathcal{F})$. Under a minimal configuration (P=1, T=1), ShapeCraft outperforms previous LLM-based baselines in both quality and computational cost.\n\nWe further compare against diffusion-based methods. As shown in [Fig. 3]() and [Fig. 4](), our procedural generation produces more structured and editable meshes, whereas diffusion-based outputs often suffer from marching-cube artifacts and topological noise, limiting their usability in downstream tasks.\n\nIn particular, ShapeCraft achieves comparable or better IoGT than MVDream (distill from diffusion model), while being significantly faster. Compared to TRELLIS-text-large (diffusion-based native 3D model trained on 500K shapes using 64 A100 GPUs), ShapeCraft is **training-free** yet approaches its performance. Notably, our evaluation set (Objaverse-MARVEL) is included in TRELLIS's training set, whereas ShapeCraft generalizes without task-specific fine-tuning.\n\nWe also demonstrate ShapeCraft’s flexibility in **post-modeling edits** (e.g., animation) in [Fig. 5(B)]() and [Appendix Fig. 6](), highlighting its practicality for interactive applications.\n\n| Method                         | Hausdorff dist.↓ | IoGT↑     | Num of API Calls↓ | Run Time (min)↓ | Train Time (min) ↓|\n| ------------------------------ | ---------------- | --------- | ----------------- | --------------- | ---------------- |\n| 3D-PREMISE (LLM-based)         | 0.527            | 0.385     | 6                 | 2.81            | 0                |\n| CADCodeVertify <br>(LLM-based) | 0.511            | 0.334     | 9                 | 3.06            | 0                |\n| MVDream (diffusion-based)      | **0.411**        | 0.427     | -                 | 32.1            | 0                |\n| TRELLIS (diffusion-based)      | **0.411**        | **0.573** | -                 | **1.05**        | >7200            |\n| **Ours (P=1, T=1)**            | 0.485            | 0.436     | **5**             | **1.62**        | 0                |\n| **ShapeCraft (P=3, T=3)**      | **0.415**        | **0.471** | 21                | 11.68           | 0                |\n\n---\n\n**Q1. Risk of VLM Failure in Iterative Refinement**\nWe acknowledge this limitation. While our VLM-guided bootstrapping significantly improves initial outputs, it is not perfect. To mitigate this:\n- We adopt component-level refinement, so even if one node's error is missed, it does **not propagate globally**.\n- Our multi-path sampling strategy introduces diversity and redundancy, increasing the chance of discovering a correct variant.\n- In practice, VLM feedback successfully catches most common structural issues (e.g., missing parts, overlaps), as shown in [Fig. 5A]() and [Appendix Fig.2,3,4]().\n\n---\n\n**Q3. Complex material interactions**\nWe acknowledge that BRDF alone cannot fully capture translucent or subsurface effects like glass, skin, or wax. However, our texture field design is modular and extendable. By incorporating BTDF models (e.g., adding transmission coefficients and subsurface weight in [Eq.(3)]()), our pipeline can be extended to support complex material types. \n\n---\n\n**Q4. Failure Case Analysis and Limitations**\nWe appreciate the reviewer’s suggestion. We acknowledge two main sources of failure in ShapeCraft:\n\n1. **Ambiguous or Underspecified Prompts**  \n    ShapeCraft relies on prompts containing **explicit geometric cues**. When prompts are vague or lack structural details, the shape parsing may fail, or the upsampled node descriptions may include hallucinated components. For example, prompts like “a magical object with flowing form” cannot be reliably decomposed into actionable modeling steps.\n    \n2. **Complex Topologies**  \n    Our current wrapper library is optimized for modeling structured shapes. It lacks native support for fine-grained or highly organic details (e.g., tails, ears, branches). However, we are actively experimenting with extensions, such as integrating Hunyuan3D add-ons, to support more diverse and irregular topologies.\nWe will include a detailed discussion of these limitations in the revision, and present qualitative failure cases and possible mitigation strategies."}, {"review_id": "HkDK2nekj4", "reviewer": "Reviewer_mrUk", "summary": "This paper presents a method of using LLM to generate 3D shape and texture. The main contribution is proposing a hierarchical structure of the target 3D shape, Graph-based procedural shape representation (GPS) to improve the quality of the generated 3D shapes. Meanwhile, the use of procedural modeling is helpful for generating better results compared with previous methods.", "questions": "Followings are some suggestions to improve the expositions of the paper:\n- I would recommend to mention the underlying program is based on Blender API. For example, when the GPS representation is introduced.\n- The description of the \"Hierarchical shape parsing via CoT reasoning\" and \"Representation bootstrapping.\" are both very unclear and confusing. I think those function notations are not helping readers to understand what these processes are. I understand that there is a page limit of a neurips submission, and I think this is why I strongly recommend the authors to focus on just shape generation. Therefore, there will be space to describe these processes in more details.\n    - For example, how \"DecomposeHierarchy\" is done? also how \"BuildGraph\" is done?\n- Although it is not ncessary to do a comparison, I am wondering why there is no discussion between the proposed method and BlenderLLM [Du et al. 2024]?", "limitations": "It is a bit unclear what is the limitation of the proposed method.\nEven though there is a limitation paragraph in Sec. 5, I feel that they are very vague and confusing. \nTherefore, I think the limitations are not well discussed, and strongly recommend the authors to provide examples and explanations on this part so that readers can understand the proposed method better.", "rating": 4, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 2, "significance": 3, "originality": 3, "strengths_and_weaknesses": "Strength:\n- The proposed method generate nice shape and the use of hierarchical structure is sound.\n- The proposed method can also generate texture beside the geometry.\n\nWeakness:\n- Meanwhile, I think the paper tends to propose too many content at a time, and therefore fail to describe the method thoroughly in the main paper. Although some details are provided in the supplemental material, it is still makes the paper hard to follow and understand.\n- I personally would argue that the paper should focus on the shape generation solely.\n- The generated texture quality is not good and not better than previous methods shown in Figure 3. The texture is quite rough and do not match to the generated shape and prompt accurately. This again makes me think this paper should focus on the shape generation.", "was_revised": true, "final_justification": "The authors addressed my questions during rebuttal, and I think their latest experiment results are nice to have in the paper.\nTherefore, I raise my ratings.", "rebuttal": "Thank you for your careful reading and valuable feedback. Below please find our clarification regarding your comments.\n\n**W1. Clarity and Scope of Method Presentation**\nWe appreciate the reviewer’s feedback and acknowledge that the inclusion of multiple modules (e.g., GPS representation, multi-path modeling, component-aware painting) may impact clarity. In the revision, we will:\n- Clarify the GPS representation and shape modeling with improved notation and explanation.\n- Provide a simplified overview figure with clear annotations of each stage.\n- Relocate implementation details to the appendix and bring key results and analyses from the appendix into the main text.\nWe aim to make the system easier to follow without sacrificing technical completeness.\n\n---\n\n**W2. Texture Quality and Scope of Contribution**\nWhile shape generation is the primary focus of ShapeCraft, the texture module is included to demonstrate the extensibility of the GPS representation for practical workflows. The diffusion model is invoked as a functional component within the LLM agentic pipeline, conditioned on the GPS structure and executed post shape modeling.\n\nOur component-aware SDS adds node-level descriptions and geometry to guide texturing. We conduct an ablation study of the 10 prompts in [Tab.1](), this design achieves higher alignment with the prompt compared to the original SDS:\n\n| Metric          | Original SDS | Component-Aware SDS |\n| --------------- | ------------ | ------------------- |\n| CLIP Score ↑    | 27.1         | **28.7**            |\n| VQA Pass Rate ↑ | 0.39         | **0.47**            |\n\nIn Fig. 3, our method successfully follows texture-related prompts, e.g., generating _“rust and dirt spots, primarily in brown and orange”_ for the air conditioner. In cases with vague or missing texture descriptions, the model falls back to common material priors (e.g., metallic for fridge, leather-like for sofa).\n\nCompared to prior LLM-based shape modeling methods, we are the first to integrate a texture generation module, highlighting a promising direction for future research, even though visual fidelity remains limited.\n\nWe will clarify this scope in the revision and emphasize that texture generation is an optional extension of our procedural modeling framework.\n\n\n---\n\n**Q1. Clarifying Use of Blender API**\nThank you for the helpful suggestion. We agree that explicitly stating our use of the Blender API when introducing the GPS representation would improve clarity. In the revision, we will update Section 3.1 to clarify that each code snippet $P_i​$ in the GPS graph ultimately corresponds to Blender API calls.\n\n---\n\n**Q2. Clarification on Hierarchical Parsing and Representation Bootstrapping**\nThank you for the thoughtful feedback. We acknowledge that the original notation in [Eq.1]() and [Eq.2]() may appear opaque, and we will revise the paper to provide a clearer, more intuitive explanation in the main text.\n\n**Hierarchical Shape Parsing via CoT Reasoning**  \nAs described in [Eq.1](), `DecomposeHierarchy` refers to the first step of LLM reasoning, where the model breaks down the input shape description into semantic levels of abstraction. We give an example \"chair\" in [Line 150-151]().\n\nNext, `ParseNodes` converts each leaf in the hierarchy into a **node-level description**, which is then passed to `BuildGraph`, a **deterministic Python procedure** that instantiates the GPS representation (e.g., generates component identifiers, bounding box placeholders, and empty code slots). These are stored in memory and serialized as `gps.json` (see examples in our supplementary material).\n\n**Representation Bootstrapping**  \nAs shown in [Eq.2]() and illustrated in[ Appendix Fig. 2](), this process refines the initial GPS layout using **visual feedback**:\n1. ``GenerateBoundingBoxShapeProgram``: The LLM generates an initial bounding box program $G_0$.\n2. ``ExecuteShapeProgram``: The boxes are rendered into multi-view images $I$.\n3. ``VlmFeedback`` A VLM is prompted with the rendered images $I_{i-1}$ and asked to evaluate completeness, correctness, and spatial coherence.\n4. ``GraphUpdate``: The bounding box coder agent revises the previous bounding box program $G_{i-1}$ with the VLM feedback $F_{i-1}$ resulting in updated results $G_i$.\n5. This loop continues (or early stopping) until a satisfactory version is selected for downstream modeling.\nWe will revise Section 3.1 and 3.2 to more clearly explain these two modules in intuitive language, minimizing notation where possible.\n\n---\n\n**Q3. Comparison with BlenderLLM**\nThank you for raising this. We have conducted a comparison with BlenderLLM using the same prompts as in [Tab.1](). As shown below, ShapeCraft outperforms BlenderLLM across all metrics, particularly in compile success rate:\n\n| Method     | Hausdorff ↓ | IoGT ↑    | CLIP ↑    | Compile Rate ↑ |\n| ---------- | ----------- | --------- | --------- | -------------- |\n| BlenderLLM | 0.511       | 0.455     | 26.99     | 50%            |\n| ShapeCraft | **0.415**   | **0.471** | **27.27** | **100%**       |\n\nBlenderLLM is tailored for CAD modeling, and its LLM is fine-tuned on instructive prompts and simple shapes. This makes it less effective on open-ended natural language prompts from the MARVEL benchmark. We will include this comparison in the revised version and clarify the distinction in scope and generalizability between the two systems."}]

Author rebuttal:

Meta-review: The paper received four reviews, all initially rated as "Borderline Accept" (4). Following a thorough rebuttal and discussion period, the reviewers maintained their scores, but their justifications clearly shifted to a more positive consensus, acknowledging that the authors had addressed most of their significant concerns.

After going through the paper, the reviews and the discussions, we have accepted the paper.
Decision: Accept (poster)