Physics-in-the-Loop: A Hybrid Agentic Architecture for Validated CAD Engineering Design

1 Introduction

Generative artificial intelligence (AI) has recently gained momentum in engineering design [Zhang et al., 2025; Steininger et al., 2025; Regassa Hunde and Debebe Woldeyohannes, 2022]. Notwithstanding this progress, transferring these methods into real-world engineering practice, where reliable and validated structural integrity is essential, remains largely an open challenge. [Berger et al., 2025; Preintner et al., 2025].

LLM-based generative methods enable the synthesis of parametric CAD models from textual and multimodal inputs [Xu et al., 2025]. However, existing generative CAD systems are predominantly assessed using geometric similarity metrics, which fail to capture functional validity, load-bearing capacity, or other engineering objectives [Berger et al., 2026a]. Generated designs appear visually plausible but lack guarantees of functional correctness or technical feasibility. Recent efforts have attempted to improve reliability and complexity through iterative feedback using Vision Language Models (VLM) to visually verify 2D renders of CAD outputs [Alrashedy et al., 2025; Preintner et al., 2025]. While effective for shape fidelity, visually-evaluated systems do not verify the structural integrity of the generated parts and produce very simple geometries. These approaches use the DeepCAD dataset [Wu et al., 2021], which contains mostly very simple geometries with no labels relevant for engineering design.

1 https://github.com/rapidcad/structbench

In this paper, we formulate generative CAD as a physicsconstrained engineering problem. We propose an Agentic CAD System that uses VLMs to automate mechanical design through an iterative "Generate-Simulate-Refine" loop. Unlike previous works that rely on visual feedback, our method integrates a validated knowledge-based tool into the feedback loop. Our agents receive feedback from physics-based tools to iteratively enhance the output to be not only geometrically valid but structurally sound. We do not train VLMs, but make use of the multi-task in-context capabilities of VLMs.

Thus our approach does not rely on large annotated datasets. Further, we define new metrics and publicize a benchmark dataset for evaluating functional validity in generative CAD. Our method does not depend on existing training datasets, as we leverage the multi-task capabilities of LLMs and VLMs. This allows us to generate designs of high complexity, exceeding prior works by a factor of three in geometric complexity (examples see Figure 1).

Our contributions are as follows:

1. A hybrid multi-agent architecture integrating physics-inthe-loop active decision signal that generates CAD design with exceeding complexity.
2. Systematic comparison of generative, agentic, and hybrid AI paradigms and empirical evidence that physicsguided agents improve reliability and physical validity.
3. A novel benchmark for functional CAD generation under load bearing requirements, made publicly available.

2 RelatedWork

2.1 LLMs for CAD and Engineering Design

DeepCAD [Wu et al., 2021] is the initial paper that pioneered deep learning methods for CAD generation using a design history. Since then several studies demonstrate the ability of LLMs to generate parametric CAD models from textual [Khan et al., 2024b; Wang et al., 2025b; Lv and Bao, 2025; Wang et al., 2025a; Govindarajan et al., 2026; Usama et al., 2025; Berger et al., 2026b], image [T. Chen et al., 2025; Alam and Ahmed, 2025], point cloud [Dupont et al., 2024; Khan et al., 2024a], or multi-modal [Doris et al., 2025; Xu et al., 2025; Kolodiazhnyi et al., 2025] inputs.

Agentic and iterative generation processes have been recently proposed. Preintner et al. integrates an evolutionary optimization loop to iteratively improve generated designs based on visual feedback. Ocker et al. propose a Multi-Agent System driven by a VLM to automate CAD model generation by mirroring the structure of human engineering teams with specialized agents. Alrashedy et al. introduces CADCodeVerify, a method that employs commercial VLMs and prompting to generate CAD code and uses visual tests to verify if the CAD object matches the intended shape.

A shared challenge of these methods is the reliance on a limited training dataset. Public datasets such as DeepCAD [Wu et al., 2021], Fusion360 [Willis et al., 2021], and CADParser [Zhou et al., 2023] contain only a few ten thousand CAD models with little complexity, which is small compared to datasets in other domains.

