Why GPT-6 Astra Got Good at Space, and What It Means for 3D and Robots

In early September OpenAI released GPT-6 Astra, and two kinds of clips spread fast. In one, it builds a fully furnished house in Blender from scratch, then exports it to Unreal Engine 5, where you can walk in, open doors, switch on lights and run the espresso machine. In the other, it directs robot arms and humanoids.

How did a language model suddenly get good at space? Did OpenAI optimize for it? And what does the route mean for 3D generation and for the "brains" of robots? We read OpenAI's announcement, system card and developer blog, the robot evaluations published since, and researchers' analyses. The short version:

• The gains are real but lopsided: 3D, visual grounding and interactive tasks jumped, while broad intelligence barely moved.
• Robot results depend heavily on the interface. The same model, used differently, scores very differently.
• The skill most likely comes from practice in environments that grade themselves, not from a new architecture.
• For 3D generation and robot brains, expect a new division of labor rather than one model replacing another.

The official numbers: big gains, unevenly spread

Against GPT-5.6 Sol, its direct predecessor, the numbers OpenAI published look like this:

• BenchCAD: 83.3% → 95.9%. The model sees renders of an object from several angles and writes CAD code that rebuilds it — modeling from pictures.
• ScreenSpot-Pro (no tools): 76.9% → 92.7%. It has to point at an exact button or element in a high-resolution screenshot of professional software.
• Score reading: 0.19 → 0.84 on OpenScore string quartets, turning dense printed scores into structured music data.
• ARC-AGI-3, an interactive puzzle benchmark: 7.8% → 66% with the benchmark's standard harness, or 99.9% with OpenAI's own.

The third-party Artificial Analysis Intelligence Index, by contrast, went from 60.9 to 61.2 — below Claude Fable 5.1 at 65.7.

So Astra did not get smarter across the board. It got much better at tasks that combine looking, acting and adjusting. Yoav Artzi, a researcher at Cornell and Google DeepMind, called it a "step change" in spatial reasoning.

What it actually did in Blender

OpenAI's developer blog walks through a complete project. The opening brief was short: design a beautiful house with minimalist but highly detailed furniture and a nice garden, and make the scene cinematic.

• Astra wrote Blender Python (bpy) to build the architecture, joinery, furniture, planting, materials, lights and cameras.
• It rendered previews, looked for problems and fixed its own code — plants intersecting each other, a steel sink whose surface normals made the bowl look pinched.
• It drew a floor plan for approval first, then rebuilt the house as a single-story U-shaped home with three bedrooms and an office.
• It exported the scene to Unreal Engine 5 as a first-person walkthrough in which doors, drawers, lights and an espresso machine all work.

The deliverable is not a picture. It is a Blender scene you can keep editing.

The limits are just as clear:

• Regular, man-made geometry works well: buildings, furniture, CAD parts, and hard-surface models such as a starship or a Dyson sphere.
• Organic shapes do not. Ask it to model a person or a cow, researcher Wentao Zhu writes, and the result is poor.
• In OpenAI's own project, the forest, ferns and rocks are existing assets from Poly Haven. A common community workflow generates the model in a 3D tool such as Tripo, then hands materials, facial-expression shape keys and rigging to Astra.

One idea explains the pattern: code is compressed geometry. A cabinet is a few boxes, an extrusion and an array — a handful of lines. A face, a tree or a draped cloth takes far more. Astra is writing programs, so what has a short program it handles itself, and what needs a long one it should hand to a specialized generator. The same rule shows up again with robots.

Robots: strong results, but read the conditions

RoboDojo is a robot benchmark with 42 simulated tasks and a leaderboard of 40 trained robot policies. The authors of one evaluation plugged Astra in as the policy itself: no fine-tuning, no ready-made grasping skills, no depth. It saw three color camera views and the robot's state, and at every step named where the arm should go.

• Astra averaged 22.48% success and ranked first. Under the same setup, GPT-5.5 managed 0.88%.
• The profile is lopsided. It leads on open-ended tasks (31% against 2.1% for DM0.5) and generalization (30.5% against 11%), but trails on precision (4% against 16.8%), long-horizon tasks and memory.

Put simply: tasks that need understanding, it wins; tasks that need a steady hand, it loses.

The bigger lesson is how much the result depends on the interface:

