Generative AI for CAD Automation: Leveraging Large Language Models for 3D Modelling

Harsh Vardhan; Sarthak Kapoor; Sumit Kumar; Yao Zhao

REVIEW 3 major objections 4 minor 1 cited by

Generative AI for CAD Automation: Leveraging Large Language Models for 3D Modelling

T0 review · 3 major / 4 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read The paper claims that a loop of LLM script generation, headless execution, and error-fed re-prompting can automate simple and moderately complex CAD parts from natural language, but that involute gears and fully constrained frames fail to…

desk verdict A clear but thin feasibility study whose central automation claim is undercut by its own manual refinement step and execution-based success metric. read the letter →

arxiv 2508.00843 v1 pith:CKGKTNE7 submitted 2025-07-05 cs.HC cs.AIcs.SE

Sumit Kumar , Sarthak Kapoor , Harsh Vardhan , Yao Zhao This is my paper · ORCID

classification cs.HCcs.AIcs.SE

keywords largelanguagemodelsgenerativedesignAIcomputer-aidedFreeCADnaturalto3Dmodeliterativerefinementparametricmodeling

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper tries to establish that a large language model, given a natural-language description of a 3D part, can generate a FreeCAD Python script, and that feeding execution errors back into the prompt lets the model correct its own mistakes without human scripting expertise. It reports that this works in one or a few iterations for basic shapes, boolean operations, and moderately parametric parts, but fails for involute gears and fully constrained frames even after the maximum 50 iterations. The authors also record that several 'successful' runs produced geometry that deviated from the requested design, so the measured convergence counts overstate fidelity to the user's intent. The point of the work is to scope where LLM-driven CAD automation is currently viable and what mechanisms—memory retrieval, adaptive prompting, hybrid geometric validation—would be needed to extend it.

What carries the argument

The central mechanism is the error-driven prompt-evolution loop. Starting from an initial prompt $P_i$ and a natural-language design description $d$, the LLM samples an initial script $S = G(P_i, d)$. FreeCAD executes the script and returns an error signal $E = \mathcal{F}(S)$; if $E \neq 0$, a refinement function $f$ constructs the next prompt $P_r^{(t+1)} = f(P_i, E^{(t)})$ by packing the original request, the terminal log (stdout plus stderr), and the last generated script into a new request. The model then produces $S^{(t+1)} = G(P_r^{(t+1)}, d, S^{(t)}, E^{(t)})$ and the cycle repeats until $E^{(t)} = 0$ or the retry cap $T$ is reached. This loop is what converts a stateless LLM API into a closed-loop CAD assistant; the paper's ten test cases are effectively measurements of how many iterations this loop needs as design complexity rises.

What would settle it

Replace the manual refinement-prompt construction with a fully automated error-log-to-prompt step and re-run the ten cases while also comparing each generated solid's dimensions and features against the specification; if the five asterisked 'successful' cases still deviate, or if Cases 8 and 10 still hit the 50-iteration cap when the correct involute-gear API call is supplied in the initial prompt, the paper's central claim about where the loop succeeds would need substantial qualification.

Watch

Extended reading notes

Core claim

On the paper's own terms, the discovery is that an iterative, error-driven refinement loop converts a stateless LLM into a usable CAD scripting assistant for a bounded class of parts. The generation step samples a script from the model's probability distribution given the prompt and design description, the script is executed headless in FreeCAD, and any stderr/stdout log is packed together with the original request and prior script into a new prompt; the loop terminates when the script runs or the retry cap is reached. Across ten graded cases, the loop converged quickly for levels 1–7 and 9, but cases 8 and 10—an involute gear and a fully constrained frame—hit the 50-iteration cap with persistent errors such as unsupported API calls and null shapes. The paper's own table flags that five of the converged cases did not fully match the requested prompt.

Load-bearing premise

The load-bearing premise is that a manually constructed refinement prompt is a stable, reproducible procedure and that a script that executes without error in FreeCAD is a valid proxy for matching the user's design intent; the paper's own Table 1 shows the second assumption failing in five of ten cases.

