acceptodds
Under review as a conference paper at ICLR 2027

Procedura: Agentic 3D Modeling with Procedural Control

Abstract

Native 3D generators now recover impressive mesh geometry from a single image. However, a dense mesh stays soft where a machined object should be sharp, it carries no part decomposition, and it exposes no parameter a user could edit. To address this, we explore the paradigm of 3D shape as code, leveraging and scaling the coding ability of an LLM for 3D modeling. We introduce Procedura, a novel 3D modeling agent framework that writes an object as a procedural assembly, a parametric program whose named parts are joined by typed, machine-checkable mates. From a text prompt, the agent plans the object as an assembly graph and writes the program part by part, solving each placement from the mated frames rather than guessing it, and admitting a part only once compile, mate, and connectivity checks pass. A decoupled vision critic then refines the assembly one diagnosed fix at a time. Moreover, the same graph carries per-part materials and a simulator-validated articulation. We evaluate on P3D-Bench under its assembly judge, and with the same judge on MechBench-36, our hard-surface benchmark. On both, Procedura outperforms state-of-the-art native 3D generators and every prior 3D-code agent on judged quality, produces the sharpest edges of any method we evaluate, and is the only one whose output is an editable, part-structured program.

Primary area:
generative models
Keywords:
parametric 3D generation, text-to-3D, LLM agents, procedural modeling

Reviews

Among:
Shape:
1234this paper, Top 4%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.33 over 3 reviews, above 96% of the others.
Reviewer_ip99OpenReview ↗
Rating
4(+1)
Confidence
3
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

This paper introduces Procedura, an agentic framework that uses a frozen LLM to generate editable 3D models as parametric assembly programs. It plans the parts and their connections, builds them one at a time, solves their placement using typed mates, and checks each addition before refining the result with a separate visual critic. The authors evaluate the method on P3D-Bench and their new MechBench-36 benchmark, reporting improvements over existing methods and single-shot generation.

Critical strengths
  1. The overall workflow is solid and convincing. The paper explains the pipeline clearly, and the design choices and implementation details are easy to follow.

  2. The benchmark is compelling, and the qualitative results are visually impressive. MechBench-36 includes challenging, many-part objects, and the showcased results stand out for their rich detail and clear part structure.

Critical weaknesses
  1. The contribution of the core assembly mechanisms is not directly tested. Typed mates, placement solving, and assembly verification are important parts of the method, especially for building valid assemblies that can move correctly in simulation. However, the ablations only cover planning, 3D feedback, and refinement. The paper does report simulation results for the full system, but it does not show how removing these core mechanisms affects assembly correctness or simulation success rates. Such experiments would help establish how much these mechanisms actually contribute.

  2. The evaluation focuses more on appearance than on the method’s main practical strengths, and the computational cost is unclear. In my view, a key advantage of this method is its explicit part structure and physically valid assembly, beyond visual quality alone. While the paper evaluates its own articulated outputs in simulation, it does not compare assembly correctness or motion validity against relevant baselines. This would be particularly useful given the small overall judge-score gap to the strongest baseline on MechBench-36. The paper also does not report generation time, cost per object, or the average number of iterations and retries, making it difficult to judge whether the improvements justify the additional computation.

Questions for authors
  1. Do you have results showing how removing mate-based placement solving or assembly verification affects assembly correctness and simulation success rates?

  2. Have you compared assembly correctness or simulation success rates with baselines that support articulated outputs? This would help establish whether the method’s structural advantages translate into more usable assets.

  3. What are the average generation time, API cost or token usage, and number of iterations and retries per object? How do these compare with the same-model Codex agent baseline, and were their generation budgets comparable?

3 comments

We sincerely thank Reviewer ip99 for the encouraging review, and for finding the workflow "solid and convincing" and MechBench-36 "compelling". You put your finger on the method's main practical strengths, explicit part structure and physically valid assembly, and we ran new experiments to measure exactly those.

Ablating the mates (W1, Q1). We ran Procedura with and without mates on all 36 objects, with GPT-6-luna at max effort. Without mates, the plan declares no mates, static or kinematic: the mating-feature library and its prompts, each part's joint and its measurement, and the mate exemption from the connectivity gate are all removed. The compile and connectivity gates stay on. Both versions run the full pipeline, including refine, and were launched side by side, so they share serving conditions.