Other approaches operate on different representations such as Boundary Representation (B-Rep) [Jayaraman et al., 2023; Lambourne et al., 2021] or meshes [Nash et al., 2020] but do not produce CAD models with a design history.

Further, the evaluation of these generative CAD methods has so far been primarily based on geometric similarity metrics such as Chamfer Distance, Intersection-over-Union (IoU), or Normal Consistency. While optimizing replication capabilities, the metrics lack consideration of real-world functional requirements like load-bearing capacity [Preintner et al., 2025; He et al., 2025]. Consequently, this research area would benefit from new data and metrics.

2.2 Agentic AI andMulti-Agent Systems

Agentic AI commonly describes systems in which one or more LLMs are embedded within an execution loop. Agentic systems allow for task distribution, observation of intermediate outcomes, and iterative refinement towards a specified objective. [Plaat et al., 2025; Huang, 2024]. In contrast to single-turn text generation, agentic architectures tightly integrate reasoning with interaction in an external environment. This enables using feedback to improve task completion and reduce hallucinations without requiring updates to model parameters. [Yao et al., 2023; Shen, 2024].

2.3 Knowledge-based Engineering and Hybrid AI

Knowledge-based engineering tools are explicit physical models and formalized design knowledge that, compared to LLMs, have already reached a very mature state [Herrmann et al., 2021]. Established tools such as topology optimization and FEA use physics-based objectives and constraints to reliably produce functionally optimized designs, albeit within restricted domains and no learning on past data. The fundamental gap between generative creativity and validated engineering tools motivates hybrid approaches that combine datadriven AI with knowledge-based tools.

3 ProblemFormulation

With this work we aim to contribute towards AI for engineering design - a discipline that focuses on the creation of technical parts that fulfill specific functional requirements [Pahl et al., 2007]. Engineering design commonly follows an iterative process, where software tools such as CAD and FEA are used to design and validate artifacts digitally [Hirz et al., 2011]. Besides the geometric appearance of an artifact in engineering design its structural and functional performance under physical loads is of key importance [Schulte et al., 1993]. The input for the problem is a structured load case defining how a part is constrained at fixed supports, the forces acting upon it, and the design space within which it is defined. The task is to generate a CAD model that satisfies the load case.

We use an established PyTorch-based FEA solver 2 to evaluate the structural performance and the objective of the AI system is to achieve a safety factor between 2.0 and 5.0, consistent with engineering practice [Budynas and Nisbett, 2020] while minimizing the volume of the part. We use gmsh 3 for meshing with optimization enabled for robustness. We set the material properties to match Aluminum 8081.

4 Load Case Data

We formulate the engineering design problem in terms of load bearing requirements that we formalize in load cases. Existing CAD datasets are not sufficient as they are not annotated with load case information necessary for physics-based validation. To this end, we construct a novel benchmark dataset

2 https://github.com/meyer-nils/torch-fem

3 https://gmsh.info

{ "meta": { "problem_id": "ARCH_BRIDGE", ... }, "design_domain": { "units": "mm", "bounds": { "x_max": 1000.0, ... } }, "spatial_selectors": [ { "id": "support_left", "query": { "x_min": 0.0, "x_max": 50.0, ... } }, ... ], "boundary_conditions": [ { "spatial_selector_id": "support_left", "type": "fixed_displacement", "dof_lock": { ... } } ], "loads": [ { "spatial_selector_id": "deck_surface", "type": "distributed_force", "magnitude_newtons": ..., "direction": ... }, ] }

comprising 20 representative load cases derived from standard mechanical design tasks [Mahamid et al., 2020]. Together with mechanical engineers we crafted the load cases to cover common challenges such as non-concave design spaces and internal holes. Each load case specifies fixed supports, applied forces, and explicit design space constraints. To evaluate generalization under varying constraints, we modify each load case using five distinct geometric scales and five force magnitude scales. As structural stiffness scales nonlinearly with geometric size, variations in scale and loading induce distinct mechanical problems. In total, the benchmark comprises 500 unique load case configurations. Representative samples are illustrated in the left column of Figure 4. An example of the JSON schema is shown in Figure 2. We make the load case data available as JSON files and the CAD models as Python code.