Editorial extensions

If this is right

For routine parts—cubes, cylinders, filleted cuboids, boolean unions and subtractions—the loop usually succeeds on the first attempt, with execution times under 30 seconds and no refinement needed.
For moderately parametric parts, one to three refinements correct syntax and constraint errors, keeping total time around a minute; the paper reports this for the plate-with-holes, hinge, and cutout-plate cases.
For highly constrained or specialized geometry—an involute gear and a fully constrained rectangular frame—the loop exhausts its 50-iteration cap and does not converge, with errors such as unsupported API calls and null shapes.
Successful execution does not guarantee that the generated model matches the prompt; the paper's Table 1 marks five of the ten cases where the script ran but the geometry deviated from the requested design.
The paper concludes that extending the approach will require memory retrieval of past fixes, adaptive prompt engineering, and hybrid rule-based geometric validation rather than relying on a stateless LLM alone.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

Editorial inference: because the refinement prompt is constructed manually (Section 2.4), the reported iteration counts measure a human-in-the-loop system, not a fully autonomous one; automating that construction is the natural next test.
Editorial inference: a stricter evaluation that compares the generated solid's dimensions and features to the specification—rather than checking only that the script executes—would likely raise the iteration counts for the five asterisked cases, since the paper already acknowledges deviations.
Editorial inference: the gear failure is triggered by the missing FreeCAD API call $\texttt{Part.makeGear}$; if the correct involute-gear API were supplied in the initial prompt, the model might converge quickly, shifting the bottleneck from reasoning to domain-specific API knowledge.
Editorial inference: because the experiments use a single LLM, the numerical results should not be assumed to transfer to other models; a comparative run across models would separate the framework's contribution from the specific model's ability.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Small feasibility study, not a new method. The idea—generate a FreeCAD script from natural language, run it, feed errors back, repeat—is exactly what Query2CAD, CAD-LLM, and the LLM-as-mechanical-designer papers already do, and the authors cite them honestly. What this adds is a 10-case FreeCAD-specific test and a table of iteration counts and runtimes. That is a modest empirical contribution, and the paper is clearly written and admirably frank about its failures on constrained geometry.

The soft spots are load-bearing, not cosmetic. Section 2.4 contradicts itself: one bullet says refinement is handled manually by constructing a new prompt and LangChain is not involved; the next says LangChain constructs the refined prompt. Equation (4) defines a refinement function f that is never specified. Appendix A promises the full set of prompts but delivers only natural-language task descriptions—no structured initial prompt and no refined prompt. So every iteration count in Table 1 depends on unsighted human edits, and the headline number of refinements is not reproducible.

The success metric is also the wrong proxy. Table 1 counts Cases 3, 5, 6, 7, and 9 as converged while asterisking that they did not fully align with the prompt. A script that runs but produces the wrong geometry is not a successful CAD automation. With five of ten "successes" deviating from the requested design, the conclusion that LLMs "perform well for simple to moderately complex designs" overstates what the data show. The two hardest cases hit the 50-iteration cap and failed, which is honest but not a demonstration of capability.

On the positive side, the equations in Section 2 are definitions of the loop, not fitted derivations, so there is no circularity. The limitations are stated explicitly. The authors are not hiding their negative results. But the gap between what they claim (an automated pipeline) and what they ran (a human-in-the-loop exercise with one trial per prompt, no model version, temperature, or seed reported) is too wide for a serious journal.

My recommendation: don't send this to peer review in its current form. It could become a respectable workshop paper or a "lessons learned" report if the authors re-run the experiments with automated refinement, disclose the exact prompts, run multiple trials, and check geometric fidelity quantitatively. As is, it is a useful data point for someone working on text-to-CAD, but not a paper that is ready for referee time.

Referee Report

3 major / 4 minor

