acceptodds
Under review as a conference paper at ICLR 2027

CADre: Agentic CAD Reverse Engineering without 3D Encoders

Abstract

Reverse engineering 3D Computer-Aided Design (CAD) shapes is a fundamental challenge in modern engineering workflows, which aims to recover editable construction sequences from static geometry. Large language models are a natural fit for this task because they can synthesize procedural CAD programs, which can be represented as Python code. However, they cannot natively support 3D CAD as a modality, since there are no pretraining data comparable in scale and diversity to image and text data. Prior work bridges this modality gap by training 3D encoders to align geometry with the language model. Yet the alignment is itself a difficult task due to data scarcity, and these approaches tie the encoder to a fine-tuned model, precluding the use of frozen frontier LLMs. We observe that CAD geometry need not be learned as a new modality. An LLM can write programs to read or estimate its structures and dimensions, and render it to grasp the overall shape, so the input arrives entirely as text and images. Building on this observation, we propose CADre, a multi-agent framework for CAD reverse engineering that equips frontier LLMs with a Python environment and a renderer, allowing them to look at and query CAD shapes directly without training a 3D encoder. In our system, a cadre of specialized agents investigate the target geometry, generate CAD programs, and verify the resulting reconstructions collaboratively. Experiments on three CAD datasets show that our system substantially outperforms prior state-of-the-art methods by up to 38 IoU points on the hardest shapes.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
CAD Reverse Engineering, LLM agents, CAD Code Generation

Reviews

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

The paper introduecs CADre, a system that uses frozen large language models to reconstruct CAD models from B-rep or point-cloud inputs without additional training. It divides the task among three agents: an investigator examines the input shape using Python queries and rendered views, a generator writes CadQuery programs, and a verifier checks the results and provides feedback for further revisions. The authors evaluate CADre on subsets of DeepCAD, Fusion 360, and ABC with different levels of shape complexity and report higher reconstruction accuracy than the selected baselines.

Critical strengths
  1. Metrics look promising. With point-cloud inputs, CADre–Gemini achieves IoU scores higher than the strongest reported point-cloud baselines on the Hard splits of DeepCAD, Fusion 360, and ABC . The ablation results also suggest that using code to measure and inspect shapes helps improve reconstruction. It shows that frozen language models can reconstruct complex CAD shapes.

  2. Support for different input types and language models. CADre accepts both B-rep models and point clouds, and the authors test it with Gemini and Qwen, which can be run locally. With B-rep inputs, the Qwen version also outperforms the selected baselines on all three Hard splits. These results suggest that the approach can work beyond a single proprietary model.

Critical weaknesses
  1. Limited methodological novelty. Earlier agentic CAD systems already use frozen language models, code execution, geometry tools, and repeated feedback. CAD-Assistant, for example, performs reverse engineering from 3D scans without additional training, and CADre’s generation and verification loop is adapted from an existing framework. The main additions seem to be a separate investigation stage and the integration of CAD-specific tools. While the evaluation is valuable, the paper does not clearly explain how these additions represent a substantial advance over prior methods.

  2. The comparisons do not fully isolate the benefits of the proposed method. CADre and the baselines differ in both the information they receive and the computation they use. CADre can query exact B-rep properties, while the baselines use point clouds or rendered depth views. A single CADre refinement step can also involve many model calls, so matching the number of steps does not ensure a fair comparison. The point-cloud experiments help address the input difference, but model capability and inference budget still vary. A key missing comparison is a simpler agent given the same language model, geometry tools, inputs, and total inference budget.

Questions for authors
  1. How much of the performance gain comes from the capabilities of the underlying VLM, and how much comes from the proposed framework? The image-only ablation uses the same model but also removes programmatic geometry access and the investigator. Could you compare CADre against a simpler single-agent loop using the same frontier VLM, geometry tools, inputs, and total inference budget?

  2. What is the principal methodological advance over existing tool-augmented CAD systems? CAD-Assistant already demonstrates training-free CAD interaction and reverse engineering from 3D scans, while CADre adapts an existing generate–verify framework. Could you clarify which technical contribution goes beyond these prior approaches and provide evidence of its benefit?

  3. How comparable are the information access and computational budgets across methods? CADre can query exact B-rep properties, whereas the baselines consume point clouds or rendered depth views, and one CADre refinement step can involve multiple model calls. Could you clarify whether the point-cloud inputs use comparable sampling and point counts, and report reconstruction accuracy against total inference cost rather than refinement steps alone?

