acceptodds
Under review as a conference paper at ICLR 2027

ArticulateCode: Functional Contracts and Physical Baking for Articulated 3D Asset Generation

Abstract

Training embodied agents at scale calls for varied furniture and appliances that can be opened, grasped, and used for storage in simulation. Generating their appearance and joint motion is only part of the task: a drawer pull must belong to the drawer, and its collision shapes must leave room for an object inside. We present ArticulateCode, which turns a reference image and an interaction request into executable programs for named parts and a physically compiled articulated asset. A functional contract specifies moving parts, joints, handle ownership, and usable interiors. It guides part construction and remains attached to the rigid bodies and collision shapes produced by physical baking. When collision shapes are rebuilt on identical generated meshes, component-aware shapes clear every sampled joint sweep and all loaded-motion cycles, whereas per-body convex decomposition introduces 3.08–18.13 mm of interference. A geometry-level audit localizes three misplaced repeated parts in two generated assets, and a single part-level code revision repairs each. ArticulateCodeBench, our companion evaluation protocol, compares final assets from direct generators, feedback agents, and full systems under shared interaction requests.

Primary area:
applications to robotics, autonomy, planning
Keywords:
articulated 3D asset generation, embodied AI, programmatic 3D modeling, vision-language models, functional contracts, physical baking, collision-aware geometry, simulation-ready assets

Reviews

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

This paper proposes ArticulateCode, a method for generating 3D articulated objects using programs as an object representation. ArticulateCode is a processing pipeline that first takes reference images and an interaction request as input and uses VLMs to generate code that can build the required 3D object. The model-generated code C first produces named geometry, and a physical baking process then produces the asset. The initially generated components must first be audited and then corrected within a specified inference budget. Experiments tested the effectiveness of the modules, yet revealed limitations in the method’s generalizability and robustness compared with other code-based methods.

Critical strengths
  1. This paper proposes a code-as-representation method to generate 3D articulated objects, which can leverage the strong capabilities of modern LLMs to improve generation quality while keeping the core idea simple and effective. As the capabilities of LLMs expand, this type of method also has the potential to evolve.
Critical weaknesses
  1. The method’s generalizability across different foundation models has not been established, which limits its contribution. As mentioned above, the generalizability of such code-as-representation methods for 3D generation is expected to be critical, as LLMs continue to evolve. If a method can only be used with a certain configuration, it could quickly become outdated and need to be redesigned for new models, which would require substantial effort. However, the results in Table 4 (Section 4.4) show limited generalizability, indicating that this method only works with GPT-5.6 Luna and cannot be adapted to Qwen models.
  2. The method did not show remarkable advantages over similar methods. As shown in Table 4 (Section 4.4), Direct Code and SceneCode are both more flexible in their choice of foundation model and yet demonstrate performance equal to or better than ArticulateCode, even when ArticulateCode uses its best GPT configuration.
Questions for authors
  1. Could the authors establish this work’s contribution beyond what can be attributed to the underlying LLMs? For example, if the method is consistently effective across a variety of foundation models and produces better results as these models become more capable (with most results better than direct model generation), then the work’s independent contribution can be substantiated.
  2. Could the authors provide more empirical results to demonstrate the advantages of this work over SceneCode and Direct Code?
  3. Could the authors resolve the two issues raised in Section 4.4, namely “Motion is the shared bottleneck” and “Interface sensitivity” (especially the latter, as other methods do not exhibit similar problems)?
  4. Could the authors provide more examples to demonstrate the diversity of the method’s 3D reconstructions and prove its ability to handle the wide range of object categories and geometries that may be encountered in scene simulation?
Reviewer_R6LYOpenReview ↗
Rating
1
Confidence
2
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

This paper presents a system that can generate articulated assets from an image reference and a text prompt describing the motion.

Critical strengths

The task that this paper tackles is useful

Critical weaknesses