Summary. The paper proposes an LLM-driven CAD automation framework in which GPT-4 generates FreeCAD Python scripts from natural-language design descriptions, executes them in headless FreeCAD, and iteratively refines the scripts using error feedback. The authors report results on ten hand-crafted cases of increasing complexity, claiming that simple to moderately complex designs converge successfully while highly constrained models fail, and they suggest future improvements such as memory retrieval and hybrid validation. The manuscript also includes formal-looking definitions of the generation, execution, refinement, and termination steps.

Significance. If the reported pipeline were fully specified and the evaluation were reliable, the paper would provide a useful empirical data point on the current capabilities and limitations of LLM-based CAD automation. The idea of using execution logs as refinement feedback is pragmatic and worth investigating, and the authors are honest in noting that several outputs deviate from the user prompt (Table 1 asterisks) and that Cases 8 and 10 hit the retry cap. However, the manuscript's central claim is currently not well supported: the refinement loop is described inconsistently, the success metric conflates error-free execution with design fidelity, and the experimental protocol lacks the model version, sampling parameters, seeds, and full prompts needed for reproducibility. I agree with the reader that the equations in Sec. 2 are definitions rather than derivations and that no parameters are fitted, so there is no circularity concern; the issue is operational reproducibility.

major comments (3)

[Table 1] The framework description contradicts itself. The bullet 'LLM with GPT-4 API and LangChain' states that the refinement process is 'handled manually by constructing a new prompt' and that 'LangChain is not directly involved in the refinement loop,' while the next bullet, 'Iterative Refinement Loop,' says that 'LangChain constructs a refined prompt.' This is more than a wording inconsistency: Eq. (4) defines P_r^{(t+1)} = f(P_i, E^{(t)}) but f is never defined, and Appendix A does not provide the structured initial prompt P_i or any refined prompt. As a result, the iterative counts in Table 1 depend on undisclosed human prompt edits and the claimed closed-loop pipeline is not an actual, reproducible procedure. The authors should either specify the automated refinement mechanism precisely (including the prompt template) or reframe the paper's empirical claim as an evaluation of human-assisted, error-log-driven prompting.
[Table 1] The success metric is error-free script execution, not fidelity to the requested design. Cases 3, 5, 6, 7, and 9 are marked with an asterisk indicating that the generated design 'did not fully align with the user's provided prompt,' yet they are counted as 'Converged after N refinements' or 'Success, first attempt.' The abstract and §3.3 conclude that 'LLMs perform well for simple to moderately complex designs,' but half of the reported successes are known geometric mismatches. The authors need a fidelity metric (e.g., checking key dimensions, positions, and constraints in the output geometry) and should report execution success and design-match success separately; the current conclusion overstates the evidence.
[Appendix A] The experimental setup is not reproducible as reported. Section 3.1 says 'GPT-4' but gives no model version (e.g., gpt-4-0613 vs. gpt-4-turbo), temperature, top-p, max tokens, or seed; Table 1 reports a single run per prompt with no variance or error bars. Appendix A, titled 'the full set of ten prompts', contains only natural-language task descriptions, not the structured initial prompt P_i or any refined prompt P_r. Consequently, the iteration counts and execution times in Table 1 cannot be independently reproduced or attributed to a specific pipeline rather than to the authors' ad-hoc prompt construction. The authors should provide the actual prompt templates (or an appendix with the verbatim prompts and refined prompts) and document the LLM API configuration and number of repeated runs.

minor comments (4)

[§2.3] The sentence 'Therefore in the refinement process we are proving the initial user request in P_r' should read 'providing the initial user request in P_r' rather than 'proving.'
[§4] The related-work paragraph cites 'Patel et al., 2023; Gupta et al., 2022' but these works are not listed in the references, and the citation style is inconsistent with the numbered references used elsewhere in the paper.
[Table 2] Table 2 and the appendix describe ten cases, but the appendix does not include the actual prompt text used to generate scripts; it lists only 'Description' fields. The paper should clarify which parts of Appendix A are the exact prompts and which are summaries.
[§5] The conclusion 'these results demonstrate that LLM-driven generation, combined with systematic error handling, can substantially minimize manual steps in routine CAD tasks' is stronger than the data support, given that the refinement step is manual and five of the ten outputs deviate from the prompt; please soften or qualify the claim.