5 comments

We thank the reviewer for the thoughtful questions and constructive feedback. We have revised the manuscript to clarify our approach and experimental comparisons.

1. Main Concerns

C1. What is CADre's principal methodological contribution beyond existing tool-augmented CAD systems such as CAD-Assistant?

We acknowledge that CAD-Assistant is an important conceptual precedent for using frozen LLMs with programmatic access to CAD geometry. However, CAD-Assistant primarily focuses on CAD question answering, sketch autoconstraining and sketch parameterization. Its reverse-engineering demonstration (Fig. 5, center) relies on a user-specified modeling procedure, including the slicing plane, extrusion operation, and extrusion length.

In contrast, CADre tackles autonomous CAD reverse engineering without user-specified procedure. We introduce a dedicated investigation stage in which the agent autonomously determines which geometric properties to inspect, writes programs to obtain these measurements, and synthesizes a reconstruction plan specifying the modeling operations needed to rebuild the target geometry. This goes beyond executing a user-provided modeling procedure. CADre further extends this approach to point clouds. We demonstrate that even without access to analytic geometry, the LLM can write programs to estimate the geometric properties it needs to reconstruct the shape autonomously.

Beyond this methodological distinction, we provide systematic quantitative evidence on 450 shapes across three CAD datasets under both B-rep and point-cloud inputs, demonstrating that training-free, encoder-free LLM agents can outperform specialized CAD reverse-engineering models on challenging shapes.

We have clarified these connections and CADre’s technical differences in Section 2 of the revised manuscript. (L160-175)

C2. How comparable is the geometric information available to CADre and the baselines?

We thank the reviewer for raising this question. The methods differ in how they make geometric information accessible to LLMs, and this distinction is central to the research question our work addresses. For example, CAD-Reasoner also starts from B-rep geometry but converts it into multi-view depth renderings before processing them with a trained neural network. In contrast, CADre treats B-rep as a queryable object, allowing the LLM to directly inspect the geometry through code execution, without a learned 3D encoder.

For point-cloud inputs, we sample 32,678 points from the target mesh, following DualBrep[1] and PI3DETR [2] (which use 32,768 points). CADre uses the full sampled point cloud by treating it as a queryable file. On the other hand, CAD-Recode and Cadrille further downsample the points to 256 as part of their respective preprocessing pipelines before feeding them into their neural networks. All methods obtain their geometric information from the same type of source. The difference lies in how each method processes and utilizes this information, rather than being given fundamentally different sources of geometry.

We argue that this distinction reflects an important advantage of our approach. By treating point clouds as queryable objects, CADre can flexibly inspect large point sets through programmatic queries, without being tied to a particular input resolution specified by a learned encoder.

Reference: [1] Liu et al., DualBrep: A Dual-Field Continuous Representation for B-rep Modelling. [2] Oberweger et al., PI3DETR: Parametric Instance Detection of 3D Point Cloud Edges With a Geometry-Aware 3DETR

C3. Are the inference budgets comparable between CADre and the baselines?

The inference budgets are not directly comparable, as CADre makes multiple LLM API calls, whereas the baselines employ different inference procedures. Smaller specialized models may cost more over their lifecycle because they may require task-specific data, training, as well as retraining to benefit from newer backbone models. These introduce substantial development, computational, and maintenance costs that are not reflected in inference-only comparisons.

CADre instead leverages frozen frontier LLMs without task-specific training. And importantly, the capability can also be easily upgraded via the agentic harness as the base model gets better.

More broadly, the inference cost of proprietary LLMs is rapidly decreasing and is not necessarily more expensive than open-weight models. For example, on OpenRouter, GPT-6 Luna costs $0.10/$0.50 per million input/output tokens, compared to $0.25/$2.00 for Qwen3.6-27B. Crucially, CADre can benefit from increasingly capable and cost-efficient frontier models without task-specific retraining.

C4. How much of CADre's performance gain comes from the underlying VLM versus the proposed agentic workflow, and is multi-agent decomposition essential to its effectiveness?