5 SystemArchitecture

We propose a multi-agent framework built on LangGraph that coordinates specialized reasoning agents to enact an iterative "Generate-Simulate-Refine" engineering loop. This architecture formalizes the human design process as a graph of stateful nodes (current plan, CAD code, validator outputs) with directed cyclic execution. Feedback from downstream agents and physics-based tools directly informs upstream decisionmaking (see Figure 3).

5.1 Core Components

The system is composed of four agents, orchestrated by a central control graph:

Planner Agent. This agent acts as the semantic bridge between user intent and geometric modeling. It decomposes load bearing requirements into a specific, step-by-step modeling plan. As input it receives the load case JSON and a visualization of the design space with boundary conditions and forces.

CAD Engineer Agent. The CAD Engineer consumes the structured plan and translates it into executable Python code using the CadQuery library. It ensures that the generated script is syntactically correct and topologically consistent. The CAD engineer agents receives feedback from the geometry reviewer to fix code and modelling errors.

Geometry Reviewer Agent. Receives as input the plan and renders of the CAD object from different angles. Acting as the critic, it checks if the geometry matches expectations, if the proposed part connects forces and constraints, is meshable, and enforces design space restrictions. It has physicsbased tools for verifying connectivity and design space compliance. Its feedback is used to fix modelling errors.

Structural Reviewer Agent. Executes physics-based FEA to assess structural performance, evaluates whether the safety factor is within a specified target range, and identifies stress hotspots or over-engineering. Its feedback is used to refine the plan.

If any physics-based evaluation fails, the Orchestrator routes feedback to the Planner and CAD Engineer for refinement; agents may inspect but cannot modify deterministic evaluation results. A solution is considered valid if and only if all deterministic geometric and physics-based checks pass. The prompt templates are available on the project page.

6 Experimental Setup

We evaluate all models in an inference-only setting without any parameter training. A single disjoint load-case example is provided for in-context learning. The in-context example is excluded from the evaluation set and the model context is cleared after each run to prevent cross-instance information leakage. To assess the capabilities of the proposed agentic framework, we designed a benchmarking protocol that evaluates the system's ability to autonomously generate functional mechanical components from high-level specifications. We benchmark the performance of the architecture using four state-of-the-art VLMs as agents: Anthropic Claude 4.5 Sonnet, Anthropic Claude 4.5 Opus, Google Gemini 3 Pro, and Google Gemini 3 Flash. The task is design a component given the load case and achieve a safety factor within the target range while respecting the given design space. The agents are granted a maximum of 10 iterations per problem to converge on a valid solution. We perform three independent runs per load case and model to account for stochasticity in the generation process.

6.1 EvaluationMetrics

In contrast to previous publications, we do not make use of geometry-based metrics, because in engineering design the functionality is of higher importance than geometric similarity to a reference design [Schulte et al., 1993]. Therefore, we introduce a new set of quantitative metrics to evaluate performance in reliability and design quality. These metrics are closely aligned with real-world engineering utility and are computed deterministically outside of VLMs.

Reliability. Geometry Generation Success Rate (R1): The percentage of generated CAD scripts that execute without geometric errors (e.g., extruding open sketches). Meshing Success Rate (R2): Fraction of geometries that can be successfully meshed. Modeling errors like non-manifold edges prevent meshing. FEA Success Rate (R3): The percentage of generated models that successfully pass the finite element solving stages. Errors like disconnected geometry cause failure.

Design quality. Safety Factor (DQ1): The minimum structural safety factor (yield strength / max stress). Higher values indicate robustness; excessive values indicate overengineering. Structural Efficiency Ratio (DQ2): SFR = Safety Factor/Volume. Identifies designs optimizing the strength-weight trade-off. Number of Faces (DQ3): Number of unique faces in the B-Rep geometry, proxying geometric complexity. This metric captures the trade-off between expressiveness and complexity. Design Space Violation Rate (DQ4): Percentage of designs violating bounding volume constraints. Design Space Violation Magnitude (DQ5): The volume of material generated outside the allowable bounding box, normalized by design space volume.

