How Claude Code took over Blender and started building 3D worlds

What happens if you give an AI full control over Blender, hook it up to powerful 3D APIs, and then step back? With Claude Code, that’s exactly what you can do: turn Blender into an AI-driven 3D lab that can simulate physics, build geometry node setups, and even try to assemble full environments from a single prompt.

This guide walks through how Claude Code connects to Blender, what tools are involved, and—most importantly—what actually works well today and what still breaks.

Why use Claude Code with Blender?

Blender is driven by Python under the hood. Almost everything—from modeling and animation to geometry nodes and simulations—can be scripted. Claude is already strong at writing and debugging code, so when you connect it directly to Blender’s scripting interface, it can operate Blender like a technical artist who never gets tired.

On top of that, a new official Blender MCP (Model Context Protocol) server makes it much easier to expose Blender as a set of tools that AI agents can call. Instead of manually clicking through menus and panels, you can describe what you want in natural language and let Claude generate the code, run it, and iterate.

If you’re new to the idea of controlling 3D tools with AI, it’s worth checking out how AI control of Blender works more broadly in this deeper guide to AI + Blender workflows.

Setting up Blender with the official MCP server

The core of this setup is the official Blender MCP extension, not the older community MCP. You’ll need:

• Blender 5.1 (or the latest supported version)
• The official Blender MCP add-on installed and enabled
• Claude Code installed on your machine

Once the MCP add-on is installed, you can verify it in Blender by going to Edit → Preferences → Add-ons and checking that the MCP entry is active. Make sure:

• The MCP server is marked as running
• Auto-start is enabled so it launches whenever Blender opens

After that, Blender is ready to talk to Claude Code via MCP tools.

Connecting Claude Code to Blender (and APIs)

On the Claude side, you run it from a terminal in a working folder. There are two ways to control permissions:

• Dangerously skip permission: Claude can run tools and commands without asking you each time. This is fast but risky.
• Manual approval: Claude proposes actions and you approve them. Much safer, slightly slower.

For demo purposes, the setup uses the "dangerously skip permission" mode to let Claude operate freely. That’s not recommended for everyday use, especially on machines with important files.

Inside the working folder, a simple .md file with setup instructions is dropped into Claude’s context. Claude then follows those instructions to:

• Install the Blender MCP server dependencies
• Configure any extra AI services

Optionally, you can connect a service like Full AI via an API key to unlock:

• Image generation
• 3D object generation
• Vision and segmentation models
• Material and texture helpers

The API key is stored in a protected .env file so Claude Code can read it without hard-coding secrets into scripts. This is the recommended way to handle keys.

After the MCP tools are installed, restart the Claude Code session once so it can discover the new Blender tools. A quick test command can confirm that Claude can see the current Blender scene and list objects.

Test 1: Physics and tornado-style assembly animation

The first serious test is a complex character animation. The idea:

• A character model is split into separate parts
• Those parts are dropped to the floor using a physics simulation so they scatter naturally
• Then, a "tornado" animation assembles the pieces back into the character

The character itself was created in a 3D generation tool (like Tripo), split into parts, and re-textured. Claude’s job inside Blender was to:

• Set up rigid body physics for the parts
• Run the simulation of the pieces falling and scattering
• Create a procedural animation that swirls the parts in a tornado and reassembles the character

The process took about five iterations:

• First attempts failed to simulate the falling apart correctly
• Later attempts produced a fragmented or inconsistent tornado motion
• With targeted feedback (e.g., "fix the timing", "add one more spin", "make the assembly smoother"), Claude refined the setup

The final result was a convincing physics-based scatter and a stylized tornado assembly. It wasn’t perfect, but it would have been time-consuming to build manually. This is where Claude shines: iterating on complex scripted setups that are tedious to adjust by hand.

Test 2: Geometry nodes for animated water bubbles

The next test focused on geometry nodes—one of Blender’s most powerful but intimidating systems. The task:

• Take a simple water surface (just a plane)
• Use geometry nodes to animate it as bubbling water
• Expose parameters so you can control bubble size, frequency, and spread speed

Claude was asked to:

• Create a new geometry node tree on the plane
• Generate the logic for bubbles rising and animating
• Add user-friendly controls for key parameters

The first version worked functionally but looked wrong: the bubbles were huge and pixelated because the world scale and resolution weren’t handled correctly. After feedback like "increase resolution" and "make the bubbles three times smaller", Claude:

• Debugged the node setup
• Adjusted scales and sampling
• Temporarily hid other objects in the scene to see the water clearly

Crucially, it didn’t delete or damage any existing assets, even while experimenting. With a couple of prompts and minor tweaks to shading (switching from a heavy Cycles setup to something simpler for clarity), the final result was a clean, controllable bubbling water animation—built entirely by AI.

If you’re interested in using Claude Code for broader coding workflows beyond 3D, there’s a useful comparison of its strengths in this article on real-world coding and UI design.

Test 3: Building full 3D worlds from images

The most ambitious experiment was to generate entire 3D locations using a mix of tools:

• World Labs / World Marble for neural 3D reconstructions (Gaussian splats, point clouds, and now colliders)
• Full AI for generating 3D objects and materials
• A custom "Image Blast"-style pipeline wired into Claude Code

