CNC programming has always involved a quiet leap of faith. You build a toolpath in CAM, punch in feeds and speeds from a catalog or a gut-feel starting point, pick a machine that "should" have the travel and horsepower for the job, and post the code. The actual validation "does this tool combination make sense?", "does this machine have the rapid traverse and spindle power to hit the cycle time you promised?", "does the vise you picked even fit in the envelope usually happens after the fact?", on the floor, when it's expensive to be wrong.
The Fusion MCP connector changes where that validation happens. Because Claude can read live data out of an active Fusion model (geometry, toolpath parameters, setup information, etc..) and reason over it alongside reference data like tool libraries, machine specs, and workholding catalogs, a programmer can sanity-check a job before it ever leaves the CAM environment.
What the connector actually gives Claude
The Fusion MCP tools expose two directions of access to the active document:
- Read access: Claude can pull geometric properties and design data straight out of the model: stock dimensions, feature geometry, and (in the electronics context) schematic and board data.
- Write access: Claude can update or execute operations against the active model, so it isn't limited to being a read-only reviewer; it can help make changes directly.
That read/write pairing is what makes it useful for more than commentary. Claude isn't just describing what it sees; it can cross-reference the model against outside data (a tool library, a machine database, a vise catalog) and then act on the discrepancy.
Where this fits in a CNC programmer's workflow
Think of three checks that normally require tribal knowledge, a spreadsheet, and a few Slack messages to a senior machinist:
1. Tool selection vs. what's actually stocked
A programmer roughing a steel bracket might default to a familiar 0.5" end mill without checking whether the shop's actual tool library supports the depth of cut they're planning. With model geometry pulled from Fusion and cross-referenced against a structured tool library, Claude can flag a mismatch immediately. For example, a shop's library might include a Kennametal HARVI I HP bull nose end mill rated for high-speed roughing at a 210 SFM surface speed and 0.08 IPT feed per tooth, good for aggressive stock removal, sitting right next to a finishing-oriented ball nose rated for a much lighter 0.03–0.04 IPT. If the CAM operation calls for a roughing pass but the toolpath was built around the finishing tool's geometry, that's a cycle-time (and tool-life) problem worth catching before the post-processor ever runs.
2. Machine selection vs. envelope and dynamics
Fusion knows the stock size and part envelope. Claude can compare that against a machine database to check more than "does it fit." A part that needs 30" of X travel obviously rules out a Haas VF-1 (20" X) but fits a VF-2 (30" X), that part is easy. The harder question is whether the selected machine can actually hit the promised cycle time. A Haas VF‑series machine tops out around 1,000 IPM rapid traverse and roughly 650 IPM cutting feed, while an Okuma GENOS M‑series machine in the same rough envelope class runs closer to 1,575 IPM rapids and 1,260 IPM cutting feed thanks to its Hi‑Cut Pro control. If a time study was built assuming Okuma-class dynamics but the job gets routed to a VF‑series machine on the floor, the estimated cycle time is wrong before the first chip flies, and that error compounds across a production batch.
3. Workholding fit
Once geometry and machine are settled, workholding is the last variable. Claude can check jaw opening, clamping force, and mounting pattern against the part's stock size and the machine's table. A part that needs more than 9" of jaw opening won't clamp in a Jergens self-centering vise rated for a 9.45" max opening with much margin, but it fits comfortably in a Chick System 5 OneLOK rated to 13.78". Getting this wrong doesn't just cost time; it's the kind of thing that stops a job mid-setup.
A concrete validation pass
Here's roughly what an actual review looks like when you point Claude at an open Fusion document with the MCP connector enabled:
- Pull the model: Claude reads stock envelope, critical feature geometry (pocket depths, hole diameters, wall thickness), and the operations already defined in the CAM setup.
- Check tool-to-feature fit: For each operation, Claude compares the assigned tool's diameter, flute count, and corner radius against the feature it's cutting (can this tool actually reach that internal radius without gouging or leaving stock?).
- Check feeds and speeds against machine capability: Using the standard relationships (N = Vc × 3.82 / D for spindle speed, F = N × Z × fz for feedrate), Claude verifies the programmed values are inside both the tool vendor's starting parameters and the machine's max spindle/feed limits. Not just theoretically achievable, but achievable on this machine.
- Estimate and compare cycle time: Combining cutting time (path length / feedrate) with non-cutting time (tool changes, load/unload, probing, air blow) gives a realistic Tcycle, the same structure used in a standard milling time study: total cutting time plus non-cutting auxiliary time, amortized against batch size and OEE.
- Surface the mismatches: Rather than a wall of numbers, Claude reports the two or three decisions that actually change the outcome: "this roughing tool is undersized for the DOC you've programmed," or "this machine's rapid traverse makes your time estimate optimistic by roughly 15%."
- Push corrections back into Fusion: Because the connector supports write operations, Claude can update the flagged parameters directly in the model rather than leaving the programmer to make each edit by hand.
Why this matters for run-time, not just correctness
The interesting part isn't that Claude can catch an obviously wrong tool. It's that machine selection and tool selection interact; a tool that's perfectly valid on one machine's spindle torque curve is marginal on another's, and a cycle-time estimate built on one machine's dynamics quietly becomes wrong the moment the job gets rerouted to a different one on the shop floor. Having a connector that can read the actual CAD/CAM state and reason about it against real specification data turns machine and tool selection from a one-time guess into something that gets re-validated automatically whenever the model, the routing, or the job mix changes.
Getting started
If your team already uses Fusion, enabling the Fusion MCP connector lets Claude read and act on the active document directly. No manual export of geometry or copy-pasting toolpath parameters into a chat window. Pair that with a structured internal reference set (a tool library, a machine spec sheet, a workholding catalog) and the review that used to happen informally on the shop floor can happen at the CAM desk instead, before a program is ever posted.
Contact the experts at IMAGINiTÂ to learn more about smarter manufacturing and what these connected solutions can do for your organization.
