See the structure behind your Fusion design.

Contriver Node Atlas reads the parametric dependency structure of your active Fusion design and renders it as an interactive node graph

• Parameters
• Sketches
• Features
• Bodies
• and Construction Geometry

with the directed relationships between them laid out as a map you can explore.

Fusion's timeline shows you the order operations happened in.

Node Atlas shows you how they depend on one another.

what drives what, what a change will ripple into, and where a rebuild failure actually originates.

Key Capabilities

- Interactive Dependency Graph: 

Pan, zoom, and focus any node; trace its upstream or downstream chain to see exactly what it depends on and what depends on it.

- Child Centers: 

Group related features — for example a run of surface operations that stitch into a single body — into named container units;

So you can reason about a region as one thing instead of a scatter of loose nodes.

- Record Relationships the API Doesn't Expose: 

Some real structural dependencies aren't reported by the Fusion API at all — notably Project-to-Surface and open-profile Thin Extrude.

Node Atlas lets you record these explicitly, so they become part of the traversable graph instead of invisible gaps.

- Provenance on Every Edge: 

Each relationship is labeled by how it was established, across four provenance classes — explicit (reported directly by the API), recovered, associative, and manual (recorded by you).

You can always tell what the API reported from what was added by hand.

- Saved Views and Live Updates:

Save arrangements you return to, and let the graph refresh automatically as you change the timeline or parameters.

- Portable Export: 

Node Atlas writes the graph to a local JSON file — the same export the companion MCP server reads (see the +MCP listing).

Where it helps

- Impact Analysis Before a Change: 

see every downstream dependent of a parameter or feature before you touch it.

- Fault Localization: 

when a model breaks on rebuild, resolve the cause to a named region instead of combing the whole timeline.

- Design Comprehension and Handoff:

understand an unfamiliar model's structure, or make your own legible to someone else.

- Teaching parametric Design: 

a live map of design intent for instruction and review.

Contriver Node Atlas + MCP

Your Fusion design's dependency structure, readable by AI.

Everything in Contriver Node Atlas, plus a companion MCP server that exposes your design's dependency graph to AI assistants;

so you can reason over your model's structure in a conversation with tools like Claude Desktop, Claude Code, Cursor, or VS Code.

The add-in builds and visualizes the graph inside Fusion.

The MCP server makes that same graph available to an AI client as a set of read-only tools, so an assistant can trace impact, explain how a design is wired, and localize a failure to a named region.
Grounded in your actual dependency structure rather than guesses about it.

Everything in the stand-alone add-in

The full interactive dependency graph, Child Centers, manual-edge recording, provenance on every edge, saved views, and live refresh — all included.

What the MCP adds — 14 read-only tools

- get_graph:

the whole dependency structure, defaulting to a container view where Child Centers appear as bounded units.

- get_node:

any node by id, with Child Centers addressable as first-class containers.

- trace_dependencies:

the upstream or downstream chain from any node; containers act as walls, so a trace stays at the level you're reasoning about instead of drowning in interior detail.

- get_manual_edges:

the structural dependencies you recorded that the Fusion API doesn't expose

- get_provenance:

the breakdown of how every relationship in the graph was established

And MORE!

Read-only by Design

The MCP server is strictly read-only. it makes no external network calls and sends nothing to any AI provider on its own.

it reads the local graph file the add-in writes and returns it to your client and your clients own model does the reasoning.

When you use tools in a conversation, the graph data travels to your AI Client's model provider as part of that conversation,

exactly like any file you choose to share. The server never modifies your design.

Where it Helps

- Faster fault-finding:

Point the assistant at a broken body and let it localize the cause to the named feature that produces it

- Structure-Aware Conversations:

Bring your designs actual dependencies into the same workflow you already use for thinking, writing, and code.

Usage Guide and MCP Configuration Manuals