We thank the reviewer for raising this question. We would like to clarify that our main contribution is an agentic workflow designed for autonomous CAD reverse engineering through programmatic geometric inspection, rather than a claim that multi-agent decomposition is inherently superior to a single-agent approach. In Table 2, our Image-only ablation is designed to answer the question: Is a powerful frontier VLM with visual feedback and iterative refinement sufficient for accurate CAD reconstruction?. In this ablation, we remove both the investigator and programmatic access, so the system represents a generic generate-verify refinement loop. The substantial performance drop shows that a powerful VLM with visual feedback and iterative refinement alone cannot account for CADre's reconstruction performance. Our second ablation, w/o Code inspection, aims to test the importance of code inspection for CAD reconstruction. This configuration keeps the investigator and other tools, but removes the ability to execute custom geometric queries. Reconstruction accuracy again decreases substantially, demonstrating that programmatic inspection is a key contributor to CADre's performance. Together, these experiments support the effectiveness of our CAD-specific agentic workflow and the importance of programmatic geometric inspection. These ablations are not intended to isolate the contributions of individual agent roles, as we do not claim that the particular decomposition into three agents is necessary or optimal. Our contribution lies in enabling frozen LLMs to autonomously reconstruct CAD geometry through programmatic inspection and iterative refinement, without learned 3D encoders or task-specific fine-tuning. We have revised the discussion of Table 2 in Section 4.4 (L466–480) to reflect this interpretation.

2. Questions and Clarifications

Q1. Could the authors report reconstruction accuracy against total inference cost rather than refinement steps alone?

We agree that refinement steps are not directly comparable across methods in terms of inference cost. Figure 3 is intended to illustrate refinement behavior rather than computational efficiency. We also provide detailed per-task cost breakdowns in Appendix A.2 (Tables 3–4), but acknowledge that these do not directly show the accuracy–cost relationship.

Thank you for your clarifications, I now have a more thorough understanding of the contributions of this paper. I now have 2 more concerns/questions, i will raise my score accordingly if you can give suitable explanations.

  1. the title is definitely not suitable for this paper. Is this the first work to reverse engineer cad without 3d encoder? From my understanding of your contributions now, 3d encoder free is not one of your contribution, this is very confusing and misleading.

2.How reliable is this framework? when will it fail? From your paper, the model will first use rendering of the target to grasp the general shape and begin investigation. If the target shape has inside structures, will this fail?

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

The paper proposes a multi-agent framework for reverse engineering point clouds or B-Reps into CAD programs written in Python with the CadQuery API. Existing methods typically use a 3D geometry encoder to align the input geometry with an LLM for code generation, and most of them also fine-tune the LLM. This paper instead tackles the task without any training, using a multi-agent system built on LLMs. The agents follow a tool-use paradigm and work in a Python code-execution environment equipped with the CadQuery API. The framework has three main agent roles: an investigator, a generator, and a verifier. Experiments cover three benchmarks of increasing complexity and use two backbone models, a proprietary Gemini model and an open-source Qwen model. Both models perform impressively, even though the LLM is never trained and no geometry encoder is added.

Critical strengths

Generic AI agents are getting better quickly at CAD generation. Several recent commercial tools and published works now outperform expert models trained for specific CAD tasks, such as generating CAD from text, images or sketches. Generic training-free models have not yet reached this level for CAD generation from 3D geometry. That task requires understanding the input geometry, and this ability is still in its infancy for LLM agents. To the best of my knowledge, this paper is the first to show strong results on this task with training-free LLM-based agents. Its agents outperform state-of-the-art expert models such as CAD-Recode and cadrille. The proposed multi-agent framework supports effective refinement loops through carefully designed tool use.

For reverse engineering CAD programs from geometry, training-free agents have several advantages over expert models that go beyond geometric accuracy:

(1) Expert models are limited to the kinds of CAD programs they saw during training. Large, diverse CAD datasets are scarce, so these models are often restricted to a few predefined operations (e.g., extrusion, revolution). Agentic frameworks with tool use are more general and have likely seen broader data, so they do not appear to share this limitation.

(2) Expert models copy the coding style of their training data, so their code rarely makes full use of the target API (e.g., CadQuery). Such APIs are designed to capture design intent. For example, ten holes are better written as a loop of cut operations than as ten separate cut statements. Generic agentic frameworks can take advantage of this through proper tool use.