Circularity Check

0 steps flagged · score 2.0 of 10

No circular derivation: Sec. 2 equations are definitions of the loop, no fitted parameter is renamed as a prediction, and the self-citations are background only; residual concerns are evaluation-validity issues, not circularity.

full rationale

The paper's derivation chain is not circular. Sections 2.1–2.3 present Eqs. (1)–(7) as definitions ('Mathematically, we define the generation process as') of script generation, execution, error-driven prompt refinement, and termination; the refinement function f in Eq. (4) is never specified, so no result is forced to equal an input by construction. Table 1 reports observed iteration counts and execution times, and no parameter is fitted to those outcomes, so the 'fitted input called prediction' pattern does not apply. The self-citations in the introduction and related work (e.g., [7], [8], [16]–[20]) are background references only and do not carry a load-bearing premise. The genuine weaknesses are non-circular: Sec. 2.4 first says the refinement process 'is handled manually by constructing a new prompt' and then says 'LangChain constructs a refined prompt,' and Table 1's asterisks concede that Cases 3, 5, 6, 7, and 9 'did not fully align' with the user prompt while still being counted as converged. These are reproducibility and construct-validity problems, not circular reductions; the paper's central empirical claim still has independent content in the measured iteration counts and error logs. Score 2 reflects the minor self-citations and the self-contained (non-externally-benchmarked) evaluation, not a circular derivation chain.

Assumptions & free parameters 3 free parameters · 3 assumptions · 0 invented entities

The central claim depends on unverified experimental infrastructure: a hand-designed prompt, a chosen retry cap, and a domain assumption that FreeCAD's error stream is a sufficient correction signal. No fitted mathematical parameters are used, so the ledger is dominated by experimental-design choices rather than model constants.

free parameters (3)

Maximum retry limit T = 50
Chosen by hand (Eq. 7) and used to declare Cases 8 and 10 non-convergent after 50 iterations; if T were larger, those cases might eventually converge, so it directly shapes the failure result.
Initial prompt template P_i = hand-designed, not disclosed
Contains constraints, syntax rules, and FreeCAD best practices (Sec. 2.1, 2.4); exact wording is not in Appendix A, and script success is sensitive to it.
LLM and sampling configuration = GPT-4, temperature/seed unspecified
Section 3.1 names GPT-4 only; because sampling is stochastic (Eq. 2), the single-run outcomes and timings in Table 1 are not anchored to a reproducible configuration.

assumptions (3)

domain assumption FreeCAD's headless error output is a sufficient signal to drive correction to the intended design.
The whole refinement loop (Sec. 2.2, 2.3) feeds stderr/stdout back to the LLM; Table 1 asterisks show execution success does not guarantee conformance to the prompt.
ad hoc to paper The ten hand-picked prompts span the difficulty spectrum of CAD modeling.
Section 3.2 assigns complexity levels 1 to 10 by assertion; no external benchmark or inter-rater validation is used.
domain assumption LLM APIs are stateless, requiring prompt re-supply.
Section 2.3 invokes statelessness to justify the re-prompt design; this is a property of the API, not derived in the paper.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Generative AI for CAD Automation: Leveraging Large Language Models for 3D Modelling." pith.science (2026). https://pith.science/paper/CKGKTNE7

@misc{pith2026250800843,
  author       = {Pith},
  title        = {Pith review of: Generative AI for CAD Automation: Leveraging Large Language Models for 3D Modelling},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/CKGKTNE7}},
  note         = {Machine review of arXiv:2508.00843}
}

read the original abstract