Process efficiency. We measure the average number of iterations required to reach a valid, target-compliant design (PE1). If no valid design is found within 10 iterations, the run is counted as a failure.

We compare the different models and isolate the impact of physics-based feedback on reliability and design quality by performing statistical analyses.

6.2 Implementation Details

We used commercial cloud providers to run the LLMs, a machine with 48GB of VRAM to run the HXT meshing algorithm with tet4 elements and FEA, and the langgraph orchestration framework is executed on consumer hardware. We set the temperature to 0.5 to promote diverse results, allow for 4096 output tokens and disable thinking. On average a single design interation consumes 12,767 input tokens and 5,606 output tokens that, at the time of writing, costs approximately 0.023 USD (Gemini 3 Flash), 0.093 USD (Gemini 3 Pro), 0.204 USD (Claude Opus 4.5), or 0.122 USD (Claude Sonnet 4.5) in inference costs. The average wall-clock time of one iteration is 28.7±36.9 seconds.

7 Results

The quantitative performance of the different models is summarized in Table 1 for reliability metrics and Table 2 for design quality metrics. Additionally, Table 3 presents the process efficiency in terms of iterations to convergence. Intermodel comparisons revealed highly significant differences in code execution (H=163.04, p<0.01) and FEA success rates (H=46.24, p<0.01), with Gemini 3 Flash significantly outperforming all models (95.6% execution, 84.4% FEA; all pairwise p<0.01).

8 Ablation

In a series of ablation studies, we dissect the contributions of the physics-in-the-loop feedback mechanism and individual agent roles within the architecture. These experiments aim to isolate the impact of each component on overall system performance, providing insights into the efficacy of the hybrid design approach.

8.1 Physics Feedback

We argue that embedding physics-based feedback from FEA into the design loop leads to a marked improvement in the functional validity of generated CAD models. To this end, we conduct an ablation study where we disable the physics-based tools (marked with wrench in Figure 3) of the Reviewer Agents, allowing only feedback based on the visual appearance using VLMs. We observe the achieved safety factor (DQ1) to assess the impact of physics feedback. We set a safety factor target range [2, 5] consistent for general-purpose mechanical engineering [Budynas and Nisbett, 2020], and hypothesize that without physics feedback from FEA, designs will less consistently fall within this range (see Table 4). We performed a Fisher Exact Test [Fisher, 1922] comparing the success rates of achieving target safety factors between FEAenabled (49/83 successes, 59.0%) and FEA-disabled (6/27 successes, 22.2%) conditions across all models, confirming statistical significance (p = 0.0008).

8.2 Iterative Refinement

To isolate the effect of iterative refinement driven by physics feedback, we compare the performance metrics at each iteration of the design loop. Figure 6 illustrates the evolution of the safety factor across iterations. The results show that the safety factor initially exceeds the target range but gradually improves with each iteration, converging to an acceptable level after several rounds of refinement. This underscores the efficacy of the physics-in-the-loop feedback mechanism in guiding the design process towards structurally sound solutions.

8.3 Multi-Agent

Next, we aim to isolate the impact of a multi-agent setup vs. a single LLM and remove the planning and review agents. Instead we formulate the task with a single CAD Engineer agent with access to the physics-based tools that directly generates CAD code from the load case description and refines output from raw FEA results. We observe the average safety factor (DQ1) and convergence (PE1) for randomly sampled inputs in Table 3 to assess if the planner reduces the load of the engineer, accelerating convergence and if the reviewer's structured feedback improves safety factor. We performed a Welch t-test comparing iterations required with planning enabled (n = 80, M = 4.44, SD = 5.36) versus disabled (n = 80, M = 10.77, SD = 10.11), confirming a significant increase in required iterations without planning (t = -3.17, df = 13.39, p = 0.0071, Cohen's d = -1.03).

9 Discussion