It is very encouraging to see an agentic approach work for CAD reverse engineering. Future work could nicely build on this solution, especially with the open-source model. I consider this the paper’s most important strength, and I strongly encourage the authors to release their code and the materials needed for follow-up studies.

Critical weaknesses

I did not find any critical weaknesses. The two comments below are suggestions that would strengthen the paper rather than required changes.

  • As noted in the strengths, one main advantage of training-free agentic frameworks over expert models is that they can cover a wider range of CAD operations beyond the dominant ones (e.g., extrusion, revolution). The paper could support this point by comparing the CAD functions used by the proposed framework with those used by expert models. A simple analysis would be enough: count the functions that appear in the predicted programs and compare their distribution against the outputs of expert models.

  • Table 2 shows how much each tool contributes to the final performance, which is a useful insight. It would also help to report how often the agents actually call each tool. This would show the trade-off between how often a tool is used and how much it improves geometric accuracy, and would add to the discussion of tool use.

Questions for authors
  • Could the authors report the distribution of CAD operations used in the programs predicted by their framework, and compare it with expert models such as CAD-Recode, cadrille and CADReasoner? A short discussion of the differences would also be helpful.

  • Could the authors report how often the agents use each tool, and discuss the trade-off between tool usage and final performance?

2 comments

We thank the reviewer for the encouraging feedback and for suggesting these analyses.

Questions

Q1. How does the diversity of CAD modeling operations generated by CADre compare with specialized models such as CAD-Recode, cadrille, and CAD-Reasoner?

We analyzed the CadQuery functions used in the generated programs from CADre, CAD-Recode, Cadrille, and CAD-Reasoner. Across the benchmark, the four CADre configurations use 76-95 distinct CadQuery functions, while all three baselines use the same set of 18. The broader range comes from using different functions across shapes, including operations such as filleting and lofting. We have added a summary in Section 4.2 and report the function counts and usage distributions in Appendix A.3.

Q2. How frequently does CADre use each geometry inspection tool, and what is the relationship between tool usage frequency and reconstruction performance?

We have added a tool usage analysis in Appendix A.4, where we report the median number of calls per run for each tool and agent. Code inspection is used frequently on Hard cases, and removing it leads to the largest IoU drop in Table 2.

Q3. Will the authors release the code and supporting materials to facilitate reproducibility and future research?

We’d be happy to open-source the code once we receive approval. CADre was developed during an internship, so we’ll go through the company’s internal review process before releasing it.

Reviewer_NoUAOpenReview ↗

Update After Rebuttal

I thank the authors for their rebuttal. I maintain my initial rating.

Reviewer_6ts3OpenReview ↗
Rating
2
Confidence
4
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

Prior LLM-based CAD reverse engineering trains a 3D encoder to project geometry into a language model's input space, which ties the encoder to the model it was tuned with and rules out frozen frontier models. This paper's observation is that for CAD the alignment problem is partly self-inflicted: a B-rep already stores analytic surfaces that a program can read directly, and a point cloud can be measured by an estimator the model writes for itself. So the authors replace the encoder with a Python environment and a renderer. Three frozen-LLM agents work through them: an investigator probes the target over many turns and emits a persistent description and reconstruction plan, a generator writes CadQuery, and a verifier compares the prediction against the target and returns feedback for the next revision.

The authors validate on DeepCAD, Fusion 360 and ABC, stratified by B-rep face count into Easy, Medium and Hard at 50 shapes per cell, under two input settings and two base models, one proprietary and one open 27B. The reported gain is up to 38 IoU points on the hardest split. The submission also includes a four-row tool ablation, a refinement-step curve, and an unusually complete appendix of prompts, transcripts, generated programs and per-task cost tables.

Critical strengths

The tool ablation is the paper's one well-controlled experiment, and it isolates an effect of the tools and not of model quality. The w/o Code inspection row of Table 2 holds the investigator, the plan, the loop, the renderer, the statistics tool, target access and all budgets fixed, removing only programmatic inspection, and costs roughly 0.23 to 0.39 IoU. The open-model result points the same way: the 27B configuration starts below the strongest baseline on DeepCAD Hard and climbs past it over the refinement budget (L422–424). Both results argue against the simplest explanation, that the gains come from using a strong proprietary model, and they show the refinement loop is doing the work. The authors ran the experiment that could have falsified their own claim, which is not the norm in this area, and it is the main reason I am not recommending a clear reject.