Large Language Models (LLMs) are revolutionizing industries by enhancing efficiency, scalability, and innovation. This paper investigates the potential of LLMs in automating Computer-Aided Design (CAD) workflows, by integrating FreeCAD with LLM as CAD design tool. Traditional CAD processes are often complex and require specialized sketching skills, posing challenges for rapid prototyping and generative design. We propose a framework where LLMs generate initial CAD scripts from natural language descriptions, which are then executed and refined iteratively based on error feedback. Through a series of experiments with increasing complexity, we assess the effectiveness of this approach. Our findings reveal that LLMs perform well for simple to moderately complex designs but struggle with highly constrained models, necessitating multiple refinements. The study highlights the need for improved memory retrieval, adaptive prompt engineering, and hybrid AI techniques to enhance script robustness. Future directions include integrating cloud-based execution and exploring advanced LLM capabilities to further streamline CAD automation. This work underscores the transformative potential of LLMs in design workflows while identifying critical areas for future development.

Figures

Figures reproduced from arXiv: 2508.00843 by the authors.

**Figure 2.** Output for Case 1. Case 2: Cylinder Description: Create a cylinder with radius = 30mm and height = 80mm. The base of the cylinder should be positioned at (0,0,0) on the XY-plane. Result: Total Execution Time: 20.29 seconds [PITH_FULL_IMAGE:figures/full_fig_p007_2.png] view at source ↗

**Figure 3.** Output for Case 2. Case 3: Cuboid with Fillets Description: Create a cuboid with dimensions length = 100mm, width = 50mm, height = 30mm. Apply a fillet of 5mm to all edges. Position the cuboid such that its bottom face lies on the XY-plane. Result: Total Execution Time: 42.0 seconds Number of iterations: 2 [PITH_FULL_IMAGE:figures/full_fig_p008_3.png] view at source ↗

Figures from the paper (6 more)

**Figure 4.** Figure 4: Output for Case 3 [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]

**Figure 5.** Figure 5: Output for Case 4. Case 5: Boolean Subtraction (Cut Cylinder from Box) Description: Create a box with dimensions 120mm × 60mm × 40mm and a cylinder with radius 10mm and height 50mm. Position the cylinder such that its base is on the XY-plane and its center aligns with …

**Figure 6.** Figure 6: Output for Case 5. Case 6: Parametric Plate with Holes Description: Create a parametric rectangular plate with dimensions length = 150mm, width = 100mm, thickness = 10mm. – Drill four circular holes of radius 5mm, each hole’s center should be located 10 mm from both ad…

**Figure 7.** Figure 7: Output for Case 6. Case 7: Parametric Hinge Design with Constraints Description: Design a parametric hinge with the following specifications [PITH_FULL_IMAGE:figures/full_fig_p010_7.png]

**Figure 8.** Figure 8: Output for Case 7. Case 8: Gear with Custom Tooth Profile Description: Create a gear with the following specifications: - Outer diameter = 120mm. - Inner bore diameter = 20mm. - Number of teeth = 24. - Tooth profile = involute gear profile. Ensure that the gear is cent…