We observe that our system is capable of correctly interpreting given load cases and generate complex CAD designs. Visual analysis of the generated CAD code indicates that Claude Sonnet 4.5 frequently produces overly complex geometries that are difficult to mesh and simulate, resulting in lower FEA success rates and high design space violations. In contrast, Gemini 3 Pro generates more efficient designs that balance structural complexity with manufacturability. Notably, the smaller Gemini 3 Flash outperforms Claude Sonnet 4.5 despite its reduced model size. This reveals a "Goldilocks effect" where the mid-tier Gemini 3 Flash excels, likely because it generates simpler, more practical geometries that are easier to mesh and simulate, whereas larger LLMs over-engineer, resulting in modelling errors.

Inspecting the average safety factors in Table 2 of the approved designs, we observe that all models tend to overengineer, producing safety factors close to the upper limit of the target range (5.0). Opus 4.5 hit the iteration limit most frequently (16.3%), followed by Sonnet 4.5 (12.8%).

9.1 Planning the CADDesign

We see that the Gemini models deteriorate less from the removal of the Planner Agent (see results in Table 3). This suggests that these models possess sufficient reasoning capabilities to decompose the design task internally. However, the Planner Agent still provides value by structuring the CAD Engineer's workflow, leading to more consistent code generation. Without the Planner Agent Claude Sonnet 4.5 and Claude Opus 4.5 exhibit larger degradation, indicating that explicit task decomposition is more important for their success.

9.2 Physics-in-the-Loop

The ablation studies indicate that embedding physics feedback in the design loop enables the system to more effectively correct over- and under-engineered solutions. The FEA validation provides concrete, quantitative performance measures that help guide the CAD Engineer in making targeted design adjustments. This feedback loop enables the system to iteratively refine designs towards optimal structural performance, reducing reliance on geometric heuristics alone. However, with more iterations, the results tend to become more unstable. Future work could focus on detecting stopping criteria when a CAD design becomes unrecoverable.

9.3 Failure Type Analysis

Designs most commonly fail due to design space violations and disconnected parts. The distribution is consistent across all tested LLMs with Claude Sonnet-4.5 performing worst across of all failure cases. We attribute high design space violations and connectivity errors to the limited spatial reasoning for load paths of LLMs. FEA-related failures are relatively rare, suggesting that when geometries pass meshing, they are generally well-posed for simulation. Rarely it happens that the area where loads or fixed supports are applied is not filled with material. Figure 7 summarizes the failure type distribution.

9.4 Comparison to Other Methods

Since our method is novel in its problem formulation, there are no directly comparable prior works. However, compared to purely generative CAD systems that lack physics validation, our approach demonstrates 3.4% higher compile rate (IR1) compared to Alrashedy et al. [2025]. We can also compare the complexity of generated geometries: our method achieves an average of 83.1 faces (DQ3) compared to 24.2 faces present in methods based on the DeepCAD dataset [Wu et al., 2021] such as the method by Alrashedy et al. and Preintner et al.. A qualitative comparison is shown in Figure 8.

9.5 Comparison to Topology Optimization

Topology optimization (TO) methods [Bendsøe and Sigmund, 2013] solves the same problem. We compare the execution time of our method on our dataset with a PyTorchbased TO implementation 4 on a machine with 48GB VRAM, with 10 iterations and same meshing parameters and found that TO takes on average 18.6±1.2 seconds to converge whereas our method requires 28.7±36.9 seconds. However, our approach has advantage that it produces editable CAD

4 https://github.com/meyer-nils/torch-fem

models directly with higher fidelity (example shown in Figure 8) while TO produce voxel or mesh-based representations that require additional post-processing like manually tracing design in CAD software.

10 Conclusion

Extensions to dynamic or thermal scenarios or optimization for further criteria, such as sustainability, are left for future research. This can include integrating material selection, manufacturability assessments, and cost-analysis into the design loop. Architecturally, the current prompt-driven incorporation of physics feedback could be replaced with reinforcement learning-based optimization.

We present a hybrid agentic-physical system that combines LLM-based agents with mature engineering tools. The proposed approach generates CAD designs based on load bearing requirements that are structurally grounded and more geometrically complex than those generated by geometry optimized methods, by embedding physics-based validation directly into the agents' decision-making loop. Our results suggest that combining agentic reasoning with knowledge-based engineering tools offers a practical foundation for trustworthy AI-assisted systems in engineering design.