Forgent3D Lets AI Agents Build Editable 3D CAD Models Locally

A new open-source project called Forgent3D is tackling one of the most persistent gaps in AI-assisted design: giving coding agents like OpenAI Codex, Claude Code, and Cursor the ability to generate, preview, and iteratively refine real 3D CAD models — all running locally. The tool introduces a 'code is model' philosophy where 3D geometry is represented as editable, version-controllable code rather than opaque mesh files.

The project, available at forgent3d.com, arrives at a moment when AI coding assistants have become remarkably proficient at writing software but remain largely blind when it comes to understanding the physical geometry they produce.

Key Takeaways

• Forgent3D is a local CAD tool that enables AI agents to write modeling code, rebuild geometry, and preview results in real 3D
• The tool supports a closed-loop workflow: AI writes code, sees a screenshot of the result, checks dimensions, and iterates
• 3D models are stored as code — making them diffable, parametric, and reusable in version control systems like Git
• Currently best suited for mechanical parts, product enclosures, simple assemblies, and kinematic structures
• Compatible with popular AI coding tools including OpenAI Codex, Anthropic Claude Code, and Cursor
• The project is early-stage and open source, inviting community feedback and contributions

Why AI Agents Struggle With 3D Design Today

Large language models have become exceptionally good at generating code. Tools like Cursor (backed by $900M+ in funding), GitHub Copilot, and Anthropic's Claude Code can write complex software across dozens of programming languages. But 3D modeling presents a fundamentally different challenge.

When an AI agent generates code for a 3D shape, it has no way to verify whether the resulting geometry is correct. A function that produces a gear might look syntactically valid but create intersecting faces, incorrect tooth profiles, or dimensions that are off by an order of magnitude. The AI is essentially sculpting blindfolded.

This verification gap is what Forgent3D aims to close. By providing a local CAD engine that rebuilds the model from code and returns visual feedback — screenshots, bounding box dimensions, and build success or failure signals — the tool gives AI agents the equivalent of 'eyes' for 3D geometry.

How Forgent3D Works: A Closed-Loop Design Pipeline

The architecture of Forgent3D centers on a feedback loop that mirrors how a human CAD designer works: create, inspect, revise. But instead of a human clicking through menus, an AI agent drives the entire process through code.

The workflow follows 4 distinct steps:

• Code generation: The AI agent writes parametric modeling code that describes the 3D geometry
• Local rebuild: Forgent3D compiles the code into actual 3D geometry using a local CAD kernel
• Visual feedback: The tool renders a 3D preview and captures screenshots, dimensions, and build diagnostics
• Iterative refinement: The AI reviews the output and modifies the code to fix errors or refine the design

This loop can repeat multiple times, allowing the AI to converge on a correct design through successive approximation. Unlike text-to-3D systems such as Meshy, Tripo, or OpenAI's Shap-E that produce static mesh outputs, Forgent3D generates parametric models that remain fully editable.

'Code Is Model': Why This Paradigm Matters

The most conceptually significant aspect of Forgent3D is its insistence that the model is the code. This is not a novel idea in CAD — OpenSCAD has championed programmatic 3D modeling for over a decade, and CadQuery brings similar capabilities to Python. But combining code-based CAD with AI agents creates something qualitatively new.

When a 3D model is represented as code, it gains several properties that mesh-based models lack:

• Version control: Models can be tracked in Git, with meaningful diffs showing exactly what changed between revisions
• Parametric flexibility: Changing a single variable — say, wall thickness or bolt hole diameter — propagates through the entire design
• Reusability: Components can be imported, composed, and shared as libraries, just like software modules
• AI accessibility: Code is the native language of LLMs, making it far easier for AI agents to understand and modify designs compared to binary CAD formats
• Reproducibility: The same code always produces the same geometry, eliminating ambiguity

This stands in sharp contrast to the dominant text-to-3D approach, where tools like Meshy AI or Stability AI's Stable 3D generate mesh files that are difficult to edit precisely and impossible to parameterize after the fact.

Practical Applications: From 3D Printing to Product Design

Forgent3D is currently best suited for engineering-oriented use cases rather than artistic or organic modeling. The creator highlights several target applications where the tool shows the most promise.