GPT-6-luna maxIsaac passIsaac pass, all joints freePartly blocked joints
With mates27/3612/3617.1%
Without mates20/366/3628.1%

Mates act where they are designed to act, on how the parts fit and move. A joint is partly blocked when the built contact between the moving part and its parent resists the planned motion. All joints free means the object passes Isaac and none of its joints is partly blocked. With mates, 17.1% of joints are partly blocked, against 28.1% without, and twice as many objects pass with every joint free (12 vs 6).

Assembly and simulation success against baselines (W2, Q2). We passed the same-model Codex agent's 36 models (GPT-6-luna, max) through our exporter and Isaac Sim battery. Procedura passes 27/36 vs 6/36: 21 objects pass only with Procedura and none only with Codex (p<0.001). Procedura's models carry 346 moving joints, against 23 for Codex. The structural advantages you point to translate directly into usable assets. 28 of Codex's 36 models export as a single rigid body, while every Procedura model is articulable. Joint fit is our main avenue for improvement: on the 7 objects where both methods have joints, 21% of Procedura's joints and 4.5% of Codex's are partly blocked (not significant).

Time, tokens, iterations and budgets (W2, Q3). Per object at max effort, with the same model, prompt, image and API for both methods:

GPT-6-luna maxProceduraCodex
Wall-clock, median (min)15472
Model calls, median53104
Total tokens, median (M)2.097.63
Uncached input, mean (M)1.530.46
Cached input, mean (M)0.049.91
Output incl. reasoning, mean (M)0.710.12

Procedura uses half the calls and 3.7× fewer tokens. Most of Codex's volume is cached re-reads, so we list all three token classes, which lets either method be priced exactly. The wall-clock difference has two sources. The build is sequential: each part is one model call that sees the compiled build so far, and the part is compiled and checked before the next one starts. Each of those calls also reasons at length: at max effort a Procedura call uses a median of 10K reasoning tokens and takes about 4 minutes, while Codex's many short tool-use steps use 176 tokens and 31 s. Procedura spends its time reasoning about each part rather than re-reading context.

Budgets. Both methods ran under the same 4-hour wall-clock cap. Procedura needs longer than 2 h on half the objects. Run to completion, it leads Codex (0.650 vs 0.597) with 3.7× fewer tokens.

We will report all of this in the revision.

Thank you again for these constructive questions. We hope the new results establish how much the mechanisms contribute, and we would be grateful if you would consider raising your score.

Thank you for your response. my concerns have been addressed, and I will raise my rating to 4.

Thank you for reading our response so carefully and for raising your score. Your questions about how much the mates contribute, and how Procedura compares with an agent baseline on assembly and simulation, led directly to the new experiments. We will add all of them to the revision: the with/without-mates ablation, the Isaac comparison with Codex, and the time, token and iteration breakdown. Thank you again for your constructive review.

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

This paper introduces Procedura, an agentic framework for generating editable, part-structured 3D objects through procedural code. The framework decomposes objects into assembly graphs, generates individual parts using LLMs, and employs typed mates and deterministic geometric verification to ensure correct placement and connectivity. Thanks to such an assembly representation and refinement brought by a vision critic, experiments on P3D-Bench and MechBench-36 demonstrate competitive performance against existing 3D generation methods and agentic coding baselines.

Critical strengths
  1. The procedural assembly representation naturally supports part decomposition, parametric editing, and articulation, offering advantages over conventional mesh-based generation.

  2. Typed mates and deterministic geometric checks provide an effective mechanism for improving part placement and connectivity, reducing reliance on LLM-based spatial reasoning.

  3. The paper evaluates against native 3D generators, specialized CAD agents, and a general-purpose Codex agent, with encouraging qualitative results.

Critical weaknesses
  1. Limited Improvement over Strong Agentic Baselines. Procedura achieves only a marginal improvement over the general-purpose Codex agent using the same GPT-6-astra model (0.694 vs. 0.685). This raises questions about the significance of the proposed framework's performance gains.

  2. Limited Objective Geometric Evaluation. The evaluation primarily relies on VLM-based judging and edge statistics. Without ground-truth 3D geometry or quantitative assembly-accuracy metrics, it remains unclear whether the generated models achieve genuine geometric and mechanical correctness.

  3. Insufficient Ablation Studies. The paper lacks ablations that isolate the contributions of its core technical components, particularly typed mates, solved placement, and geometric verification. For example, it remains unclear whether typed mates provide substantial benefits over conventional LLM-predicted part transformations under the same generation and refinement pipeline. Furthermore, the planning and 3D feedback ablations also remove refinement, making their individual contributions difficult to assess.

