OpenAI Astra Demonstrates 3D Modeling and Software Automation Capabilities

Not long after the release of GPT-6 Astra, no one is even looking at the rankings anymore?

It’s not that the performance was poor; it’s that OpenAI changed its approach and started collecting homework. Developers saw that and thought, fine, we’ll turn it in.

Developer Tom Krcha gave Astra an old steam locomotive blueprint to reconstruct in Blender.

A few minutes later, Blender contained 3,295 editable, independent objects: boilers, connecting rods, wheels, rivets—each selectable and modifiable individually.

Go build your own transport tycoon.

Many were amazed that AI suddenly learned 3D modeling, but Krcha himself threw a bucket of cold water on the hype:

Don’t assume it’s a modeler sitting in Blender clicking a mouse—it doesn’t click at all; it literally writes out each part one by one using Python scripts.

This is the underlying logic behind this wave of 3D hype.

Astra didn't develop hands capable of operating software; it simply treated Blender as a runtime environment with an API.

First, it examines the image to understand how the locomotive is assembled, then disassembles the boiler, wheels, and connecting rods one by one, and finally uses Blender’s Python interface, bpy, to generate, name, and position each component accurately.

Can understand diagrams, deduce spatial relationships, write scripts, and make adjustments to rendered images: when these four skills are combined, outsiders see it as “can model.”

Another demonstration by Krcha is even more thorough: switching to Three.js eliminates the need for model files altogether.

The geometry, wheel rotation, and disassembly-reassembly animations of two trains are all computed in real time by TypeScript code running in the browser.

To prove this wasn’t a one-off display of skill, OpenAI engineer Thomas Ricouard submitted the most rigorous assignment possible.

His starting point was just one sentence: design a minimalist house with rich details, a garden, and cinematic lighting. There was no floor plan, no furniture list.

Astra directly created buildings, carpentry, furniture, plants, materials, lighting, and cameras using Blender's Python interface.

More importantly, before returning it, it first reviewed a preview render, adjusted the composition, corrected the lighting, fixed the plant clipping issues, and rearranged the blanket on the sofa.

The first version of the Solace residence was generated, with Astra modeling the building, furniture, materials, and lighting using the Blender Python interface.

Once, Astra noticed that the normal map of one part of the stainless steel sink was incorrect, causing it to render as if it had been pinched; she fixed it and re-rendered the scene.

Ricouard did not point out any of these issues—they were all discovered and fixed by the model itself.

When Ricouard requested to expand the house, Astra demonstrated professionalism.

It first sketched a floor plan: a single-story U-shaped home with a living, dining, and kitchen area in the center, two wings each containing three bedrooms and a study, all surrounding a courtyard planted with greenery.

The floor plan incorporates clear traffic flow considerations, such as avoiding the use of bedrooms as passageways and routing paths around the courtyard to avoid the kitchen work area.

Only after Ricouard approved the plans did Astra rebuild the entire house.

Astra draws the floor plan first, then models: a single-story U-shaped residence with the living, dining, and kitchen areas centered, and two wings containing three bedrooms and a study, with circulation paths designed to avoid the kitchen work zone.

Everything built is geometric: sofa cushions have piping, beds have frames, slats, and mattresses, wardrobes have internal shelves and hanging rods, desks have cable management channels, and sinks are genuine hollow basins.

To test the results, Ricouard requested a 30-second, human-like HD camera walkthrough.

Astra wrote her own script to mount the camera at a height of 1.65 meters with a 24–26mm lens, adding slight walking motion; she re-shot any frames where the preview showed an empty wall, and ultimately rendered 900 frames to create the final video.

This wasn't the end—Astra then developed an export pipeline: exporting geometries as FBX files while generating a JSON description file that records the position, material, and lighting of each component.

It migrated the entire house into Unreal Engine 5, automatically handling unit conversions from meters to centimeters, coordinate system flipping, texture reuse, and rebuilding the material system—all within the pipeline. Finally, it added a first-person character with collision detection and packaged it as a native Mac application, then tested the route itself.

In the latest version, pressing the E key not only lets you open doors, pull out drawers, and turn lights on and off—but now, when you activate the coffee machine, real coffee flows into the cup, and the liquid level rises accordingly.

From a single sentence to a house that can open its door and serve coffee, no one in the toolchain has changed.

Previously, modeling in Blender was done by one person, exporting to the engine by another, and writing interactive logic by someone else; now, a single model is handled end to end.

This is the most disruptive change of all.

If there's only 3D, can you still say this is an accidental byproduct of visual ability?

But another demo on the official release page jumped directly to electrical engineering.

Astra received a circuit schematic, opened KiCad, placed each component on the board one by one, routed each copper trace carefully, and progressed all the way to a PCB layout ready for factory production.