This paper seems to be a product of auto-research and is highly flawed in many basic aspects as a research paper.

  1. The paper's writing is not understandable. It is filled with made-up jargon whose meanings are not clear, such as "FUNCTIONAL CONTRACT", "PHYSICAL BAKING", "protected interiors.", "stable names", "FROM REQUEST TO OBLIGATIONS". None of these are standard terms, nor are they properly defined.
  2. Evaluation: The paper has basically no baselines. Table 4 compares with "Direct Code" and "SceneCode", but it is unclear what they are. They seem to be some baseline agentic systems that the authors developed instead of existing works. It is also not clear what the proposed ARTICULATECODEBENCH is constructed, what is the "hard-12" and "hard-6" subset, and the reason for not evaluating on a standard setup.
  3. The methods section is also very confusing. For example, it is unclear what model is used to generate the parts, and what model is used to assemble them. It seems to be some agentic system using GPT-5.6, from my guess, but no critical implementation details are provided.
Questions for authors

N/A

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

This paper proposes ArticulateCode, a framework for generating physically functional articulated 3D assets from reference images, object dimensions, and interaction requirements. The main idea is to introduce functional contracts that specify part relationships, joints, handle ownership, and usable interior spaces. Based on these contracts, the framework generates editable part-level programs, constructs physics-ready assets through a physical baking process, and performs functional validation and local repairs when necessary. The authors also introduce ArticulateCodeBench to evaluate the functionality of generated assets, including joint motion, collision behavior, interior accessibility, and object manipulation. Experiments show that the proposed functional contracts can detect certain structural errors, while the component-aware collision construction improves motion clearance and interior usability compared to standard convex decomposition. However, the end-to-end system comparison shows relatively limited performance, with low functional success rates across different model backends.

Critical strengths
  1. Meaningful and practical problem. The paper addresses an important problem of generating physically functional articulated 3D assets, which is particularly relevant given the rapid development of embodied AI. I think this is a meaningful research direction, as generating assets that are not only visually plausible but also physically interactive is valuable for simulation and robot training.
  2. Reasonable and practically motivated design. The proposed framework makes sense from an engineering perspective. Introducing functional contracts to guide generation and validation, together with component-aware collision construction, is a reasonable way to address the gap between visual quality and physical functionality. The component-level experiments also provide some evidence that these designs can improve the usability of generated assets.
Critical weaknesses
  1. Limited methodological novelty. While the framework introduces concrete design choices such as functional contracts, component-aware collision construction, and local repair, I find the methodological novelty somewhat limited. Several key ingredients appear closely related to existing program-based articulated asset generation and physical validation techniques. Although their integration is practically useful, I am not fully convinced that the paper establishes sufficiently distinct technical contributions beyond system-level engineering.
  2. Limited and unconvincing experimental results. Although the proposed benchmark contains 31 requests across 21 objects, the main end-to-end comparison is conducted on only six requests, while several component-level experiments involve only a few generated assets. More importantly, ArticulateCode achieves zero full-sweep success across all three model backends in Table 4, consistently underperforming both baselines on this metric. This raises concerns about whether the improvements observed in controlled component-level experiments translate into robust end-to-end functionality. The use of different interface configurations across experiments further complicates the interpretation of these results.
Questions for authors
  1. Regarding methodological novelty: The proposed framework seems to mainly integrate existing techniques into a unified pipeline. Could the authors further clarify what the key technical innovations are, beyond the engineering integration of functional contracts, physical compilation, and validation? What fundamentally distinguishes the proposed approach from existing program-based articulated asset generation methods?
  2. Regarding experimental results: In Table 4, ArticulateCode achieves zero full-sweep success across all three model backends, whereas both baselines achieve nonzero success. Could the authors explain the main failure modes responsible for this gap, and why the positive results from the component-level experiments do not translate into better end-to-end performance? Given the small evaluation subset, how well do these results reflect the general effectiveness of the framework?
  3. Regarding interface sensitivity: Section 4.4 states that the main complete-system comparison uses an earlier interface configuration, whereas the part-level repair and typed construction studies use a revised interface. Could the authors clarify why the revised interface was not evaluated in the main system-level comparison? Does the revised interface improve end-to-end functional success, particularly full-sweep motion success, rather than only package generation?

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.