Questions for authors

Could the authors report the average number of LLM calls, token consumption, generation time, and computational cost per object? How do these compare with the Codex agent, especially under matched inference budgets?

2 comments

We sincerely thank Reviewer M6Mr for the careful review, and for recognizing that typed mates and deterministic checks "provide an effective mechanism for improving part placement and connectivity". We address each point below with new experiments.

Margin over the Codex agent (W1). We appreciate this concern and tested the margin with two more models, at max effort, with paired statistics. Mean over the 36 objects:

MethodModel, effortJudgeCLIP
ProceduraGPT-6-luna, max0.65081.14
Codex agentGPT-6-luna, max0.59780.20
ProceduraGemini 3.8 Flash0.68783.34
Antigravity agentGemini 3.8 Flash0.64382.25

The direction is consistent: Procedura scores higher on both metrics with both models, and the judge gap is significant for both.

Visual similarity is also only part of the picture. The judge cannot see whether a model articulates or can be edited, and on those two properties the gaps are large: Isaac pass 27/36 vs 6/36, and named parameters in 36/36 vs 8/36 models (details below).

Objective geometric evaluation (W2). Prompts have no ground-truth geometry, so we added objective measurements that need none. They use the GPT-6-luna max models of both methods:

  • Assembly and motion: the same exporter and Isaac Sim battery for both. Procedura passes 27/36 vs 6/36 (p<0.001). 28 Codex models export as one rigid body, while every Procedura model articulates (346 vs 23 moving joints). On the 7 objects where both have joints, 21% vs 4.5% of joints are partly blocked (not significant); we are working to improve Procedura's joint fit.
  • Editability: we scaled named parameters and random literals ×0.8 and ×1.2 and recompiled. Every edit compiles, in both methods. Named parameters appear in 36/36 vs 8/36 models, and random-literal edits stay intact in 81% vs 89% of cases.
  • Printability at 150 mm: 12/36 one-piece models for both, and thin features (under ~1.5 mm) at a median 0.86% vs 0.90% of volume. Procedura's multi-part assemblies print as cleanly as Codex's monolithic models.

Ablations (W3). Thank you for pointing out the refine confound in Tab. 3. Tab. 3 already contains a clean comparison for both rows: the w/o refine row is the full pipeline measured at the same draft stage as the other ablations. At that stage, Tab. 3's composite is 0.687 for the full draft, 0.678 without planning (aesthetics 0.694 vs 0.670) and 0.682 without 3D feedback (geometry 0.664 vs 0.657). We will make this comparison explicit in the revision. Our new mate ablation runs the full pipeline, including refine, with and without mates: mates lower the share of partly blocked joints from 28.1% to 20.1%, and nearly twice as many objects pass Isaac with every joint free (12 vs 6 of 36; details in our response to ip99).

Calls, tokens, time and matched budgets (Q). Per object, medians at max effort:

GPT-6-luna maxModel callsTokens (M)Wall-clock (min)
Procedura532.09154
Codex1047.6372

At a matched token budget, Procedura stays well inside Codex's, with 3.7× fewer tokens. Most of Codex's volume is cached re-reads; the breakdown by token class is in our response to ip99. Procedura needs longer run time, because it builds and verifies one part at a time. Run to completion, it leads Codex (0.650 vs 0.597).

We are grateful for your rigorous questions, which have strengthened the paper. We hope the new evidence addresses your concerns, and if it does, we would be grateful if you would consider raising your score.

Reviewer_M6MrOpenReview ↗

Response

Thank the authors for their detailed rebuttal and additional experiments. The new comparisons, simulation evaluations, and mate ablation indeed strengthen the paper. Moreover, I also accept the clarification that the “w/o refine” row provides a valid draft-stage reference for the planning and 3D-feedback ablations.

