acceptodds
Under review as a conference paper at ICLR 2027

CADForge: Agentic Single-View CAD Reconstruction with Explicit Geometry Reasoning

10 views

Abstract

Reconstructing editable parametric CAD models from a single-view image is of great practical value for modern manufacturing, yet remains challenging due to incomplete geometric observations and complex inter-part relationships. To address it, we propose CADForge, an agentic framework that progressively converts a single image into CadQuery programs. CADForge decomposes an object into CAD-meaningful components and performs explicit geometric reasoning for each component, a process that first identifies CAD-relevant constraints and then translates them into precise modeling parameters through mathematical code. The inferred parameters then drive component-wise synthesis of executable CadQuery programs, with a review agent evaluating the resulting geometry and providing targeted feedback for iterative refinement. To further improve robustness and efficiency, CADForge incorporates a failure-guided toolkit construction mechanism to distill accumulated experience into tools, and maintains a compact parametric CAD memory for retrieving modeling context on demand. Experiments on diverse single- and multi-part objects show that CADForge consistently outperforms existing baselines in reconstruction fidelity and perceptual quality, demonstrating an effective approach to accurate single-view CAD reconstruction.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
CAD generative modeling, Agent coordination and collaboration

Reviews

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

CADForge is an agentic framework for reconstructiong editable parametric CAD models from a single image. It decomposes an object into CAD-oriented components, extracts geometric descriptions, translates these descriptions into numerical parameters through executable Python programs, and generates component-wise CadQuery code. The framework additionally incorporates visual review, a failure-guided modeling toolkit, and a compact parametric memory. Experiments compare CADForge with direct VLM generation and existing agentic approaches across several object sources, using geometric metrics, execution statistics, token consumption, and perceptual evaluations.

Critical strengths

The problem and output representation have practical value. Producing executable, component-aware CadQuery programs is useful for applications that require editable geometry. The framework addresses relevant difficulties, including omitted components, inconsistent relative placement, and failures during CAD construction.

The paper provides substantial implementation details and useful ablation studies

Critical weaknesses

Existing models can already perform single-image-to-CAD generation effectively in an end-to-end manner. It is therefore unclear why this task requires the proposed explicit decomposition and geometric reasoning stages. The paper does not convincingly establish what essential capability these stages introduce beyond what simpler end-to-end approaches can already achieve. In my view, the proposed pipeline appears to introduce unnecessary complexity, and I am not convinced that this constitutes a meaningful methodological innovation.

Both the numerical scale and the variation trends of the reported CD values differ from what I would expect based on my experience with similar tasks.

The compared methods are not evaluated using consistent statistical units. In particular, Appendix C counts different types of execution attempts for different methods, including complete-program attempts, component-level attempts, and trajectory-compilation attempts. I do not consider it scientifically sound to directly compare success rates computed from these different units.

The paper omits several important and relevant studies I am concerned that related work may have been presented selectively in order to make the contribution appear more novel and important than it is

Questions for authors

See Weaknesses

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

CADForge reconstructs a part-aware CadQuery model from a single image. A VLM orders semantic components and observes their geometry relative to accepted parts. A separate Python program computes nominal dimensions and placements, which a code agent converts into B-rep geometry. Execution repair and visual review revise the current component. A dictionary of construction parameters supplies reference geometry, and helpers mined from failure traces encapsulate fragile CAD operations. The evaluation includes 170 objects with reference geometry and 30 web images. Reported geometric and preference results favor the complete pipeline, and ablations examine its reasoning, review, helpers, and memory. I interpret the contribution as an effective decomposition of visual estimation, arithmetic, and CAD construction, with heuristic rather than solver-enforced global consistency.

Critical strengths
  1. The representation matches important practical distinctions in CAD modeling. Separating image interpretation, numerical relations, and kernel construction is well motivated. Appendix G.3 explicitly computes contacts from boundaries rather than center proximity; Appendix G.4 distinguishes nominal placement from Boolean tolerances and required cuts from optional detail. These are meaningful CAD-specific choices. The geometry program makes assumptions inspectable and reduces repeated arithmetic, even though it cannot resolve unseen geometry by itself.
  2. The practical system contribution has several complementary sources of support. With a common agent backbone, Table 1 improves CD-L1 from 0.01724 for Procedura to 0.01580, and human first-choice preference is 43.8%. Table 7 directly studies geometry programming, improving CD-L1 from 0.01655 to 0.01475. The memory control preserves access to historical information while reducing tokens per component from 45,696 to 27,225. Together, these results support the engineering contribution beyond selected visual examples.
