My GPT-6 Astra Review

The model I actually want to work with

Over the weekend, a fairly complicated agent service I’d built and shared with a bunch of friends went down, and one of them texted me to let me know it was broken. I was out with my girlfriend and didn’t have time to deal with it myself, so I opened Codex on my phone, pointed Astra at the project, and literally just said, “down, please fix.” Then I put my phone away.

An hour later, he texted me to say it was back up. No intervention from me. I’d completely forgotten I’d even asked Astra to fix it. My reaction was basically, “oh, hell yeah,” and I went on with my day.

Given what happened to my computer, that probably deserves some explanation. Astra is more cautious than its predecessor, occasionally a little too cautious, but I think OpenAI has struck a really good balance here. It gets on with the work without constantly stopping to ask for permission, while being more reserved about what it takes upon itself to do. In my experience, it’s a model I can trust much more than the last one.

For day-to-day engineering, and plenty of the other things I do on a computer, Astra is pretty damn close to what I’ve wanted all along. I tell it what I need, and it gets the job done. Backend work has been especially strong, and it’s also been useful for catching problems in code written by other models. It feels like a much bigger, smarter model than the OpenAI models I was using before.

For the work I’m giving an individual agent, the biggest improvement I’m still wishing for is speed. Having a whole group of agents working together opens up some very different possibilities, and we’ll get into that. But you don’t need an elaborate setup to get great results here. For regular work, whatever you want to do, all you need to do is ask. I’ve been using Ultra reasoning effort for a lot of my bigger experiments, while Medium reasoning effort has been a really good middle ground for everyday use.

It’s also much easier to work with, for a reason that sounds almost embarrassingly simple: I can actually understand what it’s telling me. A lot of recent models, especially Claude but also some of OpenAI’s, have a habit of answering straightforward questions with incredibly dense technical explanations. I’ll read an entire response and still not know whether it actually did what I asked it to do. Astra generally speaks in plain English, keeps its responses reasonably short, and makes it easy to understand what happened and whether anything needs my attention. When you’re managing a bunch of agents at once, this makes an enormous difference. I can scan their updates and move on with my day instead of having to mentally load five different projects just to figure out what they’re asking me.

Computer use deserves quite a bit of attention here, too. It’s an area I follow particularly closely, having worked on early browser agents at HyperWrite. We launched our browser assistant in 2023 and developed our own models for operating software, so I’ve been thinking about this for a while. For a long time, these systems could pull off impressive demos but still needed enough supervision, or took so long to finish, that I’d often rather just do the task myself. And even something that works 99% of the time can be hard to trust if you’re constantly wondering whether this is about to be the other 1%.

Fable 5’s computer use was already very good. Astra feels another step above. I’ve had it work on my newsletter and access inboxes through the browser when I couldn’t get a direct integration set up. It moves quickly, gets through the work, and remembers little preferences like marking emails unread again when that’s how I want them left. I’ve also had it work on ad campaigns, which was fucking fantastic. Those interfaces are a pain for me to navigate, and I don’t know them particularly well. Being able to hand that work over without having to figure out where everything lives is enormously useful.

I’m comfortable leaving it to do those things without watching every click. In fact, Astra’s computer use is so good that I often don’t even realize it’s running at all. The task gets done, the model used it, and it’s moved on. I literally don’t think about it anymore, and it’s such a freeing feeling.

I’m also starting fresh conversations much less often. My threads tend to run for a long time, and when I need multiple agents, I’ll often ask the one I’m already working with to start the others. As a conversation grows, Astra does a remarkably good job of holding on to what matters. The process of condensing a long conversation so it can keep working feels almost seamless; I’m not constantly having to re-explain things afterward. I can show it examples, give it feedback, and build up a shared understanding of how I want the work done. In most of my work, that makes the agent more useful over time. Writing is still an exception, where I haven’t had nearly as much success getting it to absorb my preferences.

Another standout capability is how well these models communicate with each other. The Codex harness does a great job of enabling this, and Astra takes full advantage. When I’ve needed to move work to a new agent, I’ve had it talk to the previous one and get itself up to speed. They worked through the handoff together, and the new agent carried on.

All of this adds up to a model I now use for almost everything. Claude still has better visual taste and is better at creating visual assets, and I still reach for it for design and certain 3D tasks. (I tried having Astra redesign somethingbig.ai, for example, and didn’t get good results.) But Astra is much stronger across the rest of my work. And as much as I appreciate having something that can quickly fix a broken app while I’m out with my girlfriend, that’s hardly the limit of what I’ve been asking it to do. Some of the bigger projects are frankly ridiculous.

So, naturally, I asked it to build a civilization

One of the projects I gave Astra was a simulated civilization: a world with animals and people, where each person was powered by an Astra agent. With the coordination setup I’ll explain shortly already in place, I gave it one prompt and let it work.

