Hands-On with OpenAI GPT-6 Astra: Building a Walkable House from a Single Sentence

How I Used GPT-6 to Design a House

👦🏻 Author: Thomas Ricouard

🥷 Translation: gold digger

🧑‍🎨 Layout: NCon

Editor's Note from Crossing

The author of this piece is Thomas Ricouard, an engineer on OpenAI Codex. He walks through a use case for GPT-6 Astra — designing a house with Astra.

In our view, this is one of the most detailed reviews of GPT-6 Astra to date. It demonstrates two of the model's most noteworthy capabilities quite thoroughly: first, it can do 3D work directly in Blender; second, it proactively verifies and refines its own work — which also reflects GPT-6 Astra's marked improvement in computer use. 🚥

At the very beginning, I said just one sentence: I want a minimalist house with refined furniture, a garden, and a cinematic look.

I fed that sentence to Astra in Codex and had it generate an editable 3D scene directly in Blender. From there, the scene grew step by step: first it expanded into a fully furnished family home, and later it was moved into Unreal Engine 5, where you could walk through it like a game.

Blender kept working too: the scene was continuously refined, and in the end it produced both a short film with proper camera moves and a space you could actually walk into yourself.

The original scene was just a furnished open-plan living space. Later, we drew a floor plan for a larger family home, then built out the rooms one by one. Throughout the process, Astra and I iterated on the architecture, furniture, materials, and lighting, using each new render to decide what to change next.

In the final round, we added everyday objects and warmer lighting — that's when the house truly started to feel lived in.

A few of the prompts are kept below (trimmed for length).

Following along, you can see how a vague idea grows into a complete project.

Defining the House and Its Overall Mood

In the first prompt, I only described the outcome I wanted — no floor plan, no furniture list:

"Design a beautiful house with minimalist but highly detailed furniture and a nice garden. Make the scene cinematic, with considered lighting, materials, and time of day." Astra used the Blender Python API[1] (bpy) to build an editable scene: architecture, woodwork, furniture, plants, materials, lighting, and cameras — all in one go. The first version already captured the feeling I was after — a low-slung roof, an open living space, warm wood, pale stone, and a connection between the interior and the garden.

We gave the house a name: Solace.

The Courtyard House generated after the first prompt — the original Solace.

Although the house came from a single prompt, Astra didn't call it done after the first pass. It reviewed the preview images itself, adjusted the composition and lighting, and even fixed details like plants clipping into each other and an unnaturally placed sofa throw. I didn't have to describe every object in the scene, or issue a new command for every tweak.

At this stage, the scene was still centered on the furnished living space; private areas like the bedrooms existed only as exterior shells, with nothing actually built inside. So this version was more about confirming the visual direction than delivering a complete family home.

Next, I changed the environment:

"Make it golden hour. We should see the sun, and the house should be in the middle of a viridian forest." Astra kept the house and grew a forest around it: layers of trees and undergrowth, a defined sun position, and atmospheric scattering so the sunlight streaming through the trees formed crisp light shafts. The image gained depth beyond the garden, and the warm interior stood out against the forest backdrop.

The same early house, now with the forest and golden-hour lighting.

