OpenAI’s GPT-6 Astra is already being measured less by leaderboard rankings than by the work developers are handing it. A growing set of demonstrations from outside developers and from OpenAI itself points to the same shift: Astra is not only answering prompts, it is carrying out end-to-end tasks inside professional software such as Blender, Three.js, Unreal Engine 5 and KiCad.
3,295 editable objects from a steam locomotive blueprint
Developer Tom Krcha gave Astra an old steam locomotive drawing and asked it to rebuild the machine in Blender. Minutes later, Blender contained 3,295 separate editable objects, including the boiler, rods, wheels and rivets, each selectable and editable on its own.
Krcha said the level of detail could be increased or simplified with a single instruction. In his words, users could simply “go build your own Transport Tycoon.”
He also pushed back on the idea that Astra had suddenly become a mouse-driven 3D artist. According to Krcha, the model was not sitting inside Blender clicking tools. It was generating Python scripts and “writing” the parts into existence one by one.
That distinction matters. In this workflow, Astra is treating Blender as an execution environment with an API. It reads the drawing, works out how the locomotive is assembled, breaks the design into pieces such as the boiler, wheels and rods, then calls Blender’s Python interface, bpy, to generate geometry, assign names and place objects where they belong.
Seen from the outside, the combination looks like 3D modeling: it understands the reference, infers spatial relationships, writes code and then revises the result after looking at renders.
In Three.js, geometry and animation were computed in the browser
Krcha’s second demo moved to Three.js and removed model files from the process entirely.
The geometry of two trains, the wheel motion and the assembly-disassembly animation were all generated as TypeScript code and computed at runtime in the browser.
That expands the picture beyond static asset creation. Astra was handling geometry, scene logic and browser-side execution, then delivering the result as something directly runnable.
A house from one sentence, with self-checks before delivery
To show this was not a one-off stunt, OpenAI engineer Thomas Ricouard gave Astra a more demanding assignment: design a minimalist but highly detailed house with a garden and cinematic lighting. The starting point was one sentence. There was no floor plan and no furniture list.
Astra used Blender’s Python interface to create the architecture, millwork, furniture, plants, materials, lighting and camera setup.
Before returning the result, it reviewed preview renders on its own, adjusted framing and lighting, fixed plant intersections and rearranged the blanket on a sofa.
Ricouard said that in one pass Astra noticed a section of a stainless steel sink had incorrect normal orientation, making the render look dented. It corrected the problem and rendered again without being explicitly told to look for that issue.
It drew the floor plan first, then rebuilt the full U-shaped house
When Ricouard asked for a larger house, Astra did not just keep adding structure. It first produced a floor plan.
The layout was a single-story U-shaped residence with the living, dining and kitchen area in the middle, three bedrooms and a study in the two wings, and a planted courtyard at the center. The plan also reflected circulation decisions: no hallway serving the bedrooms, and movement around the courtyard routed away from the kitchen work zone.
Only after Ricouard approved the plan did Astra rebuild the house.
The finished result was constructed as actual geometry. Sofa cushions had piping. The bed included a frame, base and mattress. The wardrobe had internal shelves and hanging rods. The desk had cable management. The sink was modeled as a hollow basin rather than a simple surface.
A 30-second camera walkthrough, 900 rendered frames and an Unreal pipeline
Ricouard then asked for a 30-second high-definition walkthrough with a lived-in feel. Astra wrote a script that placed the camera at 1.65 meters, used a 24-26 mm lens and added slight walking sway.
If a preview pointed at a blank wall, it reshot the sequence. In the end, it rendered 900 frames and assembled them into a video.
It did not stop there. Astra wrote an export pipeline that sent the geometry out as FBX and created a JSON description file recording the position, material and lighting information for each part.
It then moved the entire house into Unreal Engine 5. Unit conversion from meters to centimeters, coordinate-system flipping, texture reuse and material-system rebuilding were handled inside the pipeline. After that, it added a first-person character and collision, packaged the project as a native Mac app and ran through a test path on its own.
In the latest version, pressing the E key does more than open doors, pull drawers or switch lights on and off. A coffee machine will pour coffee into a cup, and the liquid level rises as it fills.
From a single sentence to a house where doors open and coffee pours, there was no handoff to another operator in the middle of the toolchain. Work that used to be split among a Blender modeler, an engine integrator and a gameplay or interaction developer was carried through by one model from start to finish.
From Blender to KiCad, the underlying loop is the same
If the story ended with 3D, it could still be framed as vision capability spilling into production tools. OpenAI’s official materials pushed further into electronics.
Given a circuit schematic, Astra opened KiCad, placed the components on the board one by one, routed copper traces and advanced the project to a PCB layout that could be sent for manufacturing.
For hardware engineers, PCB layout remains one of the more tedious bottlenecks in electronic design and still depends heavily on manual work.
Across Blender scripting with bpy, export-pipeline work in Unreal, procedural geometry in Three.js and component placement and routing in KiCad, the software changes but the loop stays familiar:
- understand the assignment
- find the interface the software exposes
- write code or operate the tool
- inspect the result
- revise and continue
OpenAI groups this capability under computer use, web browsing and professional work. One week after release, Astra was already using that capability to turn a first wave of specialist software into a testing ground.
Community projects are multiplying, but many are not created from scratch
The public demos quickly led to a wider burst of experiments.
Peter Gostev had Astra use Three.js to connect six of Vincent van Gogh’s best-known paintings into a continuous town that users could walk through. The sequence starts in Bedroom in Arles, opens into Café Terrace at Night, continues along the street into Starry Night Over the Rhône, and exits toward Wheatfield with Crows and a field of sunflowers. The build was procedural and used no external assets. Every wall and every paving stone was drawn in code.
That example shows Astra doing more than making assets. It had to decide how six paintings could become one continuous space, where interaction points would sit and how the whole thing should be packaged as a browser experience.
Matt Shumer had Astra work in Unreal for a full week and build a Manhattan.
Dominik Kundel used Astra in BrickLink Studio to design a LEGO model that could actually be assembled, then rendered it in Blender as a 4K video. OpenAI Developers later reposted that case.
Other developers built an interactive anatomy website with 2,234 parts that can be exploded and rotated, and an AR vacuuming app that tracks the vacuum head through a phone camera, marks cleaned floor areas in green in real time and tallies the cleaned area in the lower-left corner.
What Astra appears to do best is assembly, conversion and iterative tool use
The article also makes a point that many of the projects circulating online were not generated entirely from nothing.
The 2,234-part anatomy project used the existing BodyParts3D database. Astra’s contribution was to turn those assets into an interactive website where parts could be separated and rotated, not to model thousands of anatomical structures from scratch.
In Ricouard’s forest villa example, the trees, ferns, rocks and texture scans such as oak and plaster also came from Poly Haven assets.
That puts the emphasis elsewhere. The reported advance is less about raw creation ex nihilo and more about autonomous assembly, conversion, software operation and iteration across a toolchain. In the article’s framing, Astra looks more like a tireless technical artist and pipeline engineer than a pure concept artist.
As execution improves, safety becomes a question of permissions
The safety discussion changes once a model can act instead of only speak. The concern is no longer limited to whether an AI says the wrong thing. It is whether the system can do work on a user’s behalf while also holding the keys to that user’s environment.
On Sept. 1, two days before Astra’s release, OpenAI published a safety update titled Towards Astra: Key Capabilities and Frontier Safeguards. The company said Astra became the first model to reach the “critical” cybersecurity threshold in its preparedness framework.
In OpenAI’s terms, “critical” means that with tools and permissions, the model can find previously undiscovered vulnerabilities in hardened systems and write working exploits without step-by-step human guidance.
In a controlled test with production defenses turned off, Astra built a complete intrusion chain against a hardened browser, escaped the sandbox and executed commands on the host. Against a hardened operating system, it chained several vulnerabilities into a privilege-escalation path and moved from a standard account to root.
On ExploitBench, Astra scored 100%, compared with 78.5% for the previous GPT-5.6 Sol.
OpenAI said it delayed part of Astra’s development and release over the past few weeks while strengthening defenses and completing evaluation.
The piece closes by contrasting the copilot era with what it calls the software-operation era. In the first, software remained in human hands and AI passed over tools from the side. In the second, AI takes the seat at the workstation while the human moves back to reviewing floor plans and clicking approval.
For the next one to two years, the map is fairly clear in the article’s telling: software with scripting interfaces, command lines or readable file formats is likely to be taken over first. Blender, Unreal, Three.js and KiCad already fit that description.
What about applications without such interfaces, where the only option is direct mouse and keyboard use? That is what OSWorld 2.0 measures. Without any dedicated interface and using a real computer through mouse and keyboard, Astra scored 72.6%, averaging about 40 minutes per task, nearly halving the time required by the previous generation.
Software with interfaces may be first. Software without them may follow later. Astra is learning to use a computer the way people do.