Spline V2 change 3D Design with AI Agent Integration

Spline rebuilt its editor so coding agents can drive it

Spline V2 isn't a feature flag. It's a full architectural rebuild of a 3D editor that now lets external coding agents — Claude Code, Cursor, Codex, Google Antigravity, VS Code — open and edit live, editable scenes as if they were just another file in the repo. That is the genuinely interesting part. Everything else in the announcement is plumbing.

The release notes name the Spline MCP Server as the bridge, but the deeper story is what gets unlocked when an agent that already knows your codebase can also manipulate your 3D scene. No exports, no copy-paste, no separate "design tab" to babysit. You prompt, the editor moves.

Per Spline's developer docs, MCP support is bundled into the macOS and Windows desktop apps — it does not run in the browser. When you launch Spline, the app scans for supported AI clients and auto-registers the local MCP server in their configuration files. You restart the client, prompt normally, and Spline routes the request into an open editor tab.

That's worth sitting with for a second. A coding agent already understands your components, your state management, your routing. Now it also understands the scene you're building. Two surfaces, one model.

The pain it actually kills

Before V2, the workflow looked like this:

1. Sketch in the 3D editor.
2. Export an asset or paste a snippet.
3. Switch to your editor of choice to wire it up.
4. Discover the scene is wrong, switch back.
5. Repeat until something ships.

Every step in that loop is a context switch, and every context switch is a place where intent gets lost. The designer remembers what they wanted; the agent doesn't, because it never saw the scene. Spline V2 collapses two of those switches — the export and the back-and-forth — into a single prompt-driven loop.

The architectural decision matters more than the feature list. Spline didn't add an AI button; they rebuilt the editor so its scene graph is addressable by an external process. That's the difference between a chatbot stuck on the side and a true agent surface.

How the MCP bridge actually works

The plumbing is straightforward once you see the pieces:

• The Spline desktop app bundles a local MCP server.
• On launch, it scans your machine for supported AI clients and registers itself in their MCP config.
• You restart the AI client so the registration takes effect.
• You prompt the client the same way you already do — "build a floating island" is the example from the release.
• The client translates the prompt into structured MCP tool calls.
• Spline routes those calls into an open editor tab against the live document.

The live-document bit is the headline. The scene stays editable the whole time. Whatever the agent does, you can still click in, tweak a material, drag a light, undo a mistake. The agent is a co-pilot with write access, not a one-shot generator that hands you a baked file.

The other thing worth flagging: the scene file is now diff-able. Whatever the agent changes shows up in source control like any other PR. That's a small line in the release notes and a much bigger shift in how a 3D team can actually review work.

What the dual-layer AI actually buys you

V2 ships two AI surfaces at once. There's the external one — Claude Code, Cursor, Codex, Google Antigravity, VS Code — where the agent knows your whole project. And there's a built-in AI agent inside Spline that generates and modifies scenes from text prompts directly in the app. Per the release, the goal is reducing context-switching for developers building interactive 3D web experiences.

In practice that means:

• Use the external agent when the change is coupled to code — wiring a 3D hero into a route, hooking up state, syncing with a CMS.
• Use the built-in agent when the change is purely visual — "make this material emissive", "spawn 200 particles", "rotate the camera 30 degrees on click".

Same scene, two entry points. The expensive part — the part that used to require exports — is gone.

How to actually use it today

This is the part the announcement doesn't walk through, so let's do it concretely.

# 1. Install Spline V2 desktop app (macOS or Windows).
#    The MCP server is bundled — no separate install.

# 2. Launch Spline once. It scans for supported AI clients
#    on your machine and auto-registers the local MCP
#    server in their config files.

# 3. Restart the AI client of your choice so it picks up
#    the new MCP server registration.
#    For Claude Code, for example, restart the CLI session
#    or reload the IDE plugin.

# 4. Open the scene you want to edit. Leave the Spline
#    editor tab open — the live document is the surface.

# 5. Prompt from the AI client, in plain language:

Build a floating island in the centre of the scene.
Add a low-poly tree on top, and animate the camera to
orbit it slowly when clicked.

The client turns that into MCP tool calls. Spline routes them into the open tab. The scene updates, the file is still editable, and the diff is reviewable. A few patterns that pay off immediately:

• Keep the editor tab open during the agent session. It's the live surface — changes only land on what's currently loaded.
• Tell the agent what not to touch when you're iterating on one piece. MCP tool calls are scoped, but explicit constraints avoid surprises.
• Commit the scene file alongside code changes. The agent's edits are diff-able now, so review them like any other PR.
• Browser-only caveat: MCP doesn't run in the browser version. If your workflow is web-only, the desktop app is the new prerequisite.

The part that doesn't move when the model does

Here's where the durable layer matters. Spline V2 makes the 3D scene a first-class surface for agents. Spline isn't the only place that shift is happening — Cursor, Claude Code, Lovable, Bolt, Rork, v0 are all converging on the same idea: agents that touch live UI, not just files.

The model underneath changes every quarter. The output surface does too. What doesn't change is the contract between your scene and the rest of your product: the same 3D hero has to look and behave the same on web, iOS, and Android. Same component, one API, three platforms.

That's the layer worth investing in. Use Spline V2 to drive the scene from whichever agent you trust this quarter. Wrap the embedded scene in a component that's identical across every platform it ships to. When the next model swap lands — and it will — your cross-platform surface stays put while the agent harness underneath rotates.

The two investments aren't competing. Spline V2 handles the prompt-to-scene half. The wrapping handles the scene-to-product half. Together they survive every model churn that's coming.

What this gets us

A scene that an agent can edit while you're typing on the other half of the keyboard. A 3D file that lives in version control like any other source. A prompt that ends with a live document, not a downloaded asset. A built-in agent for visual tweaks, an external one for code-coupled changes.

The interesting test isn't "can the agent make a tree" — Spline V2 already proves that. The test is whether you can ship the result everywhere your users are, with the same component contract, the moment the model behind it changes.

[Source: archynewsy.com — Spline rebuilds 3D editor to support Claude Code and AI agents]