Anyone who works with hardware knows how tedious this task is: PCB layout still relies heavily on manual work today and is famously a bottleneck in the electronic design process.

Write bpy in Blender, export pipelines in Unreal, write geometry directly in Three.js, place components and route traces in KiCad.

Four seemingly unrelated professional software tools all follow the same underlying process: understand the task, locate the software’s interface, write code or perform manual operations, observe the results, and iterate.

OpenAI defines this set of capabilities as computer operation, web browsing, and professional work. Just one week after its release, Astra has already turned the first batch of professional software into its testing ground.

In the community, a wide variety of creative creations have begun to surge.

Peter Gostev had Astra use Three.js to connect Van Gogh’s six most famous paintings into a continuous, walkable town.

You wake up in The Bedroom in Arles, step outside to find yourself at The Café Terrace at Night, walk down the street to The Starry Night over the Rhône, and beyond the city gates lie Wheatfield with Crows and a field of sunflowers.

The entire process was programatically generated, with no external assets used—every wall and every stone slab was rendered by code.

This shows that Astra’s capabilities extend beyond just assets—how to assemble six paintings into a continuous space, what triggers occur as you move through it, and how to package it all into a webpage that can be opened in a browser—all handled by Astra alone.

Matt Shumer had Astra work nonstop for a week in Unreal, building a Manhattan.

Dominik Kundel had Astra design a real LEGO model in BrickLink Studio, then rendered it as a 4K video using Blender, and the official OpenAI Developers account shared this use case.

A developer created an interactive human anatomy website with 2,234 components that can be disassembled and rotated.

Someone also created an AR cleaning app: the phone’s camera follows the vacuum brush head, overlaying green on the floor as it’s cleaned—any missed spots are instantly visible, and the bottom-left corner simultaneously displays the cumulative cleaned area.

Van Gogh Town is one of the few examples built from scratch.

Note that most spam content, while delivered as finished products, is not created out of thin air.

The viral project featuring 2,234 human anatomy models used the existing BodyParts3D database; Astra’s contribution was assembling it into an interactive, disassemblable, and rotatable website, rather than building over two thousand human anatomical structures from scratch.

In Ricouard's forest villa, the trees, ferns, stones, and textures such as oak and plaster are also sourced from ready-to-use scanned assets on Poly Haven.

What makes Astra stronger is not the ability to create things out of nothing, but its capacity to autonomously assemble, convert, operate, and iterate its toolchain.

It’s more like an tireless technical artist and pipeline engineer than a pure concept artist.

Previously, we worried about AI because it might say the wrong things. Now, we worry about AI because it can do your work—but also holds the key to your room.

Two days before Astra's release on September 1, OpenAI published a security update titled "Toward Astra: Key Capabilities and Cutting-Edge Protective Mechanisms," directly acknowledging that Astra is the first model to cross the "critical" threshold of the preparedness framework's cybersecurity standards.

The term "Critical" means: given the tools and permissions, it can autonomously discover previously undetected vulnerabilities in hardened systems and develop exploit code.

The expert team conducted a controlled test by disabling all production safeguards.

Facing a hardened browser, Astra constructed an entire attack chain, escaping from the sandbox and executing commands on the host machine; facing a hardened operating system, it chained together several vulnerabilities to escalate privileges, elevating a regular user account all the way to root.

Astra scored 100% on ExploitBench, compared to the previous GPT-5.6 Sol at 78.5%.

Over the past few weeks, OpenAI has delayed parts of Astra’s development and release to first strengthen safeguards and complete testing.

In the Copilot era, software belongs to humans, and AI stands by, handing over tools; in the software operation layer era, AI sits directly at the workstation, while humans step back to review blueprints and click confirm.

The roadmap for the next one to two years is already set: whichever software has a script interface, a command line, and a readable file format will be the first to be taken over by models. Blender, Unreal, Three.js, and KiCad—all happen to be on the list.

What about software that has no API and only accepts mouse clicks?

OSWorld 2.0 evaluates performance by directly operating a real computer using only a mouse and keyboard, without any interfaces. Astra achieved 72.6% on this benchmark, with an average of about 40 minutes per task—nearly half the time of the previous generation.

So, those with interfaces are taken over first; those without will follow shortly after.

It is learning to use your computer the way you do.

Reference materials:

https://x.com/tomkrcha

https://developers.openai.com/blog/architectural-visualization-with-astra

https://x.com/ashebytes/status/2096221988763173186

https://x.com/dkundel/status/2096297005924729240

This article is from the WeChat public account "New Intelligence Yuan" (ID: AI_era), authored by Yuan Yu.