Mechanical parts represent the sweet spot. Gears, brackets, mounting plates, and enclosures are geometrically well-defined and naturally lend themselves to parametric description. An engineer could describe a part to an AI agent — 'create a flanged bearing housing with 4 M6 bolt holes on a 50mm bolt circle' — and the agent could iteratively generate and refine the code until the geometry matches specifications.

Product enclosures and shells are another strong use case. Consumer electronics housings, sensor casings, and IoT device shells often follow predictable geometric patterns that code can express concisely.

Simple assemblies and kinematic structures — hinges, linkages, sliding mechanisms — round out the current capability set. These require not just geometry but spatial relationships between parts, which code handles naturally through variables and constraints.

For the rapidly growing 3D printing community, which is expected to reach a $35 billion market by 2027 according to Grand View Research, Forgent3D could dramatically lower the barrier to creating custom parts. Instead of learning Fusion 360 or SolidWorks, a user could describe what they need in natural language and let an AI agent handle the CAD work.

Industry Context: Where Forgent3D Fits in the AI Design Landscape

The broader landscape of AI-assisted 3D design is evolving rapidly but remains fragmented. On one end, consumer-facing text-to-3D tools like Meshy (which raised $13M in Series A funding) and Luma AI's Genie generate impressive-looking but geometrically imprecise models aimed at gaming and creative applications. On the other end, traditional CAD giants like Autodesk, Dassault Systèmes, and PTC are integrating AI features into their existing platforms but moving cautiously.

Forgent3D occupies a distinctive middle ground. It is not trying to replace professional CAD software, nor is it competing with artistic 3D generators. Instead, it functions as an infrastructure layer that connects the rapidly improving capabilities of AI coding agents with the precise world of parametric CAD.

This positioning aligns with a growing trend in the developer tools space: rather than building monolithic AI applications, creators are building bridges that let existing AI agents interact with specialized domains. Anthropic's Model Context Protocol (MCP), launched in late 2024, embodies this same philosophy — giving AI models standardized ways to connect with external tools and data sources.

What This Means for Developers and Engineers

For software developers who are already comfortable with AI coding assistants, Forgent3D extends their capabilities into the physical world. A developer who has never opened a CAD program can potentially design functional mechanical parts by describing them in natural language and letting their preferred AI agent iterate through Forgent3D's feedback loop.

For mechanical engineers and product designers, the implications are more nuanced. The tool is unlikely to replace expert-level CAD work for complex assemblies or parts requiring advanced surface modeling. However, it could significantly accelerate early-stage prototyping, where speed matters more than polish.

The open-source nature of the project is also significant. Unlike proprietary CAD tools that lock designs into specific file formats and ecosystems, Forgent3D's code-first approach means designs are inherently portable and transparent. This could appeal to the growing maker and open-hardware communities that prioritize openness and reproducibility.

Looking Ahead: Early Stage but Promising Direction

Forgent3D is explicitly an early-stage project, and its creator is actively soliciting community feedback on the direction. Several questions will determine whether the tool gains meaningful traction.

CAD kernel maturity will be critical. Professional CAD software relies on decades of development in computational geometry — Boolean operations, fillet handling, surface intersections — that are notoriously difficult to get right. How Forgent3D handles edge cases in complex geometry will determine its ceiling.

AI model improvements will also play a role. As models like GPT-5, Claude 4, and future Codex iterations become better at spatial reasoning and code generation, the quality of Forgent3D's output should improve correspondingly — without any changes to the tool itself.

The project arrives at an inflection point for AI-assisted design. The combination of increasingly capable AI coding agents, growing demand for custom manufactured parts (driven by 3D printing and on-demand manufacturing), and a cultural shift toward 'everything as code' infrastructure creates fertile ground for tools that bridge these worlds.

Whether Forgent3D itself becomes the standard tool for AI-driven CAD or simply proves the viability of the concept, the 'code is model' paradigm it champions feels like an inevitable evolution. When AI agents can already write, test, and debug software autonomously, giving them the same capabilities for physical objects is a logical — and potentially transformative — next step.