Self-Improving CAD Generation Agents with FEA Feedback

6 min read

Source Snapshot

Garden Card

This note is a Quartz-ready system pattern for engineering agents. It shows how a model can generate CAD code while a deterministic controller validates the artifact with geometry checks, rich-view rendering, finite element analysis, typed feedback, and repair loops.

1. Executive Summary

The paper introduces an agent pipeline that converts a free-form engineering brief into an assembled STEP file and validates the artifact with finite element analysis. The agent writes CadQuery code, while a deterministic controller handles execution, rendering, meshing, simulation, requirement checks, and feedback routing.

A structured blueprint and rich-view renderer help the agent inspect and revise the design. The benchmark remains difficult: frontier agents rarely produce fully valid artifacts on the first attempt, but repeated feedback-driven repair improves partial-credit performance and can eventually produce strict passes.

  • Main idea: Engineering-agent quality depends on the artifact-validation loop, not just the generated model or script.

  • Why now: CAD agents can create plausible geometry, but industrial use requires traceable checks for geometry, interfaces, clearances, load paths, stress, displacement, buckling, and metadata contracts.

  • Where it applies: Assisted CAD design, manufacturability checks, simulation-backed repair, engineering validation workflows, and controlled agent pilots.

Decision Signal

Put the agent inside a controlled engineering loop: explicit requirements in, auditable artifact out, deterministic validation, typed failure evidence, then targeted repair.

2. Key Technical Terms

  • CAD generation agent: Agent that generates CAD programs or geometry artifacts from engineering requirements.

  • Finite Element Analysis, FEA: Numerical simulation method for stress, displacement, buckling, modal behavior, and related physical checks.

  • Deterministic controller: Non-black-box control layer that executes code, calls tools, validates outputs, and returns evidence.

  • STEP artifact: Engineering artifact stored in a standard 3D product-data exchange format.

  • CadQuery: Python-based tool for creating parametric CAD geometry.

  • Typed feedback: Structured feedback by failure type, measured value, threshold, selector, load region, or repair scope.

  • Requirement checker: Program that automatically checks whether an artifact satisfies geometric, physical, or metadata requirements.

  • Repair loop: Generate, validate, return evidence, modify, and validate again.

3. Core Notes

3.1 Problem

Plausible CAD geometry can still fail engineering constraints. A part can look correct in a rendered image while violating load paths, stress limits, displacement thresholds, clearances, interfaces, selectors, material assumptions, or metadata contracts.

  • Visual plausibility is not engineering validity.

  • First-shot generation is not enough for industrial use.

  • Engineering agents need validators that can produce repairable evidence.

3.2 Mechanism

The agent writes CadQuery code and exports a STEP artifact. The controller creates isolated workspaces, executes code, runs geometry checks, renders rich views, launches finite element analysis, parses verdicts, and returns typed feedback to the agent for repair.

  • The model proposes and repairs.

  • The controller measures and governs.

  • The engineering record stores artifact versions, solver results, validator outputs, and repair decisions.

3.3 Evidence

The paper introduces Hephaestus-CCX, a benchmark of 50 engineering briefs with executable requirement checkers. Requirements include stress, displacement, modal behavior, buckling, contact, clearance, selectors, and assembly constraints.

  • In the main first-attempt sweep, 400 submissions produce no strict-passing artifacts.

  • After one FEA-feedback round, one strict pass appears across another 400 revised submissions.

  • One FEA-feedback round improves mean requirement pass by 13.4 percentage points on average across the reported model cells.

  • In the longest GPT-5.5/high run, mean requirement pass rises from 38.8% to 60.5%, with 9 strict-passing artifacts out of 50 cases.

Evidence Boundary

Treat the result as a promising engineering-assistance pattern, not proof of autonomous production readiness.

3.4 Boundary

The pattern is not production certification. Generated artifacts should not be used for safety-critical, regulated, or manufactured designs without independent review and validation.

  • Validate solver configuration, meshing stability, selector binding, units, material properties, requirement provenance, and approval boundaries.

  • Keep human engineering sign-off mandatory for high-consequence decisions.

  • Use the pattern first where deterministic evaluators already exist.

4. Concept Map

Use wikilinks to connect this note into the broader Quartz graph.

flowchart LR
  A["Engineering Brief"] --> B["Typed Blueprint"]
  B --> C["CadQuery Program"]
  C --> D["STEP Artifact"]
  D --> E["Rich-view Inspection"]
  D --> F["Requirement Checks"]
  D --> G["FEA Simulation"]
  E --> H["Typed Feedback"]
  F --> H
  G --> H
  H --> I{"All Requirements Pass?"}
  I -- "No" --> B
  I -- "Yes" --> J["Human Engineering Review"]

Diagram labels stay in English for rendering consistency and easier reuse across published pages.

5. Source Visual

CAD-agent pipeline with blueprint, STEP assembly, rich-view inspection, and FEA feedback

The paper’s pipeline separates design decisions from execution control. The agent owns planning and CAD-code repair; the controller owns execution, measurement, composition, validation, and feedback routing.

Source credit: Figure 2 in the arXiv HTML version

6. Operating Pattern

The reusable system design is an evidence-producing controller around a model. This pattern is more operationally useful than a model-only benchmark because it defines where creativity, measurement, logging, and approval should live.

engineering_agent_loop:
  input:
    brief: free_form_engineering_requirements
    contract:
      - geometry
      - interfaces
      - selectors
      - physical_limits
  agent:
    owns:
      - blueprint
      - parametric_cad_code
      - repair_decisions
  controller:
    owns:
      - isolated_execution
      - artifact_export
      - deterministic_measurement
      - rich_view_rendering
      - meshing
      - fea
      - typed_requirement_verdicts
  retry:
    feedback:
      - failed_requirement
      - measured_margin
      - selector_or_load_case
      - recommended_repair_scope

Store every artifact version, validator result, solver version, requirement schema, and repair decision. This supports traceability, reproducibility, and controlled human approval.

Implementation Risk

Before using this pattern in production, validate solver configuration, meshing stability, selector binding, units, material properties, requirement provenance, and the approval boundary.

7. Quantitative View

xychart-beta
  title "GPT-5.5/high Mean Requirement Pass During Repeated Feedback"
  x-axis ["Early loop", "Longest reported loop"]
  y-axis "Mean requirement pass (%)" 0 --> 70
  bar [38.8, 60.5]

In the longest reported run, structured feedback and repeated repair increase mean requirement pass from 38.8% to 60.5%, with 9 of 50 artifacts achieving strict passes. The result is meaningful but still far from autonomous production readiness.

8. My Take

This paper gives a concrete blueprint for engineering agents: keep the model creative, but make the surrounding system deterministic, measurable, and auditable. The strategic lesson is that validation and repair loops may matter more than first-shot generation quality.

  • What changed my thinking: The controller is not plumbing; it is the governance layer that makes an engineering agent operational.

  • What I may do next: Identify one manufacturing workflow with an existing deterministic evaluator and design a small agent loop around it.

  • What still needs verification: Solver reliability, mesh stability, unit discipline, requirement schema quality, artifact storage, and human approval triggers.

Reuse Path

Convert this note into a controlled manufacturing-agent pilot where deterministic validators already exist.

References

Graph View

Backlinks