The house and garden were modeled procedurally; for the larger forest, we used tree, fern, and rock assets from Poly Haven (translator's note: an open-source asset library offering free 3D models, materials, and HDRI environment maps) — so the effort could stay focused on environmental layout and overall mood.

Settling the Floor Plan Before Expanding

With the visual direction confirmed, I wanted to push further.

The intermediate version had added a furnished bedroom, along with improved geometry, kitchen, and furniture. Next, I wanted a larger house that a family could genuinely live in long-term:

"I like the minimalist, modern style, so keep that while we grow the house to be much more livable. Draw me a floor plan first. We'll validate and evolve it from there." From this point on, the project was no longer just about "making the image prettier." We had to answer real spatial questions: How do the rooms connect? Where do the private areas go? How will people move through the house? Those questions can't be solved by cramming more furniture into the first version of the scene.

Astra's proposal was a single-story U-shaped house organized around a planted courtyard: the living room, dining room, and kitchen formed the central space, while the two wings held three bedrooms, an office, several bathrooms, and a walk-in closet. Next to the kitchen, it placed a pantry, a laundry room, and a storage room, consolidating chores and storage in one area.

The concept floor plan confirmed before rebuilding the house.

With a floor plan in hand, many concrete issues could be examined on the table: bedrooms shouldn't become passageways to somewhere else; a circulation loop around the courtyard lets people move between wings without crossing the kitchen's work zone; the outdoor dining area, lawn, and pool extend the living space outward without turning them into enclosed rooms.

I confirmed the direction and asked Astra to back up the current scene before starting work:

"Keep the current scene as a backup, then build the updated house in Blender. Iterate until the house, furniture, and garden are detailed and the geometry is correct. Once we validate it in Blender, we'll export it to Unreal Engine 5." The order matters: review the floor plan first, then the model, and only then invest extra effort in a real-time experience version. Of course, this is still just a concept demonstration — before a floor plan can actually be built, it needs to be re-reviewed by professionals against the site, the structure, and building codes.

Building the Rooms and Furniture

The Garden House kept the forest setting and restrained palette, with the architecture organized around the finalized floor plan. The courtyard became the heart of the entire space, with rooms on both sides looking onto it.

A Blender render of the Garden House after the architectural design and mood adjustments were complete.

How believable a room feels depends heavily on its furniture. Astra built sofa cushions with piping, curved chair frames, individual books, and pottery that is genuinely hollowed out. The bed has a frame, slats, a mattress, and bedding with natural folds; the wardrobe has interior space, shelves, and a hanging rod; the office has a desk with cable management, a monitor, a keyboard, and a rolling chair.

None of this is textures or post-processing — these are actual models built into the scene. They hold up from any angle and can be carried as-is into the later animation and real-time experience. The forms of the cushions and bedding were modeled directly, so they keep their final look without running cloth simulation.

The living room's soft furnishings, furniture, books, and pottery are all fully modeled into the scene.

The kitchen and bathroom meet the same standard of detail: the sink and washbasin have genuinely carved-out interiors, and the kitchen includes an oven cavity, a grill, cutlery drawers, and storage shelves. In a wide shot, these are inconspicuous little things — but the moment the camera closes in on a countertop or steps inside a room, the difference is immediately obvious.

The materials also have to survive close inspection. In the final scene, custom materials are combined with oak, walnut, and plaster textures scanned from Poly Haven (including White Oak Veneer[2]). Astra aligned the wood grain direction, and the texture scale matches the furniture's real-world dimensions.

The kitchen and dining area carry over the restrained palette of the first version of the house, while adding more furniture and woodwork detail.

When generating the final images, Astra uses the --python flag to run Blender in the background with a script that positions cameras, selects lenses, and completes the renders. It also opens Blender directly via computer use, comparing the scene in the app against the saved renders.

(Translator's note: this is exactly the amplification effect of computer use: GPT-6 can run software itself, observe results, and catch and fix errors, so the final output improves far more than the "first-draft ability" does. The official numbers show both improving together: Astra's ScreenSpot-Pro rose from GPT-5.6 Sol's 76.9% to 92.7%, reflecting a better ability to read screens and locate targets for interaction; BenchCAD rose from 83.3% to 95.9%, reflecting improvement in reconstructing 3D geometry from visual input. See the GPT-6 Astra launch page[3] for the data.)

We relied on renders to check the model throughout. Astra outputs views of each room and close-ups of materials, then finds problems in those images and fixes them. For example, the steel sink's surface normals were wrong, making the basin floor — which should have been flat — look squashed. After correcting the normals and redoing the rounded edges, the image came out much cleaner, with the kitchen design itself untouched.

Close-up of the sink after correcting the surface normals and edges.

Turning Off Materials to Inspect the Geometry

Cinematic renders are good for judging atmosphere; turn off the materials and the model itself is laid bare — walls, openings, furniture, room layout, all clearly visible.

The model structure in Blender's solid mode. To make inspection easier, the roof, surrounding forest, and window glass are temporarily hidden here; the model itself is unchanged.

From this angle, it's also easier to see how the project grew from the first version's open space into a complete house: the new version has a continuous floor plan, both wings are furnished, and multiple openings connect to the atrium. Even setting aside lighting and final camera work, these elements remain individually editable in Blender.

Astra also checked geometric details like door openings and wall junctions, and test-walked several circulation paths. Checks like these help surface problems faster, but they can't replace reviewing renders one by one, and they don't guarantee the scene is entirely free of clipping or architectural detail errors.

Giving the House Signs of Life

With the house and furniture done, I went back into Blender to keep adding detail. The layout was solid; next the rooms needed to look "lived in," and the materials needed to hold up in close-ups. This time I made two main requests: adjust the lighting, and add signs of everyday life.

"Make the lighting quieter, warmer, and more accurate. Improve how the materials respond to light, and add dishes and everyday objects so the house feels lived in." Astra kept the architecture intact and placed objects where people would actually use them: plates, cutlery, wine glasses, and folded napkins on the dining table; bread, herbs, and jars on the kitchen counter; an open journal, a pair of glasses, a mug, a phone, and keys on the coffee table — no longer a staged showroom display. The office and bedroom got similar traces of use.

The living room after detail and lighting adjustments, rendered in Cycles at native 4K.

These objects, too, are real models built into the scene: hollowed-out dishware, fluted drinking glasses, folded linen with stitched seams. Astra also kept tuning how surfaces respond to light, combining Poly Haven's wood and plaster scans with procedural detail on fabric, ceramic, and metal. With texture scale, roughness, and subtle surface undulation all properly handled, these materials look convincing even in close-up.

The lighting was redone as well. Astra removed the hidden fill lights that had been flattening the rooms, warmed the remaining sources, and made sure every beam of light has a corresponding fixture in the frame: the ceiling lights are modeled, and the translucent shades actually contain glowing bulbs. As a result, every highlight and shadow has a clear source.

The dining area and kitchen after adjustments. The tableware and light fixtures are all models that remain editable in the scene.

Shooting a Short Film of the House in Blender

I also wanted to see how the house would look through a moving camera, so I asked Astra to shoot a 30-second, 1080p short film of the home — with camera movement that feels both deliberate and naturally handheld. We used low-quality previews to quickly check results, adjusted composition and movement, and only then did the final render.

Astra broke the brief into four shots covering the central living area, the office, the bathroom, and the bedroom, then cut them together. A Python script mounted the camera about 1.65 meters off the ground with a 24–26mm lens, easing naturally in and out of each move with a slight walking bob. The camera's gaze deliberately settles on the furniture and the landscape outside the windows; whenever a preview lingered on a blank wall or ended abruptly, Astra went back and re-adjusted.

To keep the architectural details sharp throughout, no depth of field was added. Cycles rendered 900 individual 1080p frames at 30 frames per second, using adaptive sampling and OpenImageDenoise to control noise, and Astra cut them into the film without interpolating a single frame. Since it's offline rendering, every frame can take its time.

After watching the first cut, I asked for 5 more seconds of outdoor footage before entering the house: the pool, reflections on the water, the lounge chairs. Astra rendered this opening and spliced it into the film — and along the way output five native 4K stills: exterior, atrium, living room, kitchen, and bedroom. The same scene can produce both a choreographed short film and richly detailed stills.

Walking Into the House in Unreal Engine 5

Early in the project, I also had Astra build a version of the house in Unreal Engine 5 that you could actually walk into. I wanted to move freely through the rooms at normal eye level and feel firsthand how the spaces connect. The video below is from that early version, before the detail and lighting work later done in Blender.

Based on the finalized Blender file, Astra wrote a set of export/import tools: the geometry is exported as FBX with modifiers applied (including details generated from Blender curves), along with a JSON scene description recording each part's position, the materials it uses, and how the lights and cameras are arranged.

Unreal then reconstructs the scene from that description. The conversion has to handle the unit difference — Blender works in meters, Unreal in centimeters — as well as the differing coordinate axes. Repeated trees share a single instanced mesh, so every tree in the forest doesn't need its own full geometry.

Materials need converting too — Blender and Unreal have different material systems. Astra reads the compatible material inputs from Blender, keeps the original textures, and builds a corresponding Unreal material for each surface type: wood, stone, fabric, glass, water. The placement and sizing of textures on the geometry carry over, including the direction of the wood grain. Some shader effects can only be approximated, so the final result still comes down to hands-on inspection and debugging.

Lighting is its own body of work. The sun's direction and the scene's existing light positions provide the foundation, while Unreal's sky and volumetric fog rebuild the forest atmosphere. Astra compares Unreal's output against Blender side by side while tuning the outdoor fill light and fog — preserving the original mood while letting the light respond to the player's movement in real time.

The packaged, running Unreal version. Display settings were specifically adjusted to capture this kitchen close-up.

Next come the player character and the collision system. Astra added a first-person character, walking controls, and a spawn point: the ground has to support you, walls, furniture, and glass have to stop you; nearby tree trunks can be obstacles, but not every fern should become an invisible wall. Finally, it packaged the project into an app that runs directly on Mac, and tested several routes based on how a player would actually walk.

Being able to walk into Solace myself also gave me a new way to review the design: approaching the house from the garden, entering the living space, then standing in spots the rendered shots never captured, looking at each room.

Once the Blender details and lighting were finished, I had Astra sync the more lived-in new version of the house into Unreal. It re-imported the updated geometry and materials into the existing project, and added interactivity to the model: the export process records which parts make up each door and drawer, which axis they rotate around or which way they slide, and which lights each switch controls. In Unreal, door handles, drawer boxes, and the objects inside them all move along with their parent structures.

The biggest change: things in the house actually work now. Following the on-screen prompt and pressing E, you can open doors, open the kitchen cabinets, control some of the lights, and even operate the coffee machine — in the brewing animation, the button gets pressed, coffee flows into the cup, and the liquid level rises bit by bit. All those details previously built in Blender have become interactions the player can trigger by hand.

Comparing the Blender and Unreal renders side by side

After the latest round of revisions, I had Astra rebuild the storyboards with the new version of the house and the same camera positions: each frame kept individually, then assembled into two complete storyboard sets — one Blender, one Unreal Engine 5. Both storyboards open with a large exterior shot of the house, followed by six views: living room, kitchen, office, bedroom, bathroom, garden. Numbering, titles, short descriptions, fonts, and spacing were all handled by Astra, with every image preserved in full, uncropped.

One set was rendered in Cycles, the other captured in real time with Lumen: the seven scenes in the same order, with camera positions, orientations, and fields of view matched one to one; each side keeps its own lighting, materials, and tone mapping — the Unreal version's bathroom mirror even shows some reflection artifacts. Placed in the same layout, the differences between the two are visible at a glance, and the scattered views become a complete presentation of the house.

The Blender storyboard assembled from Cycles renders.

The Unreal Engine 5 storyboard assembled from real-time Lumen captures.

Applying the same method beyond architecture

I've used the same method to build completely different 3D scenes. In the HELIOS project, I had Astra build a Dyson sphere around the sun.

This fictional energy collector ended up with several thousand individual panels: each one has a concave surface, heat-dissipation fins, and maintenance facilities with support structures, with larger control nodes distributed throughout the system.

Astra then used materials and lighting to keep these structures clearly legible next to the blinding star.

The original HELIOS collector uses an open structure with the central sun clearly visible. Sizes and distances were adjusted for visual effect, not strict astronomical scale.

Astra proactively checks the renders as it works. In the first batch of previews, it noticed a planet looking washed out and Saturn's rings getting cut off at the frame's edge, so it lowered the fill light and pulled the camera back on its own. Later, when I asked for a view from Earth toward the nearly closed shell, it made a version with only three narrow slits.

In the preview, only one beam of light read clearly, so Astra moved the emissive surfaces closer to the openings and tried several sets of parameters for the ocean material to suppress reflections that would steal the show.

Viewed from Earth, the nearly closed shell of 5,120 panels, with beams of light coming through three openings. Sizes and lighting were likewise adjusted for visual effect.

The HELIOS renders use solar imagery from NASA JPL / STEREO and SDO[4], adapted from false-color ultraviolet observations; Earth imagery comes from NASA Earth Observatory's Blue Marble[5]. Earth at Night imagery[6] is courtesy of NASA Earth Observatory / Robert Simmon, using Suomi NPP VIIRS data from Chris Elvidge, NOAA NGDC. Planet and cloud textures come from Solar System Scope / INOVE[7], adapted under a CC BY 4.0[8] license.

In the Shipyard project, Astra built a cruiser called the AURELION-07.

It has a forward-tapering hull, segmented rings, and four groups of richly detailed thrusters; the engines feature restraining rings, maintenance piping, recessed nozzles, and concentric emissive structures. Ceramic armor, machined metal, and glass each have their own materials, with procedural textures adding variation in color, roughness, and surface detail to the armor and metal. Geometry, materials, lighting, cameras — everything remains editable in Blender.

A Blender render of the AURELION-07; the ship model remains editable.

In this project, Astra again used previews to find improvements: it decided the bow was too plain and the background planet too eye-catching, so in the next version it added panels and seams along the tapering hull, attached docking structures and ring fasteners, and moved the background planet while dimming its brightness. After that, it inspected the ship from multiple angles, including the engine area. Many of the modeling and composition adjustments were completed before I pointed out issues one by one.

A second view of the same ship, showing the engine structures and surface detail more clearly.

Designing a garden from real-world references

I also had Astra build a garden modeled on Monet's garden at Giverny, with a water lily pond, a green footbridge, and dense plantings. In the early renders, the area behind the pond looked empty, so I had it study real references and fill in the surrounding garden and buildings.

In the next round, I mainly had it improve surfaces whose textures still felt thin. Astra added textured gravel paths and masonry, continued refining the lily pads and petals, then rendered new Cycles frames for me to review.

The final result is still an editable Blender scene — the proportions just don't exactly match the real garden, for the sake of the visuals.

A Cycles render of the Giverny-style water garden. Some plants, textures, and the sky environment come from Poly Haven.

You can start with a scene too

What strikes me most about Solace is how a single idea can keep growing along this path: first describe an atmosphere, then review floor plans, then ask for more precise furniture, and finally actually walk into the space.

Astra handles the scenes, the scripts, and the Unreal project; I only handle judgment — what this space should become.

HELIOS and Shipyard are similar: look at the overall design first, then go all the way down to individual components, with Astra self-checking and continuously improving throughout.

If you'd like to try it yourself, start with a space or object you want to see: a room, a piece of furniture, a spaceship, or an imagined landscape. Describe its purpose and atmosphere first, and let Astra generate an editable scene along with a few check renders. Look at the overall shape first, then zoom in and keep pointing out what needs fixing.

Every new render becomes the basis for the next round of revisions — whether you just want to polish a single object or eventually walk into an entire world.

References

[1] Blender Python API: https://docs.blender.org/api/current/

[2] White Oak Veneer: https://polyhaven.com/a/white_oak_veneer

[3] GPT-6 Astra launch page: https://openai.com/index/gpt-6-astra/

[4] NASA JPL / STEREO and SDO: https://svs.gsfc.nasa.gov/30362

[5] NASA Earth Observatory's Blue Marble: https://science.nasa.gov/resource/blue-marble-2002/

[6] Earth at Night lights map: https://science.nasa.gov/earth/earth-observatory/night-lights-2012-map-79765/

[7] Solar System Scope / INOVE: https://www.solarsystemscope.com/textures/

[8] CC BY 4.0: https://creativecommons.org/licenses/by/4.0/