Cadding

Cadding makes CAD as easy as describing what you want. Create, edit, and export 3D-printable parts with AI, directly in your browser.

Comment

Inspiration

Cadding was built to make real CAD work faster and more accessible for people who want to design real, 3D-printable objects without having to master complex traditional CAD software.

Our goal is not simply to generate 3D meshes from text. Cadding is a browser-based CAD environment where users can create and modify precise, editable geometry, work with multiple parts, and prepare designs that can actually be manufactured and 3D printed.

For the WebMCP Challenge, we wanted to take this one step further: make the same CAD environment accessible to external AI agents such as Codex.

What we built

For the challenge, we connected Cadding's CAD system to WebMCP and exposed 35 structured CAD tools to external agents.

These tools give an agent access to a large part of the real Cadding modelling workflow.

An agent can:

  • Inspect the complete live CAD scene and understand existing parts
  • Read exact dimensions, parameters, faces, edges and vertices
  • Create primitives and profile-based geometry using extrusions, revolves, sweeps and lofts
  • Change dimensions, positions, rotations and other editable parameters
  • Add holes, fillets, shells and other features
  • Perform boolean operations between parts
  • Create linear and circular patterns
  • Edit topology
  • Align, assemble and mate multiple components
  • Add mechanical connectors and joints
  • Work directly with the same editable CAD scene that the user sees

A typical agent workflow can look like:

$$ \texttt{cad.get_scene} \rightarrow \texttt{cad.inspect_part} \rightarrow \texttt{cad.get_faces} \rightarrow \texttt{cad.add_profile_shape} \rightarrow \texttt{cad.edit_part} \rightarrow \texttt{cad.fillet_edges} $$

This is important because the agent is not generating an isolated mesh, and it is not trying to control Cadding by guessing where to click.

Through WebMCP, the agent operates the actual modelling system using structured CAD operations.

Every operation happens inside the live Cadding project, so the human and the AI agent are working on the same editable model.

How we built it

One of the most important parts of Cadding is the Cadding API.

We originally developed this API to give our own AI agent a simple and reliable way to interact with the CAD editor. For the WebMCP Challenge, we extended that architecture so external agents could use the same modelling capabilities.

Instead of building a small set of WebMCP-specific demo commands, we connected WebMCP directly to Cadding's canonical CAD API.

The architecture is:

$$ \text{External Agent} \rightarrow \text{WebMCP} \rightarrow \text{Cadding API} \rightarrow \text{CAD Engine} \rightarrow \text{Live Editable Scene} $$

This means the WebMCP integration is not a separate prototype sitting next to Cadding. It is an interface into the real CAD system.

An external agent can first understand what exists:

$$ \texttt{cad.get_scene} + \texttt{cad.inspect_part} + \texttt{cad.get_parameters} $$

and then act on that information using operations such as:

$$ \texttt{cad.add_shape}, \quad \texttt{cad.add_hole}, \quad \texttt{cad.boolean_parts}, \quad \texttt{cad.mate_parts} $$

This allows agents to chain multiple operations together to build and modify much more complex objects.

Biggest challenge

The biggest challenge while building both the Cadding AI agent and the WebMCP integration was making every CAD step extremely easy for an AI model to understand and execute correctly.

CAD becomes complex very quickly.

An agent needs to reason about dimensions, coordinate systems, part relationships, faces, edges, transformations, feature order, boolean operations, assemblies and the constantly changing state of the model.

In simple terms:

$$

\text{Reliable AI CAD}

\text{Clear Tools} + \text{Precise Geometry Context} + \text{Predictable Execution} $$

Because of this, we spent a significant amount of time improving the Cadding API itself.

Our goal was to hide as much unnecessary CAD-engine complexity as possible and turn modelling actions into clear, predictable and structured operations.

Instead of expecting an AI model to understand the internal implementation of a CAD engine, we expose actions that map directly to the modelling intent:

  • Create a part
  • Inspect its dimensions
  • Get its faces or edges
  • Add a hole to a specific face
  • Resize an existing body
  • Round selected edges
  • Subtract one body from another
  • Pattern a component
  • Align two parts
  • Mate two faces together

We also worked extensively on stable identifiers, constrained parameters, clear tool descriptions, validation and useful execution feedback.

This work was critical for making both Cadding's own AI agent and external WebMCP agents more reliable.

What we learned

One of our biggest learnings was that giving an AI model access to tools is not enough.

The way those tools are designed has a huge impact on how capable the agent becomes.

We found that:

$$ \text{Agent Quality} \propto \text{Quality of the Tool Interface} $$

Complex software like CAD contains a large amount of implicit state and domain knowledge. If the interface presented to the AI is ambiguous, the agent quickly becomes unreliable.

By spending months making the Cadding API easier for AI models to reason about, we were able to turn increasingly complex CAD workflows into structured actions that agents can understand and combine.

WebMCP allowed us to take that same agent-friendly CAD interface and make it accessible to external agents.

The result is a shared CAD workspace where humans and AI agents can work together on the same real, editable and 3D-printable models.

Built With

Share this project:

Updates

Submission history