GOPR-CAD: Graph-of-Operations Progressive Reasoning for CAD Generation

Yitian Pang, Yifan Li, Xiaowei Yue, Li ZhengarXiv 2026 · arXiv

TL;DR

GOPR-CAD moves away from the unreliable practice of having Large Language Models (LLMs) write long CAD scripts directly. Instead, it uses an agentic pipeline to progressively build a "Graph-of-Operations" that is then realized by a deterministic compiler, significantly improving the structural accuracy and mechanical validity of generated 3D models.

What Problem Does This Paper Address?

Generating Computer-Aided Design (CAD) models from natural language is a "holy grail" for accessible engineering. However, current LLM-based approaches usually try to generate CAD code (like CadQuery scripts) in a single shot. This is notoriously unreliable for complex mechanical parts.

The problem is two-fold:

  1. Constraint Coordination: LLMs struggle to maintain geometric, topological, and dimensional constraints over long sequences of code. A small error early on propagates, leading to a model that might "look" right but is structurally broken.
  2. Deceptive Metrics: Existing evaluation methods often rely on "execution success" (does the code run?) or visual similarity. As shown in Figure 1, a model can be a valid solid but completely miss the required mechanical features, such as a coaxial bore or a specific hub placement.
Figure 1: The gap between generating an executable CAD model and realizing the mechanical structure specified by the requirement. Existing methods may fail to produce a valid model or may return a valid solid that omits required features and relations. GOPR-CAD constructs an explicit graph of executable operations before deterministic CAD realization.

Methods

The authors propose GOPR-CAD (Graph-of-Operations Progressive Reasoning). Instead of writing code, the LLM acts as a decision agent that constructs an explicit operation graph through four distinct stages:

  1. Design: The agent builds a "design ledger" that captures the core intent, mechanical roles, and dimensional cues from the prompt.
  2. Recall: It maps these intents to specific, encapsulated CAD operations from a fixed library (e.g., "Bore," "Groove," "Hub").
  3. Relation: The agent defines how these operations relate to one another—specifying ownership (hosted_on), alignment (coaxial_with), or repeated layouts.
  4. Parameter: Finally, it fills in the numerical values, propagating dimensions through the graph's dependency structure.

Once this graph is complete, a deterministic compiler takes over. Because the "reasoning" is separated from the "geometric realization," the system avoids the hallucinated syntax errors common in direct code generation.

Figure 2: Overview of GOPR-CAD. A language requirement is progressively transformed into construction intent, executable operation nodes, typed mechanical relations, and complete parameter bindings. The completed operation graph is compiled and executed through a deterministic CAD realization process.

Datasets

The researchers introduced MHCAD, a new benchmark specifically designed to test structural fidelity.

  • MHCAD: Contains 300 requirements for standard mechanical parts (bearings, fasteners, gears) derived from the Machinery’s Handbook. It includes 342 explicit structural checks (e.g., "Is there a central bore?", "Are the holes coaxial?").
  • CADPrompt: An external dataset used to verify that the system generalizes to prompts written by other domain experts.

They also define two critical metrics: Structural Fidelity (SF), which measures correctness among validly generated files, and Structural Yield (SY), which measures the overall success rate across the entire benchmark.

Key Insights and Ideas

  • Decoupling Reasoning from Realization: The biggest "aha" moment is that LLMs shouldn't be "drawing" geometry; they should be "planning" it. By restricting the LLM to a graph of high-level operations, the system leverages the LLM's strengths in logic while relying on traditional CAD kernels for the math.
  • The "Execution Gap": The paper highlights that a 100% execution rate is meaningless if the resulting part is mechanically useless. Their MHCAD benchmark proves that many "state-of-the-art" models have high execution rates but dismal structural yield.
  • Plug-and-Play Backbones: Because the pipeline is training-free and relies on structured interfaces, it works across different LLM families (Qwen, Phi, Granite) without needing model-specific fine-tuning.

Key Results

GOPR-CAD significantly outperformed existing "one-shot" methods:

  • Structural Yield (SY): On the MHCAD benchmark, GOPR-CAD achieved 82.7% SY, compared to just 37.4% for Text2CAD and 30.7% for CADFusion.
  • External Generalization: On the CADPrompt subset, it reached 87.2% SY, showing that its structural advantages aren't limited to its own benchmark.
  • Reliability: While some baselines produced valid STEP files for nearly 100% of prompts, their structural fidelity was often below 40%. GOPR-CAD maintained high fidelity (89.8% SF) alongside high coverage.
Figure 3: Coverage–fidelity tradeoff on the external CAD- Prompt subset (30 prompts; 47 checks). Coordinates show STEP coverage and conditional SF; labels report SY. Only methods with reported results are shown; exact counts are in the supplement.

Limitations and Future Work

  • Single Parts Only: Currently, the system focuses on single mechanical parts. The authors aim to extend the operation graph to handle complex assemblies with mating constraints and motion relations.
  • Reinforcement Learning: The current version is "training-free." Future work could use the structural checks (SF/SY) as a reward signal to fine-tune the agent's policy, making it even more robust.
  • Complex Geometry: While it handles standard mechanical features excellently, extremely organic or non-standard shapes might still require more flexible geometric primitives than the current operation library provides.

Summary updated

Abstract

Generating accurate CAD models requires substantial engineering expertise and careful control of geometry, topology, and mechanical constraints. Text-to-CAD aims to simplify this process, but current LLM-based methods often generate CAD programs directly. Language models remain unreliable when producing long code while coordinating coupled geometric, topological, and dimensional constraints. Consequently, executable programs may still produce structurally incorrect models, which execution rate and rendered appearance may fail to reveal. To address these limitations, we propose GOPR-CAD, an agentic Text-to-CAD pipeline based on Graph-of-Operations Progressive Reasoning. A language model acts as a decision agent over encapsulated CAD operations and progressively constructs an executable operation graph, which a deterministic compiler converts into the final CAD model. This separation requires no additional training and supports different language models. To evaluate structural fidelity, we construct MHCAD, a benchmark of 300 standard mechanical part requirements derived from Machinery's Handbook. Their explicit structures enable reference-free STEP/B-rep evaluation. GOPR-CAD achieves 82.7% Structural Yield on MHCAD, and 87.2% Structural Yield on an external CADPrompt subset.
BibTeX
@misc{pang2026gopr,
  author = {Yitian Pang and Yifan Li and Xiaowei Yue and Li Zheng},
  title = {{GOPR-CAD: Graph-of-Operations Progressive Reasoning for CAD Generation}},
  year = {2026},
  eprint = {2611.11470},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.11470},
}
Figure