💻 computer science

AgentsCAD: Automated Design for Manufacturing of FDM Parts via Multi-Agent LLM Reasoning and Geometric Feature Recognition

This paper introduces AgentsCAD, a multi-agent system that integrates geometric feature recognition with Large Language Model reasoning to automatically detect FDM printability issues in STEP files and generate valid geometric modifications, such as reorientations and fillets, to ensure manufacturability.

Original authors: Emmanuel George, Christopher Keefe, Peter Pak, Amir Barati Farimani

Published 2026-07-03

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Emmanuel George, Christopher Keefe, Peter Pak, Amir Barati Farimani

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a 3D printer, which works a bit like a very precise, robotic hot-glue gun. It builds objects layer by layer, stacking material on top of what came before. But there's a catch: if you try to print a part that sticks out too far sideways (like a birdhouse roof or a shelf), the glue has nothing to hold onto, and the print collapses. This is called an "overhang."

Usually, when an engineer designs a part, they have to manually check the design, realize it will collapse, and then go back to their computer to reshape it. It's a tedious game of "guess and check" between the design software and the printing software.

AgentsCAD is a new system that automates this entire process. Think of it as a team of specialized robot assistants that take a raw 3D design file, figure out exactly what will break, and fix it for you before you even hit "print."

Here is how the team works, broken down into simple roles:

1. The Translator (The Geometry Parser)

3D design files (called STEP files) are like a secret code written in binary numbers that computers understand but humans (and AI) can't read directly.

The Analogy: Imagine trying to explain a complex house blueprint to a friend who only speaks a different language. You can't just hand them the blueprints; you have to translate them into a simple list: "Here is a flat wall, here is a round hole, and this wall is tilted 90 degrees."
What AgentsCAD does: It reads the secret code and turns it into a structured, easy-to-read JSON list. It tells the AI: "This face is a flat wall, it's tilted 90 degrees, and it's next to this round hole."

2. The Expert Eye (The GraphSAGE Model)

Before the AI can give advice, it needs to know what it's looking at. Is that flat wall just a wall, or is it actually the bottom of a hidden pocket?

The Analogy: Imagine a master carpenter who has studied 60,000 different wooden furniture pieces. When they see a new piece of wood, they don't just see "wood"; they instantly recognize, "Ah, that's a dovetail joint," or "That's a mortise and tenon."
What AgentsCAD does: It uses a smart neural network (trained on thousands of parts) to label every single surface of the 3D model with its "job" (e.g., "this is a pocket," "this is a chamfer"). This gives the AI a deep understanding of the object's shape, not just its numbers.

3. The Architect (The Design Reasoner)

This is the main brain of the operation. It takes the translated list and the expert labels and decides how to fix the print.

The Analogy: This is like a senior architect who looks at your blueprint and says, "If we rotate this house 90 degrees, the roof won't need supports. Or, if we add a little curve (a fillet) to this sharp corner, the glue will stick better."
How it thinks: It uses a "Chain of Thought" process. It doesn't just guess; it talks through the problem. "If I rotate it this way, does the hole still stick out? No? Good. If I add a curve here, will it make the part too weak? No? Good."
The Safety Net: Crucially, this AI doesn't just imagine the rotation; it uses special "tools" to mathematically calculate the exact angle. This prevents it from "hallucinating" (making up) a solution that looks good in its head but is physically impossible.

4. The Inspector (The Visual Verifier)

Once the Architect suggests a fix, the system actually changes the 3D model and then checks the result.

The Analogy: Imagine the Architect draws a new sketch, and then a second, independent inspector (who has eyes, not just a brain) looks at the new drawing from four different angles. The inspector asks, "Do I see a smooth curve here? Is the wall still standing?"
What AgentsCAD does: It renders a picture of the new design and uses a vision AI (like GPT-4o) to confirm that the changes actually fixed the problem and didn't accidentally break something else.

The Result: The "Birdhouse" Test

The paper tested this system on a simple birdhouse model.

The Problem: The birdhouse had two holes (bores) that were pointing straight down. In a normal 3D print, these would collapse because there's no support underneath.
The Fix: The system realized that if you lay the birdhouse on its side (rotating it), one hole becomes safe. For the other hole, which was still tricky, it suggested a "teardrop" shape (a specific curve that helps glue stick).
The Outcome: The system automatically rotated the model, added the curve, and generated a new file that was ready to print without any human intervention.

Why This Matters

Before this, if you wanted to fix a 3D print design, you had to be the expert. You had to know the rules of 3D printing and manually tweak the geometry. AgentsCAD acts as a bridge between the raw 3D file and the rules of manufacturing. It translates the geometry into language, reasons about the best fix, and verifies the result, turning a difficult engineering task into an automated workflow.

In short: It's a team of AI specialists that reads your 3D design, spots the parts that will fail, and automatically redraws them so they can be printed successfully.

Technical Summary: AgentsCAD

Problem Statement

Parts manufactured via Fused Deposition Modeling (FDM) frequently require Design for Additive Manufacturing (DFAM) modifications to ensure printability, structural integrity, and minimal post-processing. While current slicing software can identify defects such as steep overhangs (surfaces tilted beyond ~45° from vertical), they lack the capability to modify the underlying Boundary Representation (B-Rep) geometry. Existing literature addresses isolated sub-problems: Text-to-CAD systems generate new geometry from prompts but cannot modify existing parts; Automatic Feature Recognition (AFR) networks classify face types but do not propose geometric fixes; and manufacturability tools predict defects without generating corrective strategies. Consequently, engineers must manually iterate between CAD and slicer platforms to resolve these issues. There is a critical gap in closed-loop systems that can parse an existing CAD part, reason about its manufacturability, and automatically modify its B-Rep geometry to resolve specific defects.