However, this experiment supports a weaker conclusion than the paper draws from it. The one remaining non-programmatic tool returns only bulk volume and topology, so removing code inspection removes nearly all per-feature measurement of the target. What the ablation supports is that quantitative access to the target is necessary, which is a far less surprising claim than the paper's, that a general Python environment beats fixed utilities because of the agents' ability for writing queries those utilities cannot express (L263–266). That stronger claim is the interesting one, and it goes untested.

Critical weaknesses

The paper does not teach enough that is new. Equipping a frozen frontier model with tools and a verifier loop, and beating a small fine-tuned specialist at considerably higher inference cost, is by 2026 well-established pattern rather than a result. The particular move here, declining to learn a modality when you can write programs against an API that already exposes it, is ViperGPT's template. The premise of handing a frozen vision-language model a Python handle on a CAD kernel over a given CAD file is CAD-Assistant's (Mallis et al. 2024), which L157–160 sets aside on scope rather than crediting as the conceptual precedent it is. With the loop, the memory scheme and the codebase inherited, what remains new is the investigator stage and the choice of tools.

The evidence compounds this. Given a B-rep, the investigator reads analytic face parameters straight off the file (Fig. 2). Nothing has to be perceived, the task collapses into transcribing queried numbers into CadQuery, and the perfect scores on two splits follow from that rather than from any claim about modalities. Point-cloud input is the regime where "no 3D encoder needed" would actually mean something, and there the result is model-dependent: the open 27B configuration falls behind the point-cloud baselines on DeepCAD Easy and Medium and behind the iterative baseline on Fusion 360 Hard. The single transcript provided also shows how good the estimates match the exact B-rep query: the cloud is dense enough that estimation recovers the same face positions. Therefore, even that setting is closer to reading than to perceiving. A revision that centred the point-cloud regime, matched the baselines' published inference budgets, and dropped the priority framing would be a more honest and more useful paper. Note, that this would be a different submission from the current one.

Questions for authors

These would not change my recommendation on their own, but they need resolving either way.

  1. Which generator produced Table 1? Sections 3.3 and 3.4 describe a single LLM call with no images and no tool access (L245–246, L259–260), which is what Eq. 3 formalises and what the abstract's "the input arrives entirely as text and images" depends on. Appendix A.3.2 gives the generator a tool that returns multi-view renders and verifier feedback, its prompt calls it a tool-driven agent receiving reference images (L737–744, L819–826), and the cost tables report dozens of generator turns per task. As written, I cannot tell which system was evaluated

  2. What candidate budget was used for each baseline? One is described as a single inference pass when its published default is best-of-ten selection, and re-running it at that default would settle the comparison.

  3. What is the aggregation statistic across the 50 shapes in each cell, and what is the invalid-geometry rate? Two of the three baselines report medians specifically to avoid invalid-output bias, and all three publish an invalid rate. Neither appears here.

  4. Figure 3 disagrees with Table 1 for several curves, including one where the tabled value exceeds every plotted point on its own curve. Which is correct? Maybe I missed something

  5. Does w/o Global statistics remove the IoU comparison tool or only the bulk-statistics tool? The main text and the appendix group them differently, which changes what that row shows.

4 comments

We thank the reviewer for the careful review. We have revised the manuscript to clarify our contributions and address the points raised.

1. Main Concerns

C1. Is Programmatic Geometry Inspection Already an Established Paradigm in CAD Reverse Engineering?

We agree that we are witnessing an increasing adoption of programmatic tool use in many LLM and agentic systems. However, we respectfully disagree that replacing trained 3D encoders with programmatic geometry inspection has become an established practice in CAD reverse engineering.

Recent CAD reverse-engineering research continues to rely extensively on 3D encoders and task-specific training. Besides CAD-Recode (ICCV 2025), Cadrille (ICLR 2026 submission) and CADReasoner (CVPR 2026) discussed in the paper, recent point-cloud-to-CAD reconstruction methods such as PartCAD (NeurIPS 2025), ReACT(AAAI 2026) and StepCAD (NeurIPS 2026) all use point-cloud encoders to process the input geometry. The reliance on learned 3D encoders also extends to B-rep inputs, despite their directly queryable nature. CADCL (JCDE 2025) and BrepCoder (ECCV 2026) both use B-rep encoders to extract geometric information for CAD reconstruction. Even in broader B-rep understanding tasks, BrepLLM (ECCV 2026) uses a hierarchical B-rep encoder to enable LLMs to understand CAD geometry, while PP-Brep (CVPR 2026) uses a graph-based encoder for CAD classification.

