GPT-6 can now open software and carry out work on its own, generate 3295 parts from a single drawing, and build a luxury mansion with just one sentence.

Hardly after GPT-6 Astra was released, no one is paying attention to benchmark rankings anymore?

It's not that the benchmark scores are unimpressive, but that OpenAI has changed its approach, shifting to collecting "homework" from users. Developers see this, and go: Alright, let's just hand in the work then.

Developer Tom Krcha threw a blueprint of an old steam locomotive to Astra, asking it to reconstruct the model in Blender.

A few minutes later, 3295 editable independent objects popped up in Blender: boilers, connecting rods, wheels, rivets, every single one can be selected and modified separately.

You can adjust the detail level to be as fine or as simple as you want with just one sentence. In Krcha's own words: "Go build your own Transport Tycoon game".

Many people are exclaiming that AI has suddenly learned 3D modeling, but Krcha himself poured cold water on this claim first:

Don't assume it is a modeler sitting in Blender clicking the mouse. It never clicks the mouse at all, and it generates every single part entirely by writing Python scripts.

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

Astra does not grow a pair of hands that can operate software. It just treats Blender as a runtime environment with APIs.

It first looks at the drawing, figures out how the locomotive is assembled, then takes apart the boiler, wheels, and connecting rods one by one, then calls Blender's Python interface bpy to generate geometry for each part, name it, and place it in the correct position.

The ability to read diagrams, deduce spatial relationships, write scripts, and modify content based on rendered previews: when these four capabilities are combined, what outsiders see is that it "can do modeling".

Another demonstration from Krcha is more thorough: by switching to Three.js, even the model files are no longer needed.

The geometry of the two trains, wheel rotation, disassembly and reassembly animations are all calculated on the fly by TypeScript code running in the browser.

From a single sentence to a house that can open doors and pour coffee

To prove this is not a random show of skill, Thomas Ricouard, an engineer at OpenAI himself, handed in the most hardcore homework.

His starting point is only one sentence: Design a minimalist but detail-rich house with a garden, with cinematic lighting. No floor plans, no furniture lists.

Astra directly generated the entire architecture, woodwork, furniture, plants, materials, lighting and cameras through Blender's Python interface.

More importantly, before handing over the results, it first reviewed the preview render by itself, adjusted the composition, modified the lighting, fixed the clipping issues of plants, and rearranged the blanket on the sofa.

The first version of the Solace residence generated by a single sentence, Astra built the architecture, furniture, materials and lighting through the Blender Python interface.

Once, Astra itself found that the normal direction of a part of the stainless steel sink was wrong, which made the rendered result look like it was pinched by someone. It fixed the issue immediately and re-rendered the scene.

Ricouard never pointed out any of these problems at all, all of them were discovered and fixed by the model on its own.

When Ricouard asked to enlarge the house, Astra demonstrated its professionalism.

It first drew a floor plan: a U-shaped single-story house, with the living room, dining room and kitchen in the center, three bedrooms and a study in the two wings, surrounding a courtyard planted with greenery.

The floor plan has clear circulation design considerations, for example, no extra aisle space is set for bedrooms, and the route around the courtyard avoids the kitchen working area.

After Ricouard approved the floor plan, Astra started to reconstruct the entire house.

Astra draws the floor plan before modeling: U-shaped single-story house, with living, dining and kitchen areas in the center, three bedrooms and a study in the two wings, and the circulation path avoids the kitchen working area.

Everything generated is pure geometry: sofa cushions have piping, beds have bed frames, bed boards and mattresses, wardrobes have internal partitions and hanging rods, desks have cable management slots, and the sink is a real hollow basin.

To test the results, Ricouard requested a 30-second human-like high-definition camera roaming shot.

Astra wrote the script by itself to set the camera at a height of 1.65 meters, equipped with a 24-26mm lens, added slight walking shake, reshooted frames where the camera faced a blank wall in the preview, and finally rendered 900 frames to assemble the video.

That's not all. Astra then wrote a set of export pipelines: export the geometry as FBX, and generate a JSON description file at the same time to record the position, material and lighting of each component.

It moved the entire house into Unreal Engine 5, converted units from meters to centimeters, flipped the coordinate system, reused textures to rebuild the material system, all processed automatically in the pipeline. Finally, it added a first-person character and collision settings, packaged it into a native Mac application, and walked through the test route by itself.

In the latest version, when you press the E key, you can not only open doors, pull drawers, and turn lights on and off, but even when you press the coffee machine, coffee will actually flow into the cup, and the liquid level will rise accordingly.

From a single sentence to a house that can open doors and pour coffee, there is no operator switching across the toolchain in the whole process.

In the past, one person did Blender modeling, another person exported the content to the engine, and a third person wrote interaction logic. Now one model runs through the entire workflow from start to finish.

