endueendue
Sign InStart free

GPT-6 Astra in Unity: what changes for 3D teams

OpenAI's new model edits Unity scenes, plays the build and fixes what breaks. What the first examples show, where the gains come from, and what to set up before you try it.

endue

5 min read한국어로 읽기

A lavender wireframe cube floats above a dark perspective grid, with a green arrow circling beside it.
On this page

When OpenAI released GPT-6 Astra in early September, the loudest reaction came from people who build in 3D. Within days there were videos of it editing Unity scenes, building a house in Blender and finishing a whole game in Godot. Unity’s own account congratulated OpenAI and pointed to how Unity works alongside coding agents to build 3D environments.

Look closely at those demos and they share one thing: Astra does not output 3D files. According to the API documentation it takes text and images in and returns text. What it has is tools, including computer use, a shell, code patching and MCP, and with them it drives Blender and Unity the way a person would. “Building 3D with Astra” means Astra operating the tools your team already uses.

Below is what has been shown so far, what Unity changed on its side, and six lessons worth taking from it.

What has been shown

Putting OpenAI’s examples together with the write-ups that followed:

Example Tools Astra drove Result
A house from a floor plan concept Blender (headless, via Python), Unreal Engine 5 A house you can walk through
One gray box into three themed prototypes Unity with Playco’s Playbot Most worked on the first attempt; about 50% fewer manual fixes
A 3D action game Godot Finished in about 25 to 53 minutes, depending on settings
Void Explorer, a space game TypeScript, Three.js, WebGPU 2,048 star systems and more than 10,000 planets

The Playco case has the most telling number. Playco builds Playbot, an AI IDE for game developers that connects directly to Unity and Godot, so a model can edit scenes, run and play the game, validate its changes with tests, and work on several things in parallel. According to OpenAI, Astra needed about half as many manual fixes there as the previous model. That result is from Unity; it does not mean Godot showed the same.

Unity got ready for agents first

About six weeks before Astra, Unity announced the Unity CLI and Pipeline package. For an agent, three things changed:

  • The Editor describes itself. Ask a connected Editor for its commands and it lists what it can do right now, so an agent discovers its options at runtime instead of relying on a hard-coded list.
  • The fix-and-check loop closes in the terminal. Entering Play mode, running tests, reading logs and building no longer need a person relaying results back and forth.
  • unity mcp replaces the in-Editor MCP server. Clients that cannot run shell commands connect over MCP; those that can call the Editor directly with unity command and unity eval. Unity’s documentation says the direct commands are faster and use fewer tokens than MCP.

Safety came with it. eval, which runs C# inside a live Editor, is gated behind a security token, and the runtime component that attaches to a running game is off by default, localhost-only, and meant for development and QA builds. It needs Unity 6.0 LTS or later.

Six lessons from the examples

1. The gains come from the checking loop

Manual fixes dropped in the Playbot case because the model played its own result, found problems and fixed them. Getting it right the first time matters, but a setup where the model catches its own mistakes makes the bigger difference.

So the first thing to build is a way to check, before a clever prompt. Does the scene load without errors? Is frame time inside budget? Does the core interaction work? Write those checks as scripts and the agent can run them after every change.

2. Code is the fastest 3D interface

In the Blender example, Astra chose headless Blender driven by Python over clicking through the interface. The Three.js game was code from the start, and Unity now exposes its Editor through a CLI and eval. Operating a screen works, but it is the slowest path and burns the most tokens.

An agent can only be as fast as your pipeline is scriptable. If a routine task lives only in an Editor menu, give it a command.

3. Compose before you generate

ITHappy Studios described Astra assembling a city in Unity from its free asset pack, and valued that it worked from a prepared library instead of generating new assets. Quality and consistency are much easier to hold that way.

A prefab library with consistent naming and scale becomes the agent’s raw material. Keeping only clearly licensed assets in it is part of the same job.

4. A good render is not a good asset

Guides to turning a single reference image into a Blender scene all carry the same warning: a convincing render proves nothing about scale, topology, UVs, normals, hidden geometry or performance. What the image does not show, the model cannot know.

Turn what a machine can check (polygon budgets, texture sizes, collisions, naming) into scripts the agent runs, and leave the visual judgment to a technical artist at the end.

5. People still own the feel

Even in the FPS example, tuning how the game felt took rounds of human direction. What is fun, and what it should feel like, is still a person’s call.

Write the target down before you hand over the work: reference games, numbers like camera distance or jump height, and what must not change. The clearer the target, the fewer rounds of sending results back.

6. Set time, cost and isolation up front

The Godot game took 25 to 53 minutes. API pricing is $10 per million input tokens and $50 per million output tokens, and prompts over 272K input tokens are billed at higher rates, which is a reason to think twice before pouring a whole scene or log into context.

Because the agent drives an Editor and a shell, isolate where it works. Use a development machine and repository, never give it production credentials, and review its changes branch by branch before merging.

Something to try this week

  1. Pick one small, gray-box-level scene.
  2. Install the Unity CLI and Pipeline package in a Unity 6 or later project.
  3. Script three checks: the scene loads without errors, frame time stays in budget, one core interaction works.
  4. Give the agent a short brief: where the asset library is, the naming rules, and what it must not change.
  5. Run the loop of edit, play, check and fix, and review the results one branch at a time.

And in endue

GPT-6 Astra is in the endue model catalog, so on paid plans you can choose it as an agent’s model. Splitting the agent that edits from the agent that checks is the same idea as the generator and verifier pattern from our post on multi-agent work. With separate agents for making and checking, neither one’s criteria blur into the other’s.

Sources