**Figure 9.** Figure 9: Output for Case 9. Case 10: Fully Constrained Parametric Frame Description: Create a parametric rectangular frame with an outer dimension of 250mm × 180mm and a wall thickness of 15mm. The frame should have: - Rounded corners with a radius of 10mm. - Mounting holes (di…

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

Transforming Remanufacturing Automation with Large Language Models: A Forward-Looking Analysis with Case Studies
eess.SY 2026-08 conditional novelty 5.0 of 10

The authors propose ReManGPT, a conceptual orchestration framework for applying LLMs to remanufacturing, and illustrate it with case studies in disassembly planning, repair guidance, and robotic execution.

Reference graph

Works this paper leans on

26 extracted references · 21 canonical work pages · cited by 1 Pith paper

[1]

Valentina Alto. 2024. Building LLM Powered Applications: Create intelligent apps and agents with large language models . Packt Publishing Ltd

work page 2024
[2]

Ben Auffarth. 2023. Generative AI with LangChain: Build large language model (LLM) apps with Python, ChatGPT, and other LLMs . Packt Publishing Ltd

work page 2023
[3]

Akshay Badagabettu, Sai Sravan Yarlagadda, and Amir Barati Farimani. 2024. Query2cad: Generating cad models using natural language queries.arXiv preprint arXiv:2406.00144 (2024)

arXiv 2024
[4]

2024.Facilitating Programming-Based 3D Computer- Aided Design Using Bidirectional Programming

Johann Felipe Gonzalez Avila. 2024.Facilitating Programming-Based 3D Computer- Aided Design Using Bidirectional Programming . Ph. D. Dissertation. Carleton University; Universite de Lille

work page 2024
[5]

Magdy Ibrahim, Robert Krawczyk, and George Schipporeit. 2003. CAD smart objects: potentials and limitations. Education and Research in Computer Aided Architecture Design in Europe ECAADe 21 (2003), 547–552

work page 2003
[6]

Yayati Jadhav and Amir Barati Farimani. 2024. Large language model agent as a mechanical designer. arXiv preprint arXiv:2404.17525 (2024)

arXiv 2024
[7]

Sumit Kumar and Harsh Vardhan. 2025. Cyber security of OT networks: A tutorial and overview. arXiv preprint arXiv:2502.14017 (2025)

work page Pith review arXiv 2025
[8]

Sumit Kumar, Harsh Vardhan, Sneha Priya, and Ayush Kumar. 2023. Malaria detection using deep convolution neural network.arXiv preprint arXiv:2303.03397 (2023)

work page arXiv 2023

Show all 26 references

[9]

Neha Kumari, Sumit Kumar Priya, Ayush Kumar, Akash Fogla, et al. 2024. Auto- matic AI controller that can drive with confidence: steering vehicle with uncer- tainty knowledge. arXiv preprint arXiv:2404.16893 (2024)

2024 arXiv
[10]

John Matsson. 2023. An Introduction to SOLIDWORKS Flow Simulation 2023 . SDC publications

2023
[11]

Himanshu Neema, Daniel Balasubramanian, Harsh Vardhan, Harmon Nine, and Sandeep Neema. 2024. RAMPART: Reinforcement Against Malicious Penetra- tion by Adversaries in Realistic Topologies. In 2024 IEEE Workshop on Design Automation for CPS and IoT (DESTION) . IEEE, 33–39

2024
[12]

Ruoling Peng, Kang Liu, Po Yang, Zhipeng Yuan, and Shunbao Li. 2023. Embedding-based retrieval with llm for effective agriculture information ex- tracting from unstructured data. arXiv preprint arXiv:2308.03107 (2023)

2023 arXiv
[13]

Juergen Riegel, Werner Mayer, and Yorik van Havre. 2016. FreeCAD. Freecad- spec2002. pdf (2016)

2016
[14]

Anupam Saxena and Birendra Sahay. 2007. Computer aided engineering design . Springer Science & Business Media

2007
[15]

Till Speicher, Mohammad Aflah Khan, Qinyuan Wu, Vedant Nanda, Soumi Das, Bishwamittra Ghosh, Krishna P Gummadi, and Evimaria Terzi. 2024. Understand- ing Memorisation in LLMs: Dynamics, Influencing Factors, and Implications. arXiv preprint arXiv:2407.19262 (2024)

2024 arXiv
[16]

Harsh Vardhan, David Hyde, Umesh Timalsina, Peter Volgyesi, and Janos Szti- panovits. 2024. Sample-efficient and surrogate-based design optimization of underwater vehicle hulls. Ocean Engineering 311 (2024), 118777. Conference’17, July 2017, Washington, DC, USA Kumar S., et al

2024
[17]

Harsh Vardhan and Janos Sztipanovits. 2022. Deepal for regression using epsilon- weighted hybrid query strategy. arXiv preprint arXiv:2206.13298 (2022)

2022 arXiv
[18]

Harsh Vardhan, Umesh Timalsina, Peter Volgyesi, and Janos Sztipanovits. 2022. Data efficient surrogate modeling for engineering design: Ensemble-free batch mode deep active learning for regression. arXiv preprint arXiv:2211.10360 (2022)

2022
[19]

Harsh Vardhan, Peter Volgyesi, Will Hedgecock, and Janos Sztipanovits. 2023. Constrained bayesian optimization for automatic underwater vehicle hull design. In Proceedings of Cyber-Physical Systems and Internet of Things Week 2023 . ACM, 116–121

2023
[20]

Harsh Vardhan, Peter Volgyesi, and Janos Sztipanovits. 2021. Machine learn- ing assisted propeller design. In Proceedings of the ACM/IEEE 12th International Conference on Cyber-Physical Systems . 227–228

2021
[21]

Martin Wolf, Anja Elser, Oliver Riedel, and Alexander Verl. 2020. A software architecture for a multi-axis additive manufacturing path-planning tool. Procedia CIRP 88 (2020), 433–438

2020
[22]

Sifan Wu, Amir Khasahmadi, Mor Katz, Pradeep Kumar Jayaraman, Yewen Pu, Karl Willis, and Bang Liu. 2023. Cad-llm: Large language model for cad generation. In Proceedings of the neural information processing systems conference. neurIPS

2023
[23]

Lingfan Yu, Jinkun Lin, and Jinyang Li. 2023. Stateful large language model serving with pensieve. arXiv preprint arXiv:2312.05516 (2023)

2023 arXiv
[24]

Haiyang Zhang, Wei Yan, Huicong Hu, Xumei Zhang, Qingtao Liu, Hong Xia, Yingguang Zhang, and Yuhao Lin. 2025. An LLM-based knowledge and function- augmented approach for optimal design of remanufacturing process. Advanced Engineering Informatics 65 (2025), 103206

2025
[25]

Huixue Zhou, Mingchen Li, Yongkang Xiao, Han Yang, and Rui Zhang. 2023. LLM instruction-example adaptive prompting (LEAP) framework for clinical relation extraction. MedRxiv (2023). Generative AI for CAD Automation: Leveraging Large Language Models for 3D Modelling Conference’...

2023
[26]

Ensure that the gear is centered at the origin and is ready for 3D printing

- Tooth profile = involute gear profile. Ensure that the gear is centered at the origin and is ready for 3D printing. Result: Total Execution Time: 836.46 seconds Number of iterations: 50 STDERR: Exception while processing file: freecad_generated_script.py [module 'Part' has n...

2017

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.

[1] [1]

Valentina Alto. 2024. Building LLM Powered Applications: Create intelligent apps and agents with large language models . Packt Publishing Ltd

work page 2024

[2] [2]

Ben Auffarth. 2023. Generative AI with LangChain: Build large language model (LLM) apps with Python, ChatGPT, and other LLMs . Packt Publishing Ltd

work page 2023

[3] [3]

Akshay Badagabettu, Sai Sravan Yarlagadda, and Amir Barati Farimani. 2024. Query2cad: Generating cad models using natural language queries.arXiv preprint arXiv:2406.00144 (2024)

arXiv 2024

[4] [4]

2024.Facilitating Programming-Based 3D Computer- Aided Design Using Bidirectional Programming

Johann Felipe Gonzalez Avila. 2024.Facilitating Programming-Based 3D Computer- Aided Design Using Bidirectional Programming . Ph. D. Dissertation. Carleton University; Universite de Lille

work page 2024

[5] [5]

Magdy Ibrahim, Robert Krawczyk, and George Schipporeit. 2003. CAD smart objects: potentials and limitations. Education and Research in Computer Aided Architecture Design in Europe ECAADe 21 (2003), 547–552

work page 2003

[6] [6]

Yayati Jadhav and Amir Barati Farimani. 2024. Large language model agent as a mechanical designer. arXiv preprint arXiv:2404.17525 (2024)

arXiv 2024

[7] [7]

Sumit Kumar and Harsh Vardhan. 2025. Cyber security of OT networks: A tutorial and overview. arXiv preprint arXiv:2502.14017 (2025)

work page Pith review arXiv 2025

[8] [8]

Sumit Kumar, Harsh Vardhan, Sneha Priya, and Ayush Kumar. 2023. Malaria detection using deep convolution neural network.arXiv preprint arXiv:2303.03397 (2023)

work page arXiv 2023