These recent works show that training dedicated 3D encoders remains a common approach to CAD reverse engineering. While programmatic tool use is well established in many LLM systems, replacing trained 3D encoders with programmatic geometry inspection is not yet an established practice in this domain. CADre demonstrates that frozen frontier LLMs can instead inspect CAD geometry through Python execution and reconstruct editable CAD programs without training a 3D encoder.

We have added these recent examples into the introduction and related work sections of the revised manuscript.

C2. Novelty beyond CAD-Assistant and ViperGPT

We thank the reviewer for pointing out these connections. We acknowledge that CAD-Assistant and ViperGPT are important conceptual precedents for tool-augmented, training-free LLM systems.However, CADre differs from these works in both its technical approach and the problem it addresses.

Compared with CAD-Assistant: CADre tackles autonomous CAD reverse engineering without user-specified procedure. On the contrary, CAD-Assistant is presented as an interactive assistant and primarily focuses on CAD question answering, sketch autoconstraining and sketch parameterization. In CAD-Assistant's qualitative demonstration (Fig. 5, center), the user explicitly specifies the slicing plane, extrusion operation, and extrusion length. In contrast, CADre introduces a dedicated investigation stage in which the agent autonomously determines which geometric properties to inspect, writes programs to obtain these measurements, and synthesizes a reconstruction plan specifying the modeling operations needed to rebuild the target geometry. This goes beyond executing a user-provided modeling procedure. CADre further extends this approach to point clouds. We demonstrate that even without access to analytic geometry, the LLM can write programs to estimate the geometric properties it needs to reconstruct the shape autonomously.

Compared with ViperGPT: Although both methods utilize Python programs generated by LLMs, ViperGPT relies on pre-trained vision models to provide perception capabilities, such as using MiDaS for depth estimation and GLIP for object detection. In contrast, CADre enables LLMs to inspect B-rep geometry and point clouds through programmatic queries, without relying on learned 3D encoders or task-specific training.

Beyond these technical distinctions, CADre provides systematic quantitative evidence that training-free, encoder-free LLM agents can outperform specialized CAD reverse-engineering models on challenging shapes. We evaluate 450 shapes across three CAD datasets under both B-rep and point-cloud inputs, establishing autonomous agentic reconstruction as a competitive alternative to task-specific fine-tuning.

We have clarified these connections and CADre’s technical differences in Section 2 of the revised manuscript (L160-175).

C3. Does direct access to geometric measurements trivialize CAD reconstruction?

Direct access to analytic geometry is a central insight of our approach. However, we disagree that accessing geometric measurements reduces CAD reverse engineering to simply transcribing numbers into CadQuery. A B-rep provides geometric information such as surface types, dimensions, and spatial relationships, but does not preserve the modeling operations or construction sequence. The agent must still interpret these measurements, identify geometric features, and infer appropriate modeling operations to reconstruct the shape. In our work, this is done by the investigator.

More importantly, our point-cloud experiments independently support the paper’s main conclusion. In this more challenging setting, the agent must estimate geometric properties from sampled points through programmatic inspection. Notably, CADre-Gemini outperforms all evaluated baselines on all three Hard splits. These results demonstrate the effectiveness of training-free geometric investigation even compared with recent specialized methods

C4. Do we claim that Python-based inspection is superior to fixed utilities in general?

We thank the reviewer for pointing out that our original wording may be too broad. In L263–266 of the original manuscript, we describe Python execution as "the most flexible tool in the suite," enabling targeted geometric queries that fixed utilities cannot capture. We intended to describe its flexibility within our tool suite, rather than claim superiority over all possible predefined utilities. Indeed, any Python execution script could, in principle, be implemented as a predefined utility.

