Astra can get a lot done and not

The Model

GPT-6 Astra is OpenAI's most capable model for demanding end-to-end work, including coding and complex reasoning. Its model guidance describes stronger instruction following and work across code and other tools. The same guidance introduces async tool calling, mid-turn steering, and the ability to change reasoning effort during a conversation through the API. Those are platform capabilities; this article is about my experience using Astra inside Codex, not a test of every API feature.

I noticed the improvement most in how it handled context. It picked up what the website was trying to do and made new decisions that fitted the direction already in place. That matters in frontend work. A page can be technically complete and still feel detached from the rest of the site. I wanted to see how much of that judgement Astra could supply from the repository and a short prompt.

The Astra Run

The Services area had accumulated nine separate offers. I asked Astra to simplify them into three clearer groups and redesign the page. I deliberately kept the prompt light as a test. It had access to the repository and used Luna subagents for parts of the work.

In roughly 15 to 20 minutes, it produced the new AI Integrations, Online Branding, and Automations structure and a substantially different Services page. It did more than rename cards. It reworked the route content, page hierarchy, navigation relationships, and service detail presentation around the smaller offer. The result felt coherent with the direction I had been developing for the site.

That is the part that felt noticeably smarter to me: Astra could take a small instruction, understand the surrounding intent, and commit to new ideas that belonged with it. I still reviewed the output. Speed and confidence are useful only when the page says the right thing to the people who will read it.

The Sol High Run

I then used GPT-5.6 Sol at High reasoning effort to simplify a larger set of product pages into four groups: Platform, Workbench, Console, and Suite. This run also used Luna subagents. The first pass took about 40 minutes and left me with a satisfactory foundation.

The difference showed up in instruction following and design continuity. A few directions had not been followed clearly, and the Products result did not yet feel as resolved as Astra's Services work. I sent three follow-up prompts, essentially asking Sol to study what Astra had done and move the product experience closer to that standard. Those corrections took about another 20 minutes.

That is roughly an hour of elapsed work for Products, compared with 15 to 20 minutes for the Services redesign. It was also more of my own attention: I had to spot the gaps, identify the reference worth using, and describe the next adjustment. Both results are useful, but the path to them was different.

The Resource Question

My Codex usage reports showed Sol High consuming about half the tokens Astra consumed, even after the three extra prompts. I am describing the usage shown for these particular runs, not a model-wide efficiency ratio or a price comparison. The jobs had different page surfaces and different amounts of work, so the figures cannot isolate the model as the only cause.

Still, those figures make the choice practical rather than abstract. Astra saved elapsed time and reduced how much I had to spell out. Sol High spent fewer tokens, but asked for more review and correction. The resource that mattered changed with the situation: sometimes it was model usage, and sometimes it was the time and attention I could give the page.

My Shorthand

My deliberately over-the-top comparison is Astra as Rambo with a machine gun. Give it a large front and a tight deadline, and it can move an astonishing amount of work very quickly. It will also burn through resources. When I need a broad redesign under pressure, that trade can make sense.

Sol High feels more like the American Sniper: capable of finishing the job with less waste, provided I give it a clear target and keep it aimed. For a contained improvement, I can describe the acceptance criteria, point it at the right reference, and use the smaller footprint. In this case I learned that I had to be more deliberate about that guidance than I initially expected.

Neither analogy is a claim that one model is universally better. Astra's strength here was initiative within a messy frontend brief. Sol's strength was its lower usage while still reaching a serviceable result. The same model could behave differently on another repository, prompt, or kind of task.

Advice for Codex Builders

For a frontend change that crosses navigation, copy, page structure, and visual design, I would consider Astra when I need the model to carry more of the interpretation. I would also give it the real repository context and budget enough usage for a broad pass. A short prompt worked well in this experiment, but that is not an argument for withholding essential constraints on production work.

For a narrow change with a good reference, I would consider Sol High and state the target precisely: which routes matter, what existing work should guide the design, and what would count as done. If the first result misses something, the next prompt should name that gap instead of asking vaguely for polish.

Whichever model I use, I compare the rendered pages and the diff. Here the Services hub and its three service routes show the Astra direction; the Products hub and its four category routes show the Sol High direction. I have linked the public pages below so you can judge the output yourself. My timing and usage notes describe what I experienced, while the pages show what was built.

The repository history records the related change sets as e8d35ef for Services and 64e49f0 for Products. Those commit IDs are useful to anyone with repository access; the working branches are not public.