Playing someone
else's piano.

When OpenAI demonstrated their Astra model driving Blender through the Model Context Protocol, the showcase was designed to turn heads: a natural language prompt, a socket flashing in real time, and a 3D asset materializing inside the viewport. On social media, the reaction was predictable. Commentators declared that 3D modellers, game asset artists, and visual effects studios had just been automated away overnight.

If you work in 3D production, the demo was fascinating, but not for the reason the marketing suggested. It was not a breakthrough in artificial creativity. It was a masterclass in how a world-class rendering engine can hide a completely unworkable foundation.

01 The wireframe test

In the promotional clip, the asset looks convincing. It is framed with a shallow depth of field, bathed in soft contact shadows, and rendered with a glossy metallic surface. To anyone whose exposure to 3D comes from playing games or watching animated films, it looks production-ready.

Then a modeller presses Z to turn on the wireframe overlay.

Because large language models have no innate understanding of physical space, they assemble shapes using crude digital cookie-cutters. Take a cylinder, smash a cube through it, hollow out a sphere, and hope the seams hold together.

Look beneath the surface at the wireframe, and you find a geometric crime scene. Instead of clean, orderly rows of polygons that wrap naturally around curves, the surface is glued together from needle-thin slivers and warped, awkward patches. There is no structural grain. If you try to smooth the object or bend it for a character animation, the surface puckers, pinches, and tears itself to pieces.

Look inside the object, and it gets worse. Automated shape-cutting regularly leaves stray surfaces trapped inside solid volumes, alongside open cracks where edges failed to weld. If you put that model into a game engine like Unreal or Unity, shadows leak through solid walls, lighting glitches, and physical collisions behave unpredictably.

Applying textures is just as hopeless. In 3D software, painting a model requires flattening its three-dimensional skin onto a two-dimensional canvas, like unfolding a cardboard box. The AI's automated attempt shatters the surface into thousands of shredded, microscopic scraps. Patterns stretch, colors smudge, and you cannot paint clean surface details onto it.

In studio terms, the model did not generate an asset. It generated a crude digital placeholder: the sort of rough grey shape an artist throws together in three minutes to check camera angles before real work begins. The marketing dressed a placeholder up in cinema-grade lighting and presented it as the death of a craft.

02 Three lines of text

The second illusion is the idea that controlling 3D software is a new frontier capability.

When Anthropic published the Model Context Protocol in late 2024, developers built working Blender MCP servers within forty-eight hours. Before MCP existed, community projects like BlenderGPT were already piping GPT-4 completions into Blender's Python runtime over local WebSockets back in early 2023. The plumbing has been public domain for years.

More to the point, look at what actually crosses that socket:

bpy.ops.mesh.primitive_cylinder_add(radius=1.0, depth=2.0)
bpy.ops.object.modifier_add(type='BEVEL')
bpy.context.object.modifiers["Bevel"].width = 0.05

The model picked two numbers and remembered the string name of a modifier. That is the entire extent of its contribution.

Everything that makes the output look like a solid physical object happened inside software Ton Roosendaal started building in 1994. Joe Eagar and the Blender team spent years designing the underlying data structures that track how millions of points, edges, and surfaces connect without crashing memory. The cutting tools rely on complex mathematical research to keep overlapping shapes from corrupting each other.¹ And Brecht van Lommel's Cycles engine computes the realistic light bounces that make the surface shine.

The model is not a sculptor. It is a typist entering commands into an API designed by human engineers so that people would not have to write matrix transformations by hand.

03 The triangle soup paradox

Here is the central irony. If you want to see what genuine AI 3D modeling looks like, look at the systems specifically built for it.

Research labs have poured fortunes into native generative text-to-3D. Early work like OpenAI's Point-E and Shap-E operated on point clouds and implicit fields.² DreamFusion distilled 2D diffusion into Neural Radiance Fields, taking an hour per asset and giving creatures three faces in the process.³ Modern feed-forward architectures like Stability's TripoSR, Tencent's Hunyuan3D, and Microsoft's TRELLIS reconstruct meshes and 3D Gaussian splats in seconds.^{4, 5}

These models are genuinely learning 3D latent geometry. And when you import their output into a studio pipeline, you get an unmitigated disaster.

When neural models convert abstract mathematical data into a surface, they produce what 3D artists call a triangle soup: an impenetrable crust of hundreds of thousands of microscopic, disorganized triangles, with shadows and reflections permanently baked onto the surface like a photograph.⁶

