Spline V2 lets Coding Agents as Real-Time 3D Design Collaborators

The genuinely new thing

Spline didn't bolt an MCP server onto V2 — they rebuilt the editor so MCP is the API. That's the whole Spline V2 AI integration story in one sentence: your coding agent can now sit inside a live 3D scene, see what's there, and change it without flattening it to an image. Released Thursday, Spline V2 ships a local MCP server inside the desktop app for macOS and Windows, registering itself with Claude Code, Cursor, Codex, Google Antigravity, and VS Code the moment the app launches.

That's a real enable. Most AI-3D tools either generate a mesh and hand you a file, or take a screenshot and call it collaboration. Spline's bet is that the AI should edit the same document the designer is looking at, in the same tool, with the same undo stack.

How the wiring actually works

The MCP server isn't a separate download. It's bundled into the rebuilt desktop app. The article is explicit: it does not work in the browser, and there is no standalone server package to install.

When you open the Spline desktop app, it scans for supported AI clients and writes the server entry into their config files. You restart the AI client, and the MCP server is just there — same as any other MCP tool.

# On macOS / Linux, the supported clients Spline looks for:
~/.cursor/mcp.json          # Cursor
~/.config/.../mcp.json      # Claude Code, Codex, Antigravity, VS Code

(Exact paths vary by client — Spline handles the registration; you don't write these by hand.)

Once wired, a prompt flows like this: you type "create a floating island" into Claude Code. Claude turns that into structured MCP tool calls. Spline routes those calls to whichever 3D editor tab is open. If nothing is open, the app creates a new file. The model reads the live scene first, decides what to change, and writes the change back to the same document. You get a live scene back — not a PNG.

What you can actually ask it to do

The article's worked example is the floating island. From there, the surface area is whatever the editor exposes through MCP. A few things the architecture makes natural:

• Generate a mesh from a text prompt. Spline's own AI agent can build or edit a scene from a prompt, so the MCP layer can call it as a tool. "Add a low-poly forest to the back of the scene" is one prompt away.
• Edit existing geometry — properties, transforms, materials — because the model can read the scene before it writes.
• Move between design and code. The model can read the canvas and the code running over it — think Three.js logic, state machines, game loop. It can change the visual and the code in the same turn.
• Keep the project editable. Every change stays inside the Spline project. The designer still owns the timeline, the layers, the undo stack. Nothing gets flattened.

The honest framing: this is design collaboration, not design replacement. The model is a junior designer with read/write access to the same doc.

Setting it up today

The setup is short because the app does the work:

1. Download the Spline V2 desktop app for macOS or Windows from Spline's official site. The article doesn't link a direct installer URL, so go to the vendor rather than guessing at a mirror.
2. Launch it. Let it auto-register the MCP server with your installed AI clients — Claude Code, Cursor, Codex, Google Antigravity, and VS Code. Spline finds them; you don't point it at anything.
3. Restart the AI client you want to use. This is the step people forget — config files only load on launch.
4. Open a 3D scene in Spline, or leave it closed — the app will create one if needed.
5. Prompt normally. Something like:

Create a low-poly floating island with a small house on top
and a torus-shaped portal hovering 2 units above it.

6. Watch the editor tab update. The scene stays live and editable.

Troubleshooting, straight from the article's mechanics:

• Server not appearing in your client? The app only registers on launch. Quit and reopen Spline, then restart the client.
• Browser workflow? Not supported — V2's MCP server is desktop-only. If you live in the browser, this isn't your release yet.
• Client not on the list? The article names Claude Code, Cursor, Codex, Google Antigravity, and VS Code. Anything else is unconfirmed — Spline may add more, but the article doesn't promise it.

What this enables

The interesting workflow isn't "AI draws a cube." It's the loop. A designer prototypes a scene by hand, hands it to Claude Code, asks for a variant, gets a variant that's still in the same Spline file, tweaks it visually, hands it back. The MCP server makes the editor addressable from a coding agent — that's the part that wasn't there in V1.

For builders shipping 3D into a product — interactive hero scenes, configurators, embedded product viewers, game UI — the question stops being "how do I generate an asset" and becomes "how does the asset live in my app." That second question has nothing to do with Spline. It has to do with how you wrap the canvas, share state across platforms, and keep the same component behaving on web, iOS, and Android without writing it three times.

Where the limits are

Read the article and the limits are real:

• Desktop-only. macOS and Windows. No browser, no Linux mentioned.
• The MCP server only ships inside the desktop app. No standalone package, no self-host.
• What the AI can do is bounded by what the editor exposes through MCP. Spline's own AI agent can generate meshes and images; beyond that, the tool surface is whatever Spline publishes.
• The list of supported AI clients is the list in the article. Anything else is unconfirmed.

None of these are blockers for the use case — most 3D-heavy teams run a desktop editor anyway. They're just the lines to draw before you promise a client a workflow.

The durable layer underneath

Spline V2 is worth adopting. The MCP-in-the-editor move is the right bet for 3D tooling, and the setup cost is roughly fifteen minutes. Use it.

The part that doesn't change when Spline ships V3, or when the supported-agent list grows, or when MCP itself gets replaced by whatever comes next, is the runtime your 3D scene ships inside. The asset is the volatile half. The component that hosts the canvas — the one that looks and behaves the same on web, iOS, and Android through a single API — is the durable half. That's the layer OTF owns: you build the interactive 3D experience once, in one component, and it lands on every platform the same way without a parallel codebase.

Spline gives you the scene. The part underneath the scene is what you keep.