Claude's Blender MCP Burned 60% of a $200/Month Plan on One Donut — Real Test Results
Claude's Blender MCP took 2 hours, burned 60% of a Max plan's session tokens, and still had clipping and color artifacts. Here's the honest breakdown.
Claude Burned Through 60% of a $200/Month Plan Trying to Make a Donut
The Blender MCP connector for Claude Desktop is real, it installs in about thirty seconds, and it will eat your session tokens faster than you might expect. One honest test: 2 hours of back-and-forth, 60% of a 5x Max plan’s session tokens consumed, and the final render had sprinkles clipping through the plate, a coffee cup clipping into the donut, wrong camera angles, and a magenta color wash that appeared right as the context window gave out. That’s the benchmark. Everything else in this post is context around it.
If you’re evaluating whether to route 3D work through Claude’s MCP integration, that number is the one to hold onto.
What the Blender MCP Connector Actually Is
MCP stands for model context protocol. It’s a backend communication layer — Claude issues commands directly to Blender, not by moving your mouse around the screen. No computer-use theater. The application receives structured instructions from the model, executes them, and returns state. This matters because it means the integration is more reliable than screen-scraping approaches, but it also means Claude needs to understand Blender’s internal API well enough to issue correct commands without visual feedback.
Coding agents automate the 5%. Remy runs the 95%.
The bottleneck was never typing the code. It was knowing what to build.
To set it up: you need the Claude Desktop app, the “control your computer” skill enabled, and the Blender MCP installed. Under Connectors, there’s an install button. That part is genuinely easy. The unofficial version of this has been running for over a year, so the underlying approach isn’t new — Anthropic just made it first-party.
The test used Blender Guru’s donut tutorial as the benchmark. If you’ve spent any time in the Blender community, you know this tutorial. It’s four hours long, it’s the canonical “learn Blender from zero” resource, and the final output is a recognizable donut with icing, sprinkles, and a coffee cup. It’s a reasonable proxy for “can Claude do basic 3D work.”
The answer is: sort of, expensively, and not without supervision.
The Session-by-Session Breakdown
The test started with a simple prompt: “Make me a donut in Blender.” Claude produced something. Not appetizing, but structurally present. The tester then provided a screenshot of the actual Blender Guru tutorial final render and asked Claude to match it.
Claude initially misidentified the screenshot as its own render. Minor confusion, easily corrected. What followed was a series of iterative passes that illustrate exactly where MCP-driven 3D work breaks down.
Pass one: donut and coffee cup appeared. Promising. Pass two: sprinkles went vertical and aggressive — the tester described it as “a donut on Fury Road.” Claude caught the error and laid the sprinkles flat on the next pass, but they were oversized and clipping through the plate. The coffee cup handle got redesigned into something resembling a Bavarian pretzel, unprompted.
Then the camera problems started. Claude went full macro photography on the first “final” render — extreme close-up, heavily overexposed. Asked to pull back, it did, but now the coffee cup was clipping into the donut. The scale was off: either a thimble-sized cup or a giant donut, depending on your frame of reference.
The tester downloaded PBR texture files from the original Blender Guru tutorial and handed them to Claude. While that was happening, Claude decided to place the scene in a desert. No explanation. The textures did load correctly — the donut looked more doughy, the cup had a nice material — but the exposure problem persisted.
One more camera angle adjustment attempt. Then, unprompted, Claude tried to fix the exposure itself and came back with magenta everywhere. This is the context window signal: when the model starts producing color artifacts and congratulating itself on a great image that objectively has problems, you’ve hit the end of coherent context. Claude then began telling the tester the work was done and essentially crashed out of the session.
The final output is better than nothing. It’s worse than what a Blender beginner with a few hours of practice could produce. And it cost 60% of a session on the $200/month 5x Max plan.
Why the Token Cost Is the Real Story
The quality issues are expected at this stage. Clipping geometry, wrong camera angles, exposure problems — these are the kinds of errors you’d expect from any system that’s issuing commands without visual confirmation of intermediate results. They’re fixable with more iteration.
The token cost is the part that changes the business calculation.
Other agents start typing. Remy starts asking.
Scoping, trade-offs, edge cases — the real work. Before a line of code.
If you’re on a 5x Max plan and you burn 60% of your session tokens on one 3D task, you have 40% left for everything else that day. Claude Code, document analysis, code review, whatever else you’re using the plan for. The token management strategies that matter for Claude Code sessions apply here too — context accumulates fast when you’re doing iterative creative work, and there’s no equivalent of a /compact command to trim the Blender conversation history mid-session.
This is a meaningful constraint for anyone thinking about routing production 3D work through Claude. The cost isn’t just the subscription — it’s the opportunity cost of session tokens that can’t be used elsewhere. A skilled Blender artist who knows what they’re doing probably doesn’t need the MCP at all. A non-expert using it as a crutch will burn through tokens faster than they expect and still need to fix the output.
There’s a narrower use case that actually makes sense, and it’s not “replace your 3D artist.” Hiokazu Yokohara demonstrated it: using MCP for complex geometry node graphs, where the value isn’t generating a scene from scratch but navigating and modifying a deeply nested node structure that would take significant manual effort to traverse. That’s the kind of task where backend computer-to-computer communication has a real advantage over a human clicking through menus. The tester acknowledged that doing it by hand might actually be faster in some cases, but the point is the direction — MCP integrations are going to be genuinely useful for complex graph manipulation before they’re useful for creative direction.
What’s Buried in the Failure Modes
The magenta artifact at context limit is worth dwelling on. It’s not just a visual glitch — it’s a diagnostic signal. When Claude starts producing color artifacts and self-congratulatory output simultaneously, the model has lost coherent track of the scene state. The context window has filled with the history of every command issued, every error corrected, every texture loaded, and the model is now pattern-matching on “what does a successful completion look like” rather than actually evaluating the render.
This is a general problem with long agentic sessions, not specific to Blender. The three-layer memory architecture in Claude Code addresses this in a coding context by externalizing state to files. Blender MCP doesn’t have an equivalent mechanism — the session history is the only state, and once it’s full, coherence degrades.
The practical implication: if you’re going to use Blender MCP for anything serious, you want to checkpoint aggressively. Save the Blender file at each meaningful milestone. Start a new Claude session with a fresh context and a description of where you are, rather than letting one session run until it halts. The token cost per session goes down; the total work gets distributed across multiple sessions.
This is also where the comparison to the Adobe connector is instructive. The Adobe MCP operates at Adobe Express level — not Photoshop, not Premiere, not Illustrator, despite being marketed alongside those apps. A 9x16 reframe of a single image took 3 minutes and 14 seconds and didn’t center the subject. A manual Photoshop adjustment of the same type takes about 13 seconds. The Adobe connector isn’t slow because of a bad implementation — it’s slow because it’s routing through Adobe Express’s API, which has its own processing pipeline. The ceiling of what it can do is set by Express, not by Claude.
One coffee. One working app.
You bring the idea. Remy manages the project.
Both connectors share the same underlying limitation: the model is only as capable as the API surface it’s been given access to. Blender MCP has a reasonably deep API surface, which is why it can produce a donut at all. Adobe MCP has a shallow one, which is why it can’t touch Photoshop’s adjustment layers.
The Agentic Workflow Problem Is Separate but Related
The same session that tested Blender MCP also compared a human-edited 30-second short (five cuts, sound effects, an adjustment layer) against a fully agentic one-shot version of the same script. The agentic version was choppy and lacked intentionality. The human version was better, and it wasn’t elaborate — five cuts and some sound effects.
The specific failure mode with agentic video is rhythm across multiple clips. Cance 2.0 and Kling’s Omni model both handle L/J cuts well within a single generation. The problem is stitching multiple 15-second generations together via ffmpeg without editorial judgment. The cuts exist; the flow doesn’t. This is a different problem than the Blender token issue, but it points to the same underlying constraint: agentic systems are good at local optimization and bad at global coherence.
For builders thinking about where to invest in agent infrastructure, this distinction matters. Platforms like MindStudio handle orchestration across 200+ models and 1,000+ integrations with a visual builder for chaining agents and workflows — but the orchestration layer doesn’t solve the coherence problem if the underlying task requires judgment about rhythm, composition, or intent. The infrastructure question and the capability question are separate.
What to Actually Do With This
If you’re a Blender expert, the MCP is probably not useful to you right now for creative work. It’s potentially useful for the tedious parts — finding a specific layer in a complex scene, modifying a node graph you didn’t build, batch-applying a material change across many objects. Tasks where the value is navigation and execution, not creative direction.
If you’re a Blender non-expert hoping the MCP will let you skip the learning curve, the honest answer is: not yet, and not cheaply. You’ll spend tokens, you’ll get something, and you’ll need to know enough to evaluate and fix what you get. The how to save tokens in Claude Code using Opus plan mode approach — plan with a capable model, execute with a cheaper one — doesn’t have a direct equivalent in Blender MCP yet, but the principle of separating planning from execution is worth thinking about.
If you’re building tools that use Claude to generate structured outputs that then get compiled into something deployable, the abstraction question is worth considering. Remy takes a different approach to this problem: you write a spec — annotated markdown — and the full-stack app gets compiled from it, including TypeScript backend, database, auth, and deployment. The source of truth is the spec; the generated code is derived output. That’s a different domain than 3D, but the same principle applies: the quality of the output is bounded by the quality of the specification, not just the capability of the model.
Day one: idea. Day one: app.
Not a sprint plan. Not a quarterly OKR. A finished product by end of day.
The Blender MCP will get better. The context window problem will get better. Token costs will come down. None of that changes the current reality, which is that a two-hour session burning 60% of a $200/month plan to produce a donut with clipping sprinkles is not a production workflow. It’s a proof of concept with a real cost attached.
The useful frame isn’t “does this replace a 3D artist” — it’s “what’s the smallest task where this saves more time than it costs tokens.” Right now, that task is probably narrower than the marketing suggests. Finding it is worth the experiment. Betting your production pipeline on it is not.
The Will Smith eating spaghetti era of 3D AI is real. We’re in it. The question is whether you’re documenting it or depending on it.