What code execution offers is open-ended flexibility without requiring developers to anticipate every possible geometric query in advance. The agent can dynamically formulate and compose measurements based on the geometry it’s given. For example, in Appendix A.4.2, the investigator analyzes point-cloud coordinates to identify potential feature boundaries, then constructs targeted queries to estimate individual segment dimensions. Such adaptive inspection is not supported by the other tools in our suite, such as the global statistics tool.

We acknowledge that the original wording could be misleading. We have revised Sections 3.4 to improve the clarity (L269-272).

C5. Are the inference budgets comparable between CADre and the baselines?

The inference budgets are not directly comparable, as CADre makes multiple LLM API calls, whereas the baselines employ different inference procedures. Smaller specialized models may cost more over their lifecycle because they may require task-specific data, training, as well as retraining to benefit from newer backbone models. These introduce substantial development, computational, and maintenance costs that are not reflected in inference-only comparisons.

CADre instead leverages frozen frontier LLMs without task-specific training. And importantly, the capability can also be easily upgraded via the agentic harness as the base model gets better.

More broadly, the inference cost of proprietary LLMs is rapidly decreasing and is not necessarily more expensive than open-weight models. For example, on OpenRouter, GPT-6 Luna costs 0.50 per million input/output tokens, compared to 2.00 for Qwen3.6-27B. Crucially, CADre can benefit from increasingly capable and cost-efficient frontier models without task-specific retraining.

2. Questions and Clarifications

Q1. Does the generator see any image?

We thank the reviewer for pointing out this inconsistency. The generator initially receives only the investigator's text description and reconstruction plan. After generating valid CadQuery code, the verifier inspects the predicted and target geometries through code execution and rendering, then returns feedback for subsequent refinement.

After inspecting our implementation, we found that a rendering flag was unintentionally left enabled, causing the verifier's feedback to include comparison images alongside textual feedback. Thus, although the generator cannot actively invoke rendering tools or select viewpoints, it does receive comparison images during refinement. This is the configuration used in Table 1.

We have revised Section 3 (L207-208, L254-257) and the Figure 1 caption (L124-125) to clarify that the generator starts with the investigator’s text description and receives comparison renders during refinement. This clarification does not change our central contribution of training-free agentic CAD reconstruction through programmatic geometry inspection and iterative verification.

Q2. Baseline Inference Configurations.

We followed the official released implementations of all three baselines.

  • For CAD-Recode, we followed its official code demo, which generates a single candidate per shape using the provided inference configuration. However, we acknowledge that its paper also describes a best-of-10 strategy, where 10 point clouds are independently sampled and the best reconstruction is selected based on Chamfer distance.
  • For cadrille, we followed the official implementation with the provided top-k = 1 setting, which effectively performs greedy decoding.
  • For CAD-Reasoner, we followed its official stochastic beam-search implementation, which generates 5 candidates in the first iteration and up to 25 candidates per subsequent iteration. We extended the refinement budget from the default of 5 to 30 iterations and selected the best reconstruction across all iterations based on Chamfer distance, following the selection procedure provided in the official implementation. We have added the baseline inference settings used in Table 1 to Section 4.1.

Q3. How were the metrics aggregated, and what were the invalid-output rates?

In the original submission, Table 1 reported the arithmetic mean of per-shape IoU and Chamfer distance only over valid shapes. Each split contained 50 target shapes, but the denominator could be smaller when some outputs could not be scored. We did not make this clear in the table caption.

In the revised Table 1, we report mean IoU over all 50 targets per split, assigning zero IoU to the invalid shapes. For Chamfer distance, we report the median over valid shapes. We also added per-split valid ratio to appendix A.2 for all methods. Across all 900 runs per model (for both B-rep and PC), Qwen produces 4 invalid outputs in total, while all outputs produced by Gemini are valid.

Q4. Why did Figure 3 and Table 1 disagree?

We thank the reviewer for pointing out this inconsistency. The original Figure 3 and Table 1 used different aggregation procedures, particularly in their treatment of invalid outputs. We have corrected these inconsistencies in the revised version and updated the curves accordingly. The CADre curves and single-pass baselines now match the revised Table 1.

For CAD-Reasoner, Figure 3 shows the reconstruction selected at each refinement step, whereas Table 1 reports the best reconstruction selected across all 30 steps based on Chamfer distance. Therefore, these results can differ.

Q5.Does w/o Global statistics remove the IoU comparison tool?