The idea was to feed an image or concept, let the pipeline generate a world with environment and objects, then bring it into Blender as a usable scene with colliders and meshes.

How the world-generation pipeline works

The workflow looked roughly like this:

• Clone an "Image Blast"-like project that defines MCP skills for world generation
• Provide API keys for Full AI and World Marble
• Let Claude orchestrate calls to generate the environment and objects
• Preview the result in a web viewer (using a splat renderer like SparkJS)

Each world generation is expensive—sometimes up to $5 or more per world, especially when multiple 3D objects, materials, and passes are involved. In some tests, the total cost per scene reached around $8.

Results: visually impressive, but not production-ready

The generated worlds looked cool in the web viewer, especially stylized scenes like a Japanese environment with objects that seemed to interact with the terrain. But under the hood, they were still mostly splats and point-based representations, not clean meshes.

Attempts to recreate similar results directly in Blender via Claude (using segmentation, top views, and multiple tools) ran into several problems:

• Claude’s vision capabilities struggled with precise spatial reasoning and object placement
• Some objects were rotated incorrectly (e.g., 90 degrees off)
• Scaling and alignment were inconsistent between objects and terrain

Even after two days of experimentation and a lot of API credits, the final island-style scene was far from the original vision. It was a useful stress test, but not something you’d drop straight into a production project.

Trying the same pipeline with CodeX

The same folder and MCP skills were then tested with another model, CodeX. The setup process was similar:

• Ask CodeX to read the existing skills and convert them for its own use
• Let it install and configure the Blender MCP tools

CodeX took a bit more time but handled the process well. Its main advantage was a stronger integrated vision model, which helped with:

• More accurate material scaling (e.g., ice textures mapped at a more realistic scale)
• More consistent object placement on the ground, including small debris

However, even with these improvements, the overall worlds were still not truly production-ready. They looked better than Claude’s attempts in some respects, but the pipeline remained expensive and fragile.

Test 4: Retargeting animation between different rigs

Another advanced test was animation retargeting: taking motion from one skeleton and applying it to another with a different bone structure.

The setup involved:

• A custom character created in a 3D tool like Tripo and auto-rigged with AccuRig (a free rigging tool)
• An animation from Mixamo (for example, a dance loop) exported as FBX
• Both characters imported into Blender: the AccuRig character and the Mixamo mannequin

The challenge is that:

• AccuRig skeletons often have more bones and different naming conventions
• Mixamo rigs are simpler and use different rest poses and orientations

Claude’s approach to retargeting

Claude was asked to write a retargeting system inside Blender that maps Mixamo animation onto the AccuRig character. Initially, the prompt incorrectly stated that both rigs shared the same rest pose. After a long debugging session, Claude itself pointed out that the rest poses didn’t actually match, forcing a prompt rewrite and a fresh attempt.

On the second attempt, Claude:

• Analyzed both skeletons
• Created mapping logic between corresponding bones
• Tested poses and adjusted constraints

There were a few issues along the way:

• Blender crashed once during experimentation, but reopened with auto-recovery
• Claude recognized that it had broken the model and reverted to a working state

The final result was about 90% correct:

• Legs, body, and head motion were retargeted nicely
• Arms and hands had problems due to bone differences and mirrored fingers

Even with those issues, this showed that Claude can get very close to a working retargeter. The next logical step would be to ask it to wrap the logic into a Blender add-on, so you could simply select two armatures and transfer animation with a click.

What works well today (and what doesn’t)

From all these tests, a pattern emerges about where Claude Code + Blender is strong and where it still struggles.

Strengths

• Script-heavy tasks: Anything that involves writing Python for Blender—like geometry nodes setups, simulations, or add-on scaffolding—is a great fit.
• Iterative debugging: Claude is good at reading its own code, spotting issues, and refining logic with your feedback.
• Parameterized setups: Creating node trees and tools with exposed sliders and controls is something it handles surprisingly well.

Weaknesses

• Vision-based spatial reasoning: Tasks that rely heavily on interpreting images and translating them into precise 3D layouts are still unreliable.
• Complex rig differences: Retargeting between very different skeletons works partially but still needs human cleanup, especially for hands and shoulders.
• Costly 3D generation pipelines: End-to-end world generation using multiple paid APIs can quickly become expensive without guaranteeing usable results.

Practical tips if you want to try this yourself

If you’re thinking about giving Claude Code control over Blender, here are some practical guidelines:

• Avoid full auto-permission at first: Start with manual approval so you can see what it’s doing and avoid accidental file changes.
• Use separate test projects: Don’t experiment on your main production files. Keep a sandbox blend file for AI experiments.
• Store API keys in .env: Never hard-code keys into scripts. Let Claude read them from environment files.
• Give clear, structured prompts: Describe your goal, constraints (scale, resolution, performance), and what you want exposed as parameters.
• Expect iteration: Most complex tasks took several rounds of feedback to get right. Treat Claude like a junior technical artist who improves with guidance.

Used thoughtfully, Claude Code plus Blender’s MCP server can feel like having a programmable co-pilot inside your 3D workflow—especially for scripting, geometry nodes, and experimental animations. World-scale generation and advanced retargeting are still rough, but even there, the progress is fast enough that it’s worth keeping an eye on what the next model versions can do.