Methodology

The authors propose AgentsCAD, a multi-agent system that bridges raw B-Rep geometry with Large Language Model (LLM) reasoning to automate targeted DFAM. The system operates on a Blackboard architecture, utilizing a shared-state object to orchestrate nine distinct phases. This design decouples components, allowing for deterministic rule-based stages and interchangeable agents without refactoring coordination logic.

1. Geometric Representation and Parsing

The workflow begins by parsing a STEP file using CadQuery to traverse the B-Rep topology. To make the geometry legible to an LLM, the system converts thousands of faces, edges, and vertices into a structured, compact JSON prompt. This representation includes:

Scalar Attributes: Surface type (Planar, Cylinder, etc.), area, centroid, signed tilt angles, radius of gyration, and elongation index.
Topological Context: An explicit face-adjacency graph (serialized as a links list) encoding shared-edge relationships, which raw scalar arrays cannot represent.
Semantic Augmentation: A GraphSAGE model, trained on the MFCAD++ corpus (59,665 parts), generates 25-class semantic feature labels (e.g., rect_pocket, chamfer) and confidence scores for each face. These are injected into the prompt to provide manufacturing context.

2. Multi-Agent Workflow

The system executes the following phases:

Defect Detection (Rule-Based): A deterministic module flags faces with surface normals satisfying $\theta = \arccos(\hat{n}_{face} \cdot \hat{z}_{plane}) \le 0$ as overhangs. This establishes a verifiable ground truth.
Design Reasoning (LLM): A Claude Sonnet 4.6 agent analyzes the JSON prompt using Chain-of-Thought (CoT) reasoning. It is grounded by Model Context Protocol (MCP) tools (check_orientation_overhangs, lay_face_to_build_surface) to perform "mental rotation" and calculate exact Euler angles, preventing coordinate-transform hallucinations. The agent recommends reorientations, fillets, chamfers, teardrops, or part splitting.
Modification: A script applies the recommended operations programmatically via CadQuery. Reorientation is performed last to preserve face ID integrity.
Visual Verification: A GPT-4o vision-language model inspects rendered views (2048×2048 pixels) of the modified part. It answers targeted yes/no questions regarding geometric integrity (e.g., "Do edges appear smoothly rounded?") and logs failures to the blackboard.
RAG Memory: To accumulate technical nuance across parts without retraining, the system uses Retrieval-Augmented Generation (RAG). Past analysis states are encoded into a FAISS vector store and retrieved to inform the reasoning of new parts.

Key Contributions

Closed-Loop DFAM Automation: AgentsCAD is the first system to the authors' knowledge that modifies an existing part's underlying B-Rep geometry to resolve manufacturing defects, rather than just generating new geometry or predicting defects.
Structured Geometry-to-Language Translation: The paper demonstrates that a structured JSON representation combining scalar descriptors with explicit topological adjacency graphs is sufficient for LLMs to perform contextual DFAM reasoning, overcoming the limitations of raw scalar arrays.
Inductive Feature Recognition: The work validates the use of GraphSAGE over Graph Convolutional Networks (GCN) for CAD feature recognition. GraphSAGE's inductive nature allows it to generalize to unseen STEP files, and its concatenation-based aggregation preserves self-features, outperforming GCN which dilutes local geometry through symmetric normalization.
Necessity of Geometric Grounding: Through ablation studies, the authors demonstrate that MCP tool grounding is a prerequisite for reliable reasoning. Without tools to verify rotations, the LLM consistently hallucinates coordinate transforms with high confidence.

Results

Feature Recognition Performance

On the MFCAD++ held-out test set, the GraphSAGE architecture with UV-net surface normal augmentation achieved state-of-the-art performance:

Accuracy: 85.0%
Macro F1: 0.785
Comparison: This significantly outperformed the GCN baseline (53.8% accuracy, 0.469 Macro F1). The performance gap widened with richer feature sets, confirming that GraphSAGE better exploits additional information without diluting minority class signals.
Visualization: Misclassifications were found to cluster at feature boundaries (transition zones between features and stock material), suggesting future work could benefit from boundary-aware loss weighting.

End-to-End Validation

The system was validated on a birdhouse model containing two cylindrical bores that presented as severe overhangs in the default orientation.

Resolution: The system correctly identified the overhangs, retrieved relevant domain knowledge via RAG, and recommended a reorientation strategy (laying the part on a specific face) combined with a teardrop modification for a remaining horizontal bore.
Outcome: The modified STEP file had zero actionable overhangs. The volume delta was -0.75%, consistent with the material removal expected from the teardrop profile.
Verification: The visual verifier confirmed the geometric integrity, attributing any inconclusive flags to render resolution rather than actual defects.

Significance and Claims

The paper claims that AgentsCAD successfully bridges the gap between B-Rep geometry and LLM reasoning for the specific, tractable problem of overhang resolution. The system produces physically valid, modified STEP files and human-readable manufacturing reports.

The authors emphasize three primary findings:

Structured JSON with explicit topology is sufficient for LLMs to perform complex DFAM reasoning, including stability analysis.
GraphSAGE is superior to GCN for this domain due to its inductive capabilities and preservation of self-features.
Geometric grounding via tools is not an optional enhancement but a fundamental requirement for reliable DFM reasoning; without it, LLMs hallucinate physical transformations.

The work positions itself as a step toward fully automated DFAM, acknowledging current limitations such as context size constraints for large parts, the lack of assembly support, and the reliance on a single reasoning agent. Future work is proposed to include dedicated sub-agents for specific defects (e.g., stress concentration), active GraphSAGE injection, and the eventual integration of next-generation models (e.g., GPT-5) for more conversational, multimodal collaboration.