1. Color images only, one target position per step (RoboDojo): 4% on precision tasks; of 33 real-robot trials kept around a safety stop, one full success.
2. Three cameras, up to 20 model calls per attempt (Robocurve's tests on real arms): 19 of 20 blocks into a bowl, but 2 of 20 puzzle pieces into their groove.
3. A depth camera, plus permission to write its own geometry code (the Agent as Policy v1 · Table 1 paper): 4 of 5 four-pair assemblies, 5 of 5 dice flips and block builds at 5/5, 5/5 and 4/5 — with successful trials averaging about 21–54 minutes, depending on the task.
4. Calling existing robot skills or a VLA model: long tasks get done. In one report, a hybrid in which Astra reviews and corrects a VLA's actions succeeded 48% of the time, on tasks where Astra alone managed 26%.

These are different tasks and cannot be compared head to head, but they point the same way. Anthropic's July robotics study found the same thing: a model's robotics score depends as much on the robot body and the control interface as on the model itself. Any claim about how good Astra is at space needs the words "with which interface".

Three things to keep in mind when the demos scroll by:

1. The viral "untangle the interlocked parts, thread a rope through three rings" clip is a kinematic replay in simulation. The author's methods page says it starts from a pre-grasped state and assumes ideal grasps: it shows a planned path, not a robot controlled live.
2. "25 times better than the old model" compares Astra with GPT-5.5, not with its direct predecessor GPT-5.6 Sol. In the two-pair assembly comparison (AGP v1 · Table 2), Sol and Claude Opus 5 also completed 5/5 trials; Astra averaged 9.2 minutes on successful trials, versus Sol’s 14.2. In the separate pyramid comparison (AGP v1 · Appendix C, Table 5), Astra completed 10/10 trials versus Sol’s 7/10.
3. Stanford's HomeBody kitchen robot: Astra does the thinking — where to go, what to pick up, what to do first — and even built the kitchen's digital twin. Walking, grasping and balance come from SLAM, depth estimation, motion planning and pretrained low-level controllers.

Where the ability comes from

OpenAI has said two things on the record: Astra got "targeted training for professional environments", and like OpenAI's other reasoning models it is trained with reinforcement learning. It has not disclosed the training data, whether Blender was involved, or whether robot data was. What follows is inference from public evidence.

At the center is a loop: take a step, look at the result, find what is wrong, fix it.

• At work, Astra writes Blender code, renders, inspects and edits; on a robot it looks, sets a target, executes, checks and corrects. In Wentao Zhu's words: "What the model does is simple: write (Blender) code, render, inspect the image, find what is wrong, decide what to change, and repeat."
• In training, the same loop is the likely source. OpenAI reportedly bought tens of thousands of Mac minis and Mac Studios to train computer use: give the model a task, let it read screenshots and send mouse and keyboard actions to a Mac, then reward the runs that succeed.

1. Large-scale reinforcement learning in environments that grade themselves (likelihood: medium-high). Computers, code and 3D software can all verify results automatically, which trains the general skill of checking, finding the error and fixing it. The jump on the interactive ARC-AGI-3, from 7.8% to 66%, is the same signal.
2. Pointing skills from computer use carry over to robots (medium). ScreenSpot-Pro rose from 76.9% to 92.7%, so the model got much better at hitting an exact spot in an image. In HomeBody, Astra picks up objects by naming exactly such a point in the camera image; depth and calibration turn it into a 3D position.
3. Blender and CAD were themselves training environments (medium-low, unconfirmed). BenchCAD jumped, OpenAI leads with 3D demos, and Yoav Artzi suspects training on large amounts of 3D data such as Blender scenes. Nothing official confirms it.
4. A new architecture (low). Astra reportedly uses recurrent depth in part of the network, but OpenAI's chief scientist Jakub Pachocki has said that the computation graph of current frontier models, Astra included, is within a factor of two of GPT-4's depth.

Our read: the spatial skill most likely did not come from a dedicated spatial architecture. It came from turning spatial tasks into practice environments that grade themselves, and training on them with general-purpose reinforcement learning.

What it means for 3D generation

There are now two ways to make 3D:

• An agent drives the engine. Like Astra in Blender or CAD, it delivers an editable scene with materials, lights and joints. It is slow — minutes to overnight — but structurally accurate, editable and checkable.
• A model generates the asset. TRELLIS, Hunyuan3D, Tripo, Meshy and similar models output a mesh in seconds to minutes. They are strong on organic shapes and detail, but the result is hard to edit, and topology, UVs and rigging often need rework.

We expect the two to complement each other while the value moves:

• Agents take over the most labor-intensive steps: layout, lighting, camera work, revisions and QA.
• Generators become asset tools for people, animals and plants, and they need to be callable by agents, for example as an MCP server or an API.
• One-prompt, one-object services are under the most pressure. Production-ready output (clean topology, UVs, rigs) and simulation-ready output (joints, mass, friction) become the new ground to compete on.

The biggest new opportunity is not prettier 3D. It is a world you can practice in.

• In HomeBody, Astra built a digital twin of the kitchen in a simulator from the robot's own SLAM geometry, camera views and joint data, then planned tasks with it.
• Wentao Zhu's team demonstrated inverse physics: given only a video and the pulling force, the model inferred a drawer's mass, friction and damping and reproduced the motion in simulation.

Where 3D skill leads, in other words, is a practice world for robots. The catch: mass and friction cannot be read from video alone, so at some point something has to push on a real object.

Native world models are not out of the race either. World Labs' Atlas, released September 1, generates and reconstructs whole 3D worlds from a few photos, with a realism and continuity that an agent driving an engine cannot match. The two routes will most likely end up calling each other.

What it means for robot brains

We expect the robot brain to split into layers rather than one model doing everything:

• General models take understanding the task, planning the steps, choosing skills, diagnosing failures and adapting to new robots — the "semantic generalization" that VLA models used to be proud of. On RoboDojo's open-ended and generalization axes, Astra already beats the trained robot policies.
• Specialized models keep high-frequency control, contact, dexterity and whole-body balance.
• The shift is that those specialized models will increasingly be built by the general model. Wentao Zhu's team had Astra set up a simulation, write the reward and train a reinforcement-learning policy; about a day and a half later it delivered a dexterous hand that spins a pen.

Why the fast control loop stays separate comes down to three hard limits:

• Latency: Anthropic puts real-time locomotion at about 83 Hz, while model inference runs at 0.2–0.4 Hz — roughly two orders of magnitude apart.
• Cost: about $1 to $27 per task in the evaluations above, and a home robot performs hundreds of actions a day.
• Safety: in Robocurve's RoboHarm test, Astra refused 2 of 100 dangerous instructions. Safety needs its own guardrails that do not depend on the cloud.

Google DeepMind's Gemini Robotics 2, announced in July, already has this shape: an embodied reasoning model for planning, an action model, and a smaller model that runs on the robot itself.

Does this prove autoregressive models win?

Some read Astra as evidence that autoregressive (AR) generation — producing one token after another, the way GPT models do — has the edge. We agree with half of that:

• The real advantage of AR is that generation can alternate with outside feedback: write some code, run it, look at the result, keep writing. A diffusion model produces the whole result at once and has a hard time taking feedback midway.
• AR also suits discrete, variable-length structure such as programs, scene graphs and mesh topology, and it reuses the training and serving stack built for LLMs.
• For continuous signals such as images, video and motor actions, pure AR has no edge. The field is moving to an autoregressive backbone with a diffusion or flow-matching head: World Labs' Atlas, DreamZero from NVIDIA researchers, and π0.5 all take that route.
• The clever part of Astra's route is that it outsources the continuous layer to renderers, CAD kernels, physics engines and motion planners. Decades of graphics and robotics engineering become the decoder — exact, editable and needing no training. The price is that the engines set the ceiling.

What this means if you work with agents

We build a desktop app where agents do the work, so the interface finding is the one we care about most. The same model scored very differently depending on what it could see, which tools it could call and whether it could check its own output. Much of the capability lives in that loop, not only in the weights.

That loop is what an agent workspace has to provide: tools to act with, files to work on, and results the agent can inspect before it hands them back. In Orkas you can run GPT-6 Astra with your own OpenAI API key or by signing in with your ChatGPT account, connect Codex as an external agent, or use Orkas-managed models. Orkas also accepts custom MCP servers, so community servers for desktop tools can be added as connectors. We have not tested a Blender server end to end, so treat that as a do-it-yourself route.

What we take from it

• Astra's sense of space is decision-making inside a loop: look, write code or set a target, execute, check, fix.
• It is strong at regular geometry, scene assembly and judgments that mix meaning with space, and weak at organic shapes and fine contact — because of what a short program can describe.
• The skill most likely comes from large-scale reinforcement learning in environments that grade themselves, not from a new architecture. The training recipe has not been disclosed.
• In 3D generation, agents take over direction and assembly while generators become asset tools, and digital twins are the bridge to robots.
• In robot brains, the general model becomes the foreman and the factory, while fast control stays with specialized on-device models.

Signals worth watching: whether 3D generation companies open interfaces for agents; whether a standard Blender agent benchmark appears; whether precision tasks pass 30% with color images alone; and whether a frontier model reaches 10 Hz closed-loop visual control.

A caveat: most of the robot evaluations above use small samples, 5 to 20 trials per setting, and most are not blind. Treat these conclusions as a working read, not a verdict.

Sources: OpenAI's GPT-6 Astra announcement and system card; Fortune's launch report; Wentao Zhu's GPT-6 Astra: 3D, Embodied AI, and Beyond; and Sebastian Raschka's essay on looped transformers, which quotes Pachocki. Other sources are linked where they are cited.

If you want to try GPT-6 Astra or another model inside Orkas, the supported models and providers section of the docs lists what connects today.