At some point, I was in my room when I heard voices coming from my computer. I walked out, and the inhabitants were talking to each other. I knew that was part of what I’d asked for. Hearing it happen from another room was still a holy-fuck moment.

Astra had built a world that looked beautiful, populated it, and worked through getting its inhabitants functioning. Watching it adjust the animals’ behavior was particularly fun. Early on, they were doing things like falling into the water; as it kept working, their behavior improved. With the human characters, it got a couple working first, then started adding more. Eventually, I had conversations coming out of my speakers.

Getting to this point took some trial and error, though. I had to approach the project quite differently from how I would with Claude.

Give it the right tools

Claude is still better at creating the visual pieces themselves. Ask it to build something in Blender or produce a 3D scene directly in code with Three.js, and it’s generally better at making the result look right. I wouldn’t describe Astra as bad at spatial reasoning. The gap is more in its ability to create convincing, good-looking visual assets. Having Astra use Blender helps, but even then, I haven’t been getting results that match what Claude can produce directly in code for these Three.js projects.

I tried a lightly adapted version of my original Claude-of-Duty prompt with Astra. The result was good. If I’d seen it before Claude’s version, I would have been thrilled. Put the two next to each other, though, and Claude’s advantage is clear.

Claude

Astra

But give Astra Unreal Engine, where it can work with existing assets and tools, and things get very interesting. It’s finally smart enough to make substantial use of that environment. Fable 5 hadn’t been able to drive Unreal nearly as effectively, though I suspect 5.1 will be a major improvement. (I got it connected and sort of working, but my earlier experiment didn’t get much further than that.)

I tried similar requests in Three.js and Unreal for both the civilization and the New York project I’ll show you below. The difference was not subtle.

Astra used existing assets, including MetaHuman characters, so it didn’t create every object or person from scratch. That matters when you’re comparing the results. But it’s also exactly what I want an agent to be able to do. There are incredible tools and resources available for building this stuff.

In a separate, earlier game experiment, it got cars working using existing assets, opened the game, played it, and made adjustments based on what happened. It was far more capable of playing the game it was building than previous models.

One prompt, quite a few agents

Astra already does much better than Fable 5 on long projects, but it still tends to reach a point where progress slows down. It keeps working, often getting absorbed in small details, without making the overall project much better. I tried several ways of organizing agents around these projects. They worked, but none really got past that same plateau. This arrangement finally did.

I’m calling this the Manager Loop: one agent keeps the project moving, while another does the work. I start by having the coordinator interview me until we agree on a goal. It turns that into a checklist of to-dos, then starts an implementer in a separate Codex session... a completely separate agent, not a sub-agent. The coordinator gives it a phase to complete, using goal mode to keep it working toward that phase’s finish line, lets it work, and moves it on to the next phase when it’s done. The implementer can bring in sub-agents as needed. Essentially, the coordinator takes over the job I’d been doing myself: keeping the work moving through the larger plan.

I also generate a web page showing the checklist and a graph of how many items have been completed over time. I’ve built a way to visualize the sub-agents working on the project, too. It’s much easier to follow what’s happening when I can see the work laid out.

I also gave it considerably more room to delegate. On one of my computers, I changed the Codex configuration to allow up to 16 sub-agents at once instead of four. On the machine running the civilization and New York projects, I pushed that to 96 (though it didn’t always use that many). It was obscene overkill and would be incredibly expensive, but I wanted to see how far I could push it. You may also need to explicitly encourage it to use more sub-agents. I’ve sometimes had to do that even at Ultra reasoning effort; increasing the limit alone doesn’t mean it will make use of it.

This is what I mean when I say the civilization came from one prompt. I’d already done the experimentation to find this arrangement and set it up. Once that was in place, I could give it the project and let the agents work through it. The amount of work happening underneath that one request was enormous.

I’m putting together a separate guide and a ready-to-use setup so you can try this without having to repeat all my experiments. The checklist and sub-agent visualization tools will be available there, too. Get notified when the Manager Loop is ready → The important thing for now is that you don’t need this for ordinary work. This is what I’ve been using when I want to ask for something absurd.

And then there’s New York

In parallel, I’ve been having Astra build a version of New York City in Unreal. The original ambition was something GTA-like, because apparently building a civilization wasn’t an unreasonable enough request.

This also started with one prompt. I’ve done a little steering since then, but it hasn’t amounted to much more than telling it to be more ambitious and keep going. I haven’t been directing the construction street by street.

This one is still very much in progress. But the level of detail it’s achieving, and the way it continues working through the build, have been astonishing. It was refining the first street before moving on, and the project keeps getting bigger. It looks fucking amazing.

The surprising part is how little I’ve had to contribute after the initial request. There’s a massive amount left to build, but the agents keep making progress without needing me to turn that ambition into hundreds of individual instructions.