That is why the Blender MCP demo seemed so striking by comparison. People saw clean rectangular grids, smoothly rounded edges, and realistic reflections, and assumed the AI had finally learned how to build clean 3D objects. But the only reason the mesh was clean is that an AI was kept strictly away from the geometry. Blender's deterministic engine enforced every single line.

04 Spatially blind samplers

This limitation is not a temporary bug awaiting more training data. It is an architectural property of large language models.

An autoregressive transformer is a 1D sequence predictor operating over discrete tokens. It has no coordinate frame, no metric space, and no internal physics engine. Google Research demonstrated this directly with SpatialVLM: frontier models fail basic spatial queries like relative distance or object boundaries because 2D image-text training carries no 3D spatial priors.⁷ Hong and collaborators found the same barrier with 3D-LLM, proving that models cannot interpret coordinates unless explicit 3D features are pumped in through dedicated encoders.⁸

Ask an LLM to build a 3D model directly without software to help it: just a raw text file listing the three-dimensional coordinates and surface points for an ordinary kitchen chair. It produces hallucinatory garbage: points placed inside out, self-intersecting planes, and collapsed volumes. Even MeshGPT, which turned 3D shapes into vocabulary tokens specifically to train transformers on geometry, fell apart once an asset passed a few hundred faces.⁹

As MIT CSAIL pointed out, the only reason LLMs can touch CAD at all is that code is symbolic.¹⁰ Code gives the model linguistic handles: extrude, revolve, bevel, union. The model stays in its comfort zone of text, and offloads every mathematical calculation to the software runtime underneath.

05 The machine code fallacy

This confusion belongs to a wider pattern across generative AI: the belief that models will replace the computing stack from first principles. Enthusiasts talk as though AI will soon bypass compilers, operating systems, and engines to emit raw machine code directly onto bare silicon.

That is not how software works. Nearly forty years ago, Fred Brooks observed that the essence of software is its conceptual structure, while syntax is merely an accidental representation.¹¹ Butler Lampson distilled systems design into one principle: any problem can be solved by another layer of indirection.¹²

When an agent writes code, nobody expects it to emit raw processor opcodes. It writes TypeScript or Rust. It relies on the compiler to check types, LLVM to allocate registers, the kernel to manage memory pages, and system libraries to talk to the hardware. The agent works because those deterministic layers exist, not because it replaced them.

Blender is a compiler for geometry. Its Python API is an Intermediate Representation. When an agent calls primitive_cube_add(), it is writing high-level code targeted at a specialized virtual machine. Claiming the model built the 3D model is identical to claiming that a programmer who types numpy.linalg.inv() personally invented linear algebra and calculated the matrix inversion on raw silicon.

06 Keep building the blocks

There is a quiet irony in the narrative that human developers are being made obsolete. If the current wave of AI proves anything, it is that foundational software engineering is more important than ever.

The building blocks are not something an AI magically creates out of thin air. An agent cannot conjure a robust geometry engine, an exact shape-cutting solver, or a raytracer out of nothing. It can only call them.

More than that, the reason AI workflows feel impressive today is that the tools themselves improved dramatically in recent years. Blender was not this capable a decade ago. It took years of deliberate human work to stabilize the Python API, integrate exact geometric math, rewrite the dependency graph, and optimize viewport rendering. Browser agents only function because web teams spent twenty-five years standardizing accessibility trees, headless runtimes, and the DOM. The agent gets the applause, but human engineers built the levers.

We are standing on the shoulders of giants, and the giants are still doing all the heavy lifting.

Who knows what architectures will emerge a decade from now. Perhaps future systems will develop genuine spatial intuition and invent their own representations from first principles. But at present, that is not how things work. The model does not replace the scaffolding. It climbs it.

The work that matters has not changed. It is still building the engines, the compilers, the libraries, and the robust primitives that make complex computation possible.

When a player piano runs through a performance of Rachmaninoff, nobody congratulates the roll of punched paper. We understand that the paper is merely an encoding. The acoustic resonance, the balanced hammer action, the cast-iron frame, and centuries of instrument craft live entirely inside the piano.

The generic large language model is the punched paper. Blender, Chromium, Linux, and compilers are the piano. OpenAI did not invent 3D modeling with a marketing demo. They wired an autocomplete engine to thirty years of human software engineering, and bet that the audience would never look at the wireframe.