Skip to content
VANGELDER

Apps

A Fusion 360 MCP pipeline for product configurators

One orchestrator, three applications, and about 28 seconds from a prompt to geometry, a render and an A4 spec sheet. Why the pipeline is built from schema-validated MCP tools instead of generated CAD scripts, and what that shape buys a configurator.

18 Oct 2026 · 6 min read

Fusion 360 has a full scripting API. Parameters, sketches, extrudes, fillets, exports — anything the UI can do, Python can do from inside the running application. That makes it the obvious thing to point a language model at, and it is the wrong thing to point a language model at.

The pipeline on our Fusion 360 MCP page is built the other way round. An orchestrator plans the build; Fusion 360, Blender and the layout renderer are each exposed as a small set of schema-validated MCP tools. Four steps — read the request, build the part, render the hero image, compose the sheet — and about 28 seconds later there is a print-ready A4 PDF on disk.

The number worth looking at there is not 28. It is the fact that the model never writes CAD code.

What generated CAD code costs you

Hand a model the adsk.fusion API and you have put the nondeterminism in the worst possible layer: the one that produces geometry someone may eventually manufacture.

The failure mode is a half-built document. A generated script that raises on line 40 has already executed lines 1 through 39, and those operations are in the timeline. There is no transaction around a Fusion script. You do not get a clean failure; you get a document containing part of a part, and a model that will cheerfully try to continue from there.

There is nothing to review. Every run emits a different script. Diffing run four against run five tells you about the model’s phrasing, not about the part. When the output is wrong, the thing you have to debug is code that will never exist again in that form.

There is nothing to test. A test suite over generated code is a test suite over a moving target. Pin the model version and it still drifts; change the model and you start from zero.

None of this is a statement about how good models are at writing Python. It is a statement about where the boundary sits. If the boundary is “the model emits code and CAD runs it”, then the correctness of every part you ship is downstream of a token sampler.

What a tool has that a script does not

Each MCP tool in the pipeline has a typed input schema and a typed return shape. That sounds like plumbing. It is the whole design.

Invalid input never reaches the CAD API. The bridge validates against the schema and rejects before a single call fires. A fin pitch that arrives as a string, a fillet radius that arrives negative, a parameter name that does not exist in the template — none of those become a Fusion operation. This is the one guardrail an LLM genuinely cannot talk its way around, because it is enforced on the other side of the boundary from the model.

The return shape is data, not console output. fusion.export_stl comes back with a file and a size, not a paragraph the model has to parse and interpret. A step that failed is a failed step, not a sentence that reads like success. That distinction is what lets the orchestrator make a decision about the next step rather than a guess.

A tool is a unit of work, not a line of code. In the published transcript, fusion.fillet_all_edges { r:0.5mm } resolves to 192 edges. One decision at the model’s level, 192 operations at Fusion’s level, and the edge-selection logic lives in the bridge where it can be read, tested and fixed once. The same run sets nine user parameters and issues seventeen sketch-and-extrude calls to produce one 82 cm³ body.

The set of things that can happen is the set of tools. That is a reviewable list. Adding a capability is a deliberate act with a schema attached, not an emergent property of a better prompt.

There is one deliberate asymmetry, and it is worth naming because it looks like an inconsistency. The Blender step is blender.execute_blender_code — generated Python, running in Blender. The stat on the page is “0 freeform code paths in CAD”, not zero everywhere. The reasoning is about consequence: a bad shader wastes the fourteen seconds Cycles spends on the render and you look at the image and re-run it. A bad extrude produces a body that is geometrically valid, visually plausible, and wrong — and that one can travel all the way to a supplier.

The tools are the contract

Because every capability is a schema rather than a prompt convention, the orchestrator is the least load-bearing component in the pipeline. Claude drives it today; Microsoft Foundry, OpenAI or any other tool-calling model drives the same tools without the tools changing.

That is a portability claim, and portability claims are usually softer than they sound, so here is the specific version. What is model-specific in this pipeline is the planning: which tools to call, in what order, with which values. What is not model-specific is everything that touches Fusion, Blender or the PDF. Swap the orchestrator and you may get a different plan. You cannot get a different set of legal operations, because the schemas did not move.

For anything running against a customer’s product catalogue, that matters more than raw model quality. Model choice becomes a procurement question — where it runs, under what terms, at what latency — rather than an architectural one.

Why this shape suits a configurator

A configurator is a parameter contract with a form on the front. The customer picks a fin count, a pitch, a mounting pattern; those choices have to end as geometry, an image and a document, reliably, on the hundredth configuration as much as the first.

Three properties of the pipeline map directly onto that.

The parameters are the interface. Each product family gets a Fusion template and a parameter contract. Nine user parameters drove the heat sink in the published run. A configurator’s option set is the same object seen from the other side — which is also the honest limit of what our page demonstrates: the run it documents is prompt-driven. The architectural point is that the tools accept validated values and do not care whether a person typed them or a form submitted them.

The output is reproducible from the inputs. The build is fully parametric and re-runnable. Change one parameter, re-run, and you get the corresponding part, render and sheet — not a near-miss. Reproducibility is what makes revisions cheap, and a configurator is mostly revisions.

The time budget is legible. About 28 seconds end to end on a laptop, of which the Cycles render is fourteen. If that is too slow for your case, you know exactly which step to attack, and it is not the CAD step. Timings that come out of a pipeline of discrete tools can be attributed; timings that come out of a script cannot.

Where the work actually is

Not in the MCP layer. The pipeline is built on the fusion-general MCP server, paired with blender-mcp for the render. Most CAD-side servers are still community-maintained; Autodesk released its first official ones — Fusion, Fusion Data and Revit MCP servers — as tech previews in April 2026.

The work is in the contracts. A Fusion template per product family, with parameters that are named and bounded rather than implicit. A spec-table schema that says which fields appear and where each one comes from — CAD parameters, ERP, or a YAML side-car. A brand template for the layout, configured once, so nothing between brands is a code change. Localised labels and units if the sheets go out in NL, FR, EN and DE.

That is unglamorous work, and it is the part that determines whether the thing holds up. The pipeline itself does not change between CAD platforms; only the bridge on the CAD side does. Whichever platform you are on, the same question decides the outcome — whether you can write down, precisely and in advance, what a valid product in this family is. Schema-validated tools do not answer that question for you. They do make it impossible to skip.

All insights