Critical weaknesses
  1. Executable geometry reasoning does not yet constitute a global geometric constraint mechanism. Equations (2)–(3) compute parameters from relationships estimated by the VLM. Appendix G.2 requires a single best estimate rather than an uncertainty range, and G.3 sets one initial extent to 1. This fixes a scale convention; it does not determine perspective-dependent depth or hidden interfaces. Exact arithmetic therefore ensures consistency with the assumed relations, not their correctness in the image. The observed/inferred distinction in the prompts is helpful, but does not propagate uncertainty into subsequent construction. The construction is also directional: each part references accepted predecessors, and review primarily revises the current part. A later cross-member can expose incompatible positions of two earlier supports. The method does not specify an update rule that revisits both anchors and regenerates their dependents. G.4 instructs the code agent to preserve relations, but G.3 treats solver outputs as candidates and no independent residual check is described. Thus the consistency claim should be scoped to progressive heuristic reconstruction, with explicit handling of conflicting relations rather than an implied constraint-solving guarantee.
  2. Kernel validity, design intent, and the distinctive source of robustness remain partly conflated. Section 3.5 stores numerical construction parameters, not a demonstrated dependency system that preserves design intent under edits. Appendix D.2 offers a useful editing example, but does not establish automatic regeneration of mating or symmetry relations. Likewise, Listing 1 returns an unfilleted solid when filleting fails. This is appropriate for optional decoration, as G.4 states; it also illustrates why successful execution does not establish feature fidelity. The paper should distinguish these levels of correctness. Failure-guided helpers are sensible, but removing all helpers does not isolate their automatic construction from the value of ordinary CAD utilities. A library with equivalent operations is the relevant control. Separately, Appendix C.1.1 uses different attempt units for CPVR across systems. Final-object delivery and a common failure-inclusive cost account are needed before claiming an intrinsic reliability advantage. These concerns qualify the mechanism and reliability claims, while leaving the geometric improvements meaningful.
Questions for authors

These requests address the current method and could change the assessment.

  1. When a new part conflicts with two accepted references, can the system revise earlier components and regenerate all affected dependents? Please specify the conflict criterion and update procedure, or state the limitation explicitly.
  2. Which geometric-program outputs are required to survive into the final B-rep, and how are contact, alignment, and required openings checked independently of the visual reviewer? Please distinguish prompt instructions from implemented checks.
  3. Do the geometry-programming and helper-construction gains persist with equal calls, reasoning budgets, and equivalent geometric utilities? This would establish which proposed mechanism contributes beyond additional computational support.
  4. Please report complete-object delivery and total cost including exhausted runs under a common attempt definition. What edit operations preserve dependencies automatically, and which require fresh LLM rewriting?
Reviewer_pagNOpenReview ↗
Rating
4
Confidence
4
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper considers a problem of single-view reconstruction of parametric CAD models of real objects. The proposed method follows the previous approaches and decomposes an object into set of components and then generates CadQuery programs. The key novel ideas is to separate geometric observation from executable geometry programming. Previously constructed components are used as references. Small memory and toolkit are mined from set of examples. The method is evaluated on 30 images and 170 objects with reference geometry, and compared to other methods, using the same GPT-5.5 as a backbone. The proposed method demostrate superior performance to them.

Critical strengths
  1. I think the key idea of the method is geometric specification of the observed object parts relative to the retrieved set of previously constructed components, and then geometry programming using component parameters as a reference. I think it is quite similar to what human designer would do. I think it is a good idea and can be used in other 3D reconstruction agentic frameworks.

  2. Evaluation is done using Articraft and Procedure SOTA approaches with the same GPT-5.5. baseline. The proposed method outperforms them, and quantitative and qualitative analysis is performed to demostrate the validity of the approach.

Critical weaknesses
  1. In the abstract it is stated that "single-view 3D reconstruction has great value for modern manufacturing", which I believe is a large overexageration. For 3D reconstruction in general, for simulation and robotics probably, but definetely not for manufacturing, which requires a significant amount of proof, from construction feasibility to specific metric accuracy. Such things are not considered at all in the paper.

  2. Evaluation dataset is quite small, so it is difficult to assess the robustness of the proposed method, as well it's practicality. Does method correctly estimate hidden geometry? What about metric accuracy? More systematic analysis is required.

Questions for authors
  1. What is the object-level completion rate for the proposed method and competitors under a fixed total generation/repair budget?
  2. What checks are used to define a valid component and assembled output? Do they test intersections, disconnected components and geometric relations?
  3. What are the 60 examples, which are used for tooking construction? How close they are to the test set?
  4. How method can be scaled? Why 60 examples are selected, why not less or more?

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.