This is the most subversive change.

Connecting the execution layer of cross-software toolchains

If it only has 3D capabilities, it can be said that this is just a spillover of its visual capabilities.

But another demonstration on the official release page directly extends to electronic engineering.

Astra gets a circuit schematic, opens KiCad, places components on the board one by one, then routes the copper wires one by one, and finally generates a PCB layout that can be sent to the factory for production.

People working in the hardware industry all know how tedious this work is: up to now, PCB layout still relies heavily on manual work, which is a well-known bottleneck in the electronic design process.

Writing bpy scripts in Blender, writing export pipelines in Unreal, generating geometry directly in Three.js, placing components and routing in KiCad.

Four seemingly unrelated professional software share the same underlying logic: understand the task, find the interface of the software, write code or perform operations, check the result, and iterate the modification.

OpenAI defines this set of capabilities as computer operation, web browsing and professional work. Only one week after its release, Astra has used this capability to turn the first batch of professional software into its own test fields.

In the developer community, all kinds of imaginative finished products are also emerging in large numbers.

Peter Gostev asked Astra to use Three.js to connect Van Gogh's 6 most famous paintings into a continuous walkable small town.

You wake up in The Bedroom in Arles, push the door and you see Café Terrace at Night, walk down the street and you reach Starry Night Over the Rhône, and outside the city gate you see Wheatfield with Crows and a field of sunflowers.

The whole process is procedurally generated, no external assets are used, every wall and every stone slab is drawn by code.

This shows that Astra's capabilities are not limited to making assets. It handles the whole process of figuring out how to combine six paintings into a continuous space, designing what triggers at which position, and finally packaging the whole project into a web page that can be opened in the browser.

Matt Shumer let Astra work continuously in Unreal for a week to build a Manhattan scene.

Dominik Kundel asked Astra to design a real buildable Lego model in BrickLink Studio, then render it into a 4K video with Blender, this use case was officially reposted by OpenAI Developers.

Some developers made an interactive human anatomy website with 2234 components that supports disassembly and rotation operations.

Someone else made an AR cleaning application: the phone camera follows the vacuum cleaner brush, the swept ground is covered with green in real time, so you can see where is missed at a glance, and the total cleaned area is synchronously accumulated in the lower left corner.

The Van Gogh town example is one of the few cases built entirely from scratch.

It is worth noting that most of the viral finished products, although they deliver complete results, are not generated out of thin air.

The viral 2234-component human anatomy project uses the ready-made BodyParts3D database. What Astra does is to assemble it into a disassembly and rotatable interactive website, rather than building more than 2000 human body structures from zero.

In Ricouard's forest villa, the trees, ferns, stones and textures such as oak and gypsum also use ready-made scanned assets from Poly Haven.

What makes Astra stronger is not the ability to create things out of nothing, but the ability to independently assemble, convert, operate and iterate toolchains.

It is more like a tireless technical artist and pipeline engineer, rather than a pure conceptual artist.

When hands-on capabilities get stronger, security becomes a permission issue

In the past, we worried about AI saying wrong things, but now we worry that AI can work for you, but it also holds the key to your room.

On September 1, two days before the release of Astra, OpenAI released a security update first, titled Towards Astra: Key Capabilities and Cutting-Edge Protection Mechanisms, which directly acknowledged that Astra is the first model that has reached the "Critical" cybersecurity threshold in the preparation framework.

"Critical" level means: give it tools and permissions, without human guidance, it can find previously undiscovered vulnerabilities in hardened systems by itself, and then write exploit programs.

The expert team turned off all production protections and conducted a controlled test.

Facing a hardened browser, Astra built a full intrusion chain, escaped from the sandbox, and ran commands on the host machine. Facing a hardened operating system, it connected several vulnerabilities into a privilege escalation chain, and escalated from a normal account to root access.

Astra got a full 100% score on ExploitBench, while the previous generation GPT-5.6 Sol only got 78.5%.

Therefore, OpenAI pushed back part of Astra's development and release schedule in the past few weeks, to strengthen protection mechanisms and complete full tests before public release.

In the Copilot era, software belongs to humans, and AI stands by to pass the wrench. In the software operation layer era, AI directly sits at the workstation, and humans step back to the position of reviewing floor plans and clicking confirm.

The roadmap for the next one or two years is already clear: any software that has script interfaces, command lines, or readable file formats will be taken over by the model first. Blender, Unreal, Three.js, KiCad are all exactly on this list.

What about those softwares that have no interfaces and only accept mouse clicks?

OSWorld 2.0 tests the capability of directly operating a real computer with mouse and keyboard without using any interfaces. Astra scored 72.6% on it, taking an average of about 40 minutes per task, nearly half the time of the previous generation model.

Therefore, software with interfaces will be taken over first, and software without interfaces will only be a step behind.

It