I still wouldn’t call long-running autonomous work solved. Astra can get absorbed in small details, and the coordination setup is necessary to keep the larger project moving. I want this to happen naturally, without having to arrange it myself. I wouldn’t be surprised if we’re only a generation or two away from that. But this is the first model where I feel like I can get it there with the right prompting and setup.

Beyond the game worlds

I’ve also had Astra build a web browser. This was one of the projects I started before figuring out the coordination loop, and it’s a good example of the plateau I mentioned earlier. Astra built a set of tests, compared its browser’s behavior against Chromium, and kept working through the differences. It got as far as rendering Google reasonably close to how it should look. But eventually, the improvements slowed down, even though there was still plenty left to do. I’d be very interested to see how this project would go with the setup I’m using now.

It’s also been good at building AI into applications, including working with Codex App Server.

I’ve had useful results outside engineering, too. Astra reviewed my tax information and identified potential savings my accountants hadn’t raised.

One of my favorite builds came from a much less glamorous problem: I was running out of disk space. My Codex threads had become enormous, and I was talking to Theo about it. (Shoutout to Theo. I’ve also been using T3 Code, and it’s been awesome.) He’d built a system to handle this with previous models and was telling me how complicated it had been to get working. I joked that I’d just ask Astra to do it.

Two prompts later, it had built a system that moves old threads to the cloud, removes the local copies, and loads them back when I click on them in Codex. It just nailed it. Having that conversation immediately beforehand made the whole thing pretty funny.

That one is easy to overlook next to a simulated civilization, but I love it. Something about my setup was annoying me, I described what I wanted, and now it works that way. I’m running enough agents that they’re creating new problems for my computers, and I’m asking those same agents to fix them.

How much work can you afford?

The disk-space problem was part of a somewhat ridiculous situation in my apartment. During testing, I ended up with a Mac mini on my kitchen island, three MacBook Pros on my coffee table with their fans blaring, and my main Mac overseeing the others. There was also a cloud machine that I’d overloaded with agents. If you saw me talking about running five Macs and wondered what the fuck I was doing, this was it.

I was running into memory limits. I switched some work from the Codex app to the terminal because it used less memory there. I even had agents watching the machines’ memory and disk space so the other agents could keep working. At some point, you have to appreciate the absurdity of employing an AI to keep your computer healthy enough to employ more AIs.

We need better ways to run all of this. I want cloud computers that can handle the work, and a straightforward way to manage the agents on them. There’s a lot of room to improve the experience between giving an agent a job and having to find another laptop for it.

Obviously, you don’t need an apartment full of computers to use Astra. I was running a lot of experiments at once to find out what it could do. For actual work, I’d generally rather focus on fewer projects and do them really well. But I could have run more experiments if I’d had more capacity, which is a little mind-boggling considering what was already happening in my apartment.

As these models get better, there’s more reason to run more of them. An additional agent can take on another substantial piece of work, with less of your attention needed to keep it useful.

I know it sounds crazy, but I firmly believe that a year from now, we’ll each be using hundreds of times more tokens than we do today.

You still need judgment and good coordination; throwing agents at a project doesn’t automatically improve it. But with something like the Manager Loop, I’m starting to see how much more work I can set in motion from a single request. That makes the amount of model usage you can afford much more consequential.

Two people can have access to exactly the same model and have very different capabilities in practice. One might need to ration their usage or work on one project at a time. Another might be able to leave agents working on several large projects, try multiple approaches, and keep the promising ones going. As agents become more capable and require less supervision, I expect that difference to grow.

It starts to look a lot like hiring. Having the money to employ twenty people gives you options that working alone doesn’t. Agents make that kind of help accessible to far more people, which is genuinely exciting. But there will still be an enormous difference between being able to afford a little help and being able to afford as much as you can use.

I find that both exciting and uncomfortable. Someone who could never have afforded to hire an engineer can now get real software built. At the same time, someone with a much larger budget can put the same technology to work at a completely different scale. Cheaper intelligence could expand what almost everyone can do while still widening the gap between them.

At the time of writing this review, I don’t know Astra’s launch pricing, and my excessive experiments are clearly not a sensible everyday setup. But this is why I think the cost of tokens is going to matter so much. If agents can keep making useful progress on increasingly ambitious projects, your budget starts determining how much of that work you can have happening at once.

And spending more tokens also gives you more opportunities to get good at using them. You can try more ideas, find out what fails, and figure out approaches you wouldn’t have discovered otherwise. The Manager Loop came out of exactly that kind of experimentation. People who can afford to do more of it will likely develop an advantage in how effectively they use the models, too.

Astra feels like another glimpse of that world. The setup still takes some work, and I’m sure we’ll find better ways to coordinate these systems. At the beginning of this year, I found it amazing that I could put in a prompt and come back later to a finished SaaS app. But we’re beyond that now. We’re firmly in a world where you can put in a prompt and come back to meaningful progress on a project that would previously have been considered ambitious for a team of humans to take on.