Yes. In our experiments, the "w/o Global statistics" configuration also removes the IoU comparison tool. We have clarified in Section 4.4 that this ablation removes both the bulk statistics tool and the verifier’s IoU comparison tool.

References

  1. Rukhovich et al. CAD-Recode: Reverse Engineering CAD Code from Point Clouds. ICCV 2025.
  2. Kolodiazhnyi et al. cadrille: Multi-modal CAD Reconstruction with Reinforcement Learning. Submitted to ICLR 2026.
  3. Kabisov et al. CADReasoner: Iterative Program Editing for CAD Reverse Engineering. CVPR 2026 Findings.
  4. Liu et al. Learning CAD Modeling Sequences via Projection and Part Awareness (PartCAD). NeurIPS 2025.
  5. Ding et al. ReACT: Reward-informed Autoregressive Decision CAD Transformer. AAAI 2026.
  6. Nehme and Ahmed. StepCAD: Mesh-to-CAD Code Generation via LLM Policy and Geometry-Guided Search. NeurIPS 2026.
  7. Liang et al. CADCL: Reconstruct Parametric CAD Models from B-rep via Contrastive Learning. Journal of Computational Design and Engineering, 12(10), 176–184.
  8. Kim et al. BrepCoder: A Unified Multimodal Large Language Model for Multi-task B-rep Reasoning. ECCV 2026.
  9. Deng et al. BrepLLM: Enabling Large Language Models to Understand Boundary Representations. ECCV 2026.
  10. Hao et al. PP-Brep: Few-Shot B-rep Classification with Hybrid Graph Representation. CVPR 2026.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Response

We thank the reviewers for their constructive feedback, which have helped us improve the clarity and quality of our manuscript. We have responded to each review individually and highlighted the manuscript revisions in light blue. The main updates are summarized below:

  • Clarification of our contribution. We clarify how CADre differs from existing tool-augmented systems such as CAD-Assistant and ViperGPT. We also expanded our related work discussion to highlight that recent CAD reverse-engineering methods, including PartCAD, ReACT, and StepCAD, continue to rely on trained point-cloud encoders, while CADCL and BrepCoder use learned encoders even for directly queryable B-rep inputs. These works demonstrate that reliance on trained 3D encoders remains common in CAD reverse engineering. In contrast, CADre can leverage frozen LLMs to autonomously inspect CAD geometry through programmatic queries and reconstruct editable CAD programs, without learned 3D encoders or task-specific training.

  • Additional analyses of CAD functions and tool usage. We added an analysis of the diversity of CadQuery functions in the generated programs (Appendix A.3), as well as how frequently CADre uses different geometry inspection tools (Appendix A.4). CADre uses 76–95 distinct CadQuery functions, compared to 18 used by the specialized baselines. These analyses provide further insights into how CADre utilizes flexible modeling operations and programmatic inspection to reconstruct different geometries.

  • Clarification of metric aggregation and evaluation protocol. We corrected inconsistencies in metric aggregation between Table 1 and Figure 3. The revised results report mean IoU over all target shapes, assigning zero to invalid outputs, and median Chamfer distance over valid outputs. We also added per-split validity rates, clarified the inference configurations of all baselines, and clarified that the generator receives comparison renders during refinement.

  • Additional case studies and limitations. We added two case studies demonstrating how CADre can reconstruct shapes with internal structures through programmatic geometry inspection (Appendix A.9). In both cases, the agent identifies internal features through code execution before using rendering to verify its findings. We also further discussed the failure mode of point-cloud inputs, particularly when reconstructing small geometric features and hidden internal structures. (Appendix A.10).

  • Discussion of inference costs and training-free, agentic advantages. We clarify that inference budgets are not directly comparable across methods. Moreover, the total costs of smaller specialized models may not necessarily be lower, as they also require task-specific data, training, and maintenance, which are not reflected in inference-only comparisons. In contrast, CADre requires no task-specific training and can directly benefit from increasingly capable and cost-efficient frontier LLMs through its agentic workflow. In our original submission, we also provide detailed per-task inference cost breakdowns in Appendix A.2.

We believe these revisions have helped clarify the contributions, experimental results, and limitations of our work. We thank the reviewers again for their valuable feedback and hope that we have adequately addressed 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.