However, I still have concerns in terms of the GPT-6 Astra baseline. While the additional cross-model results increase my confidence in the framework’s effectiveness, they do not directly resolve the limited improvement over the original GPT-6-astra baseline. The mate ablation supports the value of the assembly mechanisms collectively, but removing several components together does not isolate the benefit of solved placement over LLM-predicted transformations. Furthermore, the simulation results demonstrate substantially better coverage of articulated outputs, while the evidence for superior joint-level mechanical correctness remains limited. The cost breakdown is helpful, but fewer total tokens do not establish lower actual inference cost, given the different proportions of cached input and reasoning tokens. In short, Advantages in joint-level mechanical correctness and actual inference cost also remain insufficiently established.

Overall, I remain positive about the practical contribution of this paper and decide to maintain my original rating of 3.

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

The paper presents Procedura, a method to obtain a procedurally generated 3D model from a textual prompt. Object geometry is represented as an assembly graph of parts joined by typed mates.

Given a textual prompt, a reference view is generated to guide the successive geometric assembly, which consists on three steps: (1) Planning, (2) Procedural Modeling, and (3) Refinement. In the first step, a vision call proposes the complete ordered list of parts and their typed mates. A second vision call reviews this plan and possibly adds missing parts or refines their descriptions. In the second step, the model generates a CSG module for each part and adds them to the final geometry one at a time. Placement is done by aligning mating frames of different connected parts and at every insertion goes through the following checks: the program compiles, mate penetrations remain within specified tolerances, and the insertion does not create any visible floater. In the third and final step, a visual critic guides edits to correct geometric defects by comparing renders with the reference image. The pipeline also uses reference image to assigns per-part materials and validates the articulations in Isaac Sim.

The proposed method is evaluated on P3D-Bench and on MechBench-36 where it outperforms both agentic and native 3D generation baselines in terms of overall quality predicted by a VLMs, CLIP score, and edge sharpness. Ablation studies validate the efficiency of different proposed stages.

Critical strengths
  • Interesting problem. Generating 3D geometries as procedural assemblies of parts instead of implicit geometric fields have several benefits, but it has always been a very hard inverse problem. Analyzing how agents can efficiently be leveraged to solve this problem with a specific pipeline and geometric and physical checks is very interesting and can inspire additional works in this direction.
  • Improvement over baselines and ablations. The proposed method shows improvement over baselines and ablations of different steps support the effectiveness of the pipeline.
Critical weaknesses

Limited evaluation of articulation. While the paper reports simulator-based validation, it does not compare articulation quality against relevant baselines, leaving the benefit of its mate-based representation for generating articulated assets unclear.

Questions for authors
  • Could you clarify the last claim (L102) among the contributions? What makes Procedura the only editable, part structured output compared to those from other 3D-code agents?
  • Would it be possible to visualize the input image together with the input prompt in all the figures?
  • How are the geometries rendered in Fig. 5 and Fig. 15? They appear different than the other figures.
  • For baselines that support articulated outputs, could you compare articulation quality using the same simulator-based checks reported in Sec. 4.5 or a similar metric? I think this would clarify the efficacy of the method for generating articulated objects.
1 comment

We warmly thank Reviewer e4Mp for the thoughtful review, and for finding the problem interesting and the approach likely to "inspire additional works in this direction". Your articulation question led to what we think is our most telling new experiment. We address each point below.

Articulation against baselines (W1, Q4). We took the same-model baseline, the Codex agent on GPT-6-luna at max effort. We passed its 36 final models through exactly the exporter and Isaac Sim battery of Sec. 4.5: dynamic settle, per-joint actuation sweeps, rest-contact scan, mobility test and URDF re-import.

ProceduraCodex agent
Models split into moving parts36/368/36
Moving joints, all models34623
Isaac pass, all checks27/366/36
Driven joints that reach their commanded range96.0%30.8%

Paired by object, Procedura passes where Codex fails on 21 objects, and the reverse never happens (sign test p<0.001). The reason is the representation. Codex writes most objects as one top-level module call, so 28 of its 36 models export as a single rigid body. Procedura's mate graph is already a kinematic tree, so every object comes out articulable. Codex's 6 passes come from the 8 models it split into parts; that 6/8 rate is comparable to Procedura's 27/36.

Joint fit is where we see the most room to grow. On the 7 objects where both methods have joints, the built geometry partly blocks 21% of Procedura's planned joints, against 4.5% of Codex's 22 joints (not significant). With Gemini 3.8 Flash, the same pipeline blocks 3.9–13% of joints. Mates help here: without them, 28.1% of joints are partly blocked, against 17.1% with them (see our response to ip99).

The claim at L102 (Q1). Thank you for the careful reading; we agree the wording should be more precise. Other agents also write code, but their code is rarely structured for editing. Procedura's program is a list of named part modules with named, exposed parameters. We measured the difference on the GPT-6-luna models: per model, 5 named parameters and 5 random numeric literals, each scaled ×0.8 and ×1.2, then recompiled.

ProceduraCodex agent
Models with named top-level parameters36/36 (median 34)8/36 (median 0)
Edits that compile100%100%
Named-parameter edits intact (compiles, changes, no loose piece)80% of 34681% of 36

Codex hard-codes numbers at module call sites, so a user has almost nothing named to change, whereas every Procedura model exposes its dimensions by name. When a random literal is changed outside the parameter interface, both methods mostly stay intact (81% vs 89%). We will rewrite the L102 claim.

Image and prompt in all figures (Q2). Thank you, this is a great suggestion. The revision shows the reference image and the prompt in every comparison figure, as Fig. 16 already does.

Rendering of Figs. 5 and 15 (Q3). Thank you for the careful look. Figs. 5 and 15 are rendered with clay shading, and the edge lines of the shape are highlighted, so that the geometry itself is easy to read.

We hope these results clarify how well procedural assembly works for articulated objects. If they do, we would be grateful if you would consider raising your score.

Comments on the paper

1 comment

We sincerely thank all three reviewers for their careful and constructive reviews. We were encouraged that they found the problem interesting, the pipeline "solid and convincing" (ip99), the benchmark "compelling" (ip99), and typed mates with deterministic checks "an effective mechanism" (M6Mr). Their questions point to the experiments that best show what procedural assembly buys, and we ran all of them on MechBench-36. Every method received the same locked reference image, prompt, model, effort and API. Outputs are scored blind by a Gemini 3.8 Flash judge and by CLIP. All new Procedura runs use our faster setting without per-part 3D-feedback renders. Tab. 3 shows that this setting is weaker than the full pipeline, so these numbers are conservative.

1. Procedura leads same-model coding agents in every setting. Mean over the 36 objects, with the same inputs, model and API for both methods:

MethodModel, effortJudgeCLIP
ProceduraGPT-6-luna, max0.65081.14
Codex agentGPT-6-luna, max0.59780.20
ProceduraGemini 3.8 Flash0.68783.34
Antigravity agentGemini 3.8 Flash0.64382.25

Procedura scores higher on both metrics with both models. Paired by object, the judge prefers Procedura on 26 objects and Codex on 5 (p<0.001), and Procedura over Antigravity on 22 and 6 (p=0.004).

2. Procedura's outputs articulate; the baseline's mostly cannot. We ran Codex's 36 models through the same exporter and Isaac Sim battery we use for Procedura. Every Procedura model splits into moving parts (346 joints), against 8 of 36 Codex models (23 joints). Isaac pass is 27/36 vs 6/36 (p<0.001). Codex's six passes come from the eight models it happened to split into parts, whereas Procedura produces articulable structure on every object, which is what the mate graph is designed to guarantee.

3. Procedura's outputs are parametric. All 36 Procedura models expose named top-level parameters (median 34 per model), against 8 of 36 Codex models (median 0). Every edit we made to a Procedura model compiled. Printability at 150 mm (loose pieces and thin features) is on par with Codex's monolithic models.

4. Cost. At max effort, Procedura makes half as many model calls as Codex (median 53 vs 104) and sends 3.7× fewer tokens per object (2.09M vs 7.63M). It spends that budget on uncached input and per-part reasoning, whereas most of Codex's token volume is cached re-reads. Procedura takes longer in wall-clock time (median 154 vs 72 min). It builds one part per call, in order, and compiles and checks each part before the next. At max effort each of those calls also reasons at length: a median of 10K reasoning tokens and about 4 minutes per call, against 176 tokens and 31 s for Codex's short tool-use steps. Full numbers are in our response to ip99.

5. Ablations with refine. We ran Procedura with and without mates on all 36 objects, on GPT-6-luna at max effort, both with the full pipeline including refine. Mates lower the share of partly blocked joints from 28.1% to 17.1%, and nearly twice as many objects pass Isaac with every joint free (12 vs 6 of 36).

We will add all of these results to the revision, sharpen the claim at L102, and show the reference image and prompt in every figure. We are grateful for the reviewers' time, and we hope the new evidence resolves their concerns.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.