OpenAI released GPT-6 Astra on September 3 and described it as its most intelligent and aligned model yet, with major gains in computer use, software engineering, browsing, professional work, science, and cybersecurity. Naturally, I started using it almost immediately on another website project. This has become a predictable response whenever someone gives me a stronger AI model: apparently I need to create another website, app, or elaborate system that nobody asked for so I can see what the model does when given real work instead of a benchmark prompt.
The timing was convenient because I was building an eight-page static HTML site rather than one of the custom WordPress sites I usually make. I had already started writing about Astra in My $40/Month ChatGPT + Claude Workflow, where I was still figuring out where it belonged alongside GPT-5.6 Sol, Claude Code, Claude Design, and the cheaper OpenAI models. A week later, my opinion is clearer. Astra is obviously extremely capable, and I am also increasingly convinced that using it for everything would be an absurd waste of my ChatGPT Plus allowance.
That does not mean I think Astra is overhyped or that its benchmarks are meaningless. My own work is actually a good example of why personal AI reviews need caveats: I know static HTML, WordPress, and SEO well enough to notice structural problems and push the model on them, while I have also used Sol to build an Android app in a domain where I knew almost nothing about the underlying development stack and mostly cared whether the finished product looked and worked the way I wanted. Expertise changes what you notice. It also changes what you ask the model to do in the first place.
What GPT-6 Astra Actually Improves
OpenAI is not subtle about Astra’s positioning. Its release announcement calls it the company’s strongest model for demanding professional work and reports some genuinely ridiculous benchmark numbers. Astra scored 59.3% on Agents’ Last Exam compared with 53.6% for GPT-5.6 Sol and 55.5% for Claude Opus 5. On OSWorld 2.0, which tests computer use, Astra scored 72.6% versus 65.7% for Sol, and OpenAI says it completed the simulated tasks in about 47% less time. Terminal-Bench 4.0 shows an even bigger coding gap, with Astra at 57.9% compared with 37.3% for Sol and 55.8% for Claude Fable 5.1. BenchCAD came in at 95.9% for Astra, 83.3% for Sol, and 84.3% for Fable 5.1.
The academic and cybersecurity results are even more dramatic. OpenAI reports 97.6% on FrontierMath Tier 4, 99.9% on ARC-AGI-3, and 100% on ExploitBench. Astra is also the first broadly deployed OpenAI model to meet the company’s Critical cybersecurity capability threshold, and OpenAI says it found and used two previously unknown zero-day vulnerabilities during evaluations. I am not doing cybersecurity research with it, so that part of the release has very little to do with my own experience, but it is important context for why OpenAI is treating Astra as more than a routine model refresh.
It is also worth pointing out that Astra does not simply dominate every row in OpenAI’s own comparison table. Claude models beat it on some broader intelligence and coding-agent measures, and the differences between frontier models can become surprisingly small once the previous model already clears the competence threshold for what you are doing. I made a similar point after GPT-5.6 Sol launched: a model can be meaningfully better on benchmarks without feeling dramatically different during routine work if the previous model was already capable of doing that work well.
My First Website Project With GPT-6 Astra
Static HTML is familiar territory for me. I know what I want from the design and architecture, understand front-end development well enough to recognize bad implementation choices, and have worked professionally with SEO for well over a decade. I care about reusable site components, heading structure, metadata, canonicals, schema, sitemaps, responsive behavior, internal linking, and whether a bunch of nearly identical design elements have somehow acquired their own bespoke CSS classes. Someone vibe coding their first website may never inspect any of these things, and I think that distinction matters when people compare experiences with AI development tools.
Astra did plenty well. I could throw large amounts of work at it at once, and it could reason across the project, implement complicated changes, inspect what it had done, and occasionally make thoughtful decisions I never requested. One small example I liked was that it added informational popups to links leading to sections that were not ready yet. I could easily have asked Sol to do the same thing, but I had not. Astra noticed the UX problem and came up with a sensible treatment on its own, which is exactly the kind of initiative I expect to become more common as coding agents improve.
At the same time, I kept encountering things that felt hilariously ordinary for a model being discussed in the same general atmosphere as AGI. I had to tell it to use global site elements. I had to explicitly push some of the technical SEO work I wanted. After spending the weekend iterating heavily on individual page designs, I later used Claude to help clean up what I started calling the Astraslop: a huge number of overly specific CSS classes that had accumulated instead of the model recognizing enough shared visual patterns and consolidating them.
Some of that was absolutely my fault. I was designing interactively, asking for granular changes to individual elements and pages instead of handing Astra a pristine design system and architecture document at the beginning. That style of development encourages one-off implementation because I am effectively saying “change this thing” over and over. Still, if we are talking about increasingly general machine intelligence, recognizing that dozens of elements I keep asking to look almost identical should probably use a common pattern seems like a reasonable expectation. My abbreviated reaction was basically: if this is AGI, why can’t it recognize common styles instead of giving me thousands of unique classes?
I do not think that contradiction means the benchmarks are bullshit. A model can be spectacularly capable across difficult reasoning and agentic tasks while still making architectural decisions that an experienced human finds stupid. Anyone who has worked with talented humans should already be familiar with this phenomenon.
Expertise Changes How Impressive Vibe Coding Looks
This is where my experience becomes less useful as a simple “is Astra good at coding?” review. I know websites well enough to notice problems that another user might never know to look for, and that can perversely make the technology look less impressive to me even while it is dramatically expanding what less experienced people can build. If someone knows nothing about web development and Astra creates a responsive website that looks good, loads correctly, and does what they wanted, the fact that I could later consolidate its CSS or improve its schema does not make the accomplishment meaningless.
Astra or Sol may give that person a far better result than they could have produced otherwise. They may also make mistakes that the user has no idea exist. Both things can be true, which is why “vibe coding works” and “you still benefit from knowing what good code looks like” are not competing positions. The models reduce the expertise required to make something useful, but expertise still improves the finished product and helps you identify when the model has done something unnecessarily weird.
I have experienced the other side of this myself. I recently had Sol build me a personal Android app despite having essentially no Android development background. I understood the product I wanted, cared a lot about the interface and behavior, and could tell whether the buttons worked and the data was being recorded correctly. I did not have anything close to the same ability to evaluate the underlying Android architecture that I have when looking at a WordPress theme or static HTML site. Sol could theoretically have committed some grotesque Kotlin crime under the hood and I might not have recognized it.
That does not make the app bad. It means my evaluation was limited by what I knew. Someone who could not previously build an Android app now has a functioning Android app, which is a meaningful change regardless of whether an experienced mobile developer could improve the implementation. On web projects where I already have expertise, AI is doing something different for me: it compresses implementation, gives me more options to evaluate, and lets me iterate to an obsessive degree without manually doing every boring thing myself. I wrote about that dynamic more broadly in Ritual Reuptake: The AI Dopamine Loop. AI does not eliminate judgment. If anything, faster implementation gives you more opportunities to exercise it.
GPT-6 Astra Burns Through ChatGPT Plus Usage
My biggest practical complaint about Astra has nothing to do with CSS. It eats usage like crazy, and this became obvious almost immediately even when I used lower reasoning settings. I am on the $20 ChatGPT Plus plan right now, so I am not expecting unlimited access to OpenAI’s most expensive frontier model. I have paid for $100 AI plans before and may again when the workload justifies it, but lately I have specifically been testing how much I can get from ChatGPT Plus and Claude Pro together. That makes model selection part of the workflow whether I want it to be or not.
OpenAI’s current Work and Codex usage guidance explains why Astra felt so brutal. On Plus, OpenAI estimates roughly 5–45 local Astra messages per five-hour period, compared with 10–100 for Sol, 25–200 for Terra, and 250–2,000 for Luna. These are not fixed message caps because context size, reasoning effort, tool use, task complexity, Fast mode, and output length all change consumption, and weekly limits apply on top of the five-hour window. Still, the relative difference is enormous. Work and Codex also share the same allowance, so using Astra heavily in one means less room everywhere else.
My experience lined up with that. Small Astra tasks could consume an uncomfortable percentage of my allowance, while giving it a substantial batch of work at once felt much more worthwhile. That makes intuitive sense for a model designed to reason deeply, inspect a repository, use tools, verify its work, and stay coherent across long tasks. Repeatedly invoking all of that machinery because I have decided that a card needs four pixels more spacing is probably a stupid way to spend frontier-model compute.
OpenAI’s own Astra model guidance is unusually candid about some of this behavior. It says Astra tends to be thorough with testing and verification and can run broader checks than a small change warrants, so developers may want to explicitly tell it not to over-test reversible, low-impact work. OpenAI also notes that higher reasoning effort does not always produce a better result. During the launch weekend, Tibo said the company had already made changes that could reduce subscription usage by as much as 3–4x on the long tail for some Astra power users without changing model quality. My first weekend with Astra was therefore happening while OpenAI was still tuning how much of the subscription meter the model consumed.
Tibo’s Astra Resets Became Part of the Launch
The usage story gets stranger because OpenAI also spent the Astra rollout handing out resets. Tibo, who leads ChatGPT Work and Codex, initially announced that paid users would receive one banked reset for every day they did not yet have Astra access while the rollout was still in progress. A banked reset sits in the account until you choose to use it and refreshes the eligible five-hour and weekly Work/Codex allowances. Because I did not have Astra during the first part of the rollout, I ended up with two banked resets to play with once I did get access.
OpenAI’s official reset documentation now confirms that eligible existing Plus, Pro, and Business users received a banked reset on both September 3 and September 4. Then, on September 7, OpenAI gave those users another global reset that applied automatically instead of being saved for later. In practical terms, I had far more Astra capacity during launch weekend than a normal $20 Plus week would provide, which is important context when I say I used Astra heavily. I was not carefully rationing one ordinary weekly allowance. I had several opportunities to refill the tank while deliberately trying to see how quickly I could empty it.
The community reaction was predictably funny. Once users realized delayed Astra access was earning them banked resets, a Reddit thread announcing the policy immediately filled with people deciding they were suddenly very patient. One user wrote, “Now I don’t want Astra for 3 weeks please,” while another said they could wait “days and days” and got the reply, “Days? Months.” The shiny new model had been available for hours and users had already turned not receiving it into the more desirable product.
The resets also became their own tiny economy because activating a banked reset changes the date of your next weekly reset. Users started discussing when to spend them, complaining when they used one shortly before OpenAI surprised everyone with another global refresh, and building third-party sites that track Tibo’s reset announcements. I have some sympathy for the planning problem because these limits affect how much work you can get done, but there is also something very funny about watching people become furious that their strategically hoarded free compute was devalued by additional free compute.
More seriously, the reset frenzy demonstrates how central usage has become to evaluating coding models. People are not merely comparing intelligence anymore. They are comparing how long a model can remain useful before the subscription meter stops them, whether lower effort preserves enough quality, whether a cheaper model can implement a plan created by a stronger one, and whether orchestration saves usage or burns even more of it. That question became more interesting to me than whether Astra could beat Sol on another benchmark.
Sol Is Still Excellent, and Terra Finally Makes Sense to Me
My first response to Astra’s usage was to fall back on Sol and start giving more small tasks to Luna. More recently, I have also discovered that I was sleeping on Terra. When GPT-5.6 launched, Sol quickly became my favorite OpenAI model for development and a lot of general-purpose work. Nothing about Astra’s release has suddenly made Sol bad. If I have a substantial feature to implement, a messy bug to investigate, or a project where I want strong judgment without thinking too hard about whether the task deserves Astra, I still use Sol constantly.
Luna came into the picture because I was running out of usage. I started using it for the obsessive little tweaks that make up a surprisingly large percentage of website development once the main architecture works, and it was better than I expected. If I already know exactly what needs to change and the task is focused, repetitive, or easy to verify, I often do not need Sol and definitely do not need Astra. OpenAI positions Luna as the fast, economical model for focused work, and the fact that its estimated Plus usage range is an order of magnitude larger than Terra’s and dramatically larger than Astra’s makes that difference hard to ignore.
Terra is turning out to be the missing middle. OpenAI describes it as balancing speed, capability, and cost for everyday work such as routine code changes, which sounded like boring product taxonomy until I started using it more. For web development, there is plenty of work where Luna feels a little too lightweight but Sol is more intelligence than I need. Terra can inspect enough context, understand what I am doing, and make a normal implementation change without consuming nearly as much of the shared allowance.
I do not have a rigid workflow where Astra gets architecture, Sol gets features, Terra gets implementation, and Luna is sentenced to footer padding forever. Sometimes I use Sol on something Terra probably could have handled because I know Sol will do it well and I do not feel like spending thirty seconds optimizing inference as though I personally pay OpenAI’s GPU bill. But the hierarchy is becoming useful. Astra is for the problems where I actually want the strongest available reasoning or unusual autonomy. Sol remains the serious everyday workhorse. Terra increasingly handles normal development that needs more than Luna. Luna gets the cheap, granular work and searches where speed matters more than deep judgment.
This also reinforces the point I made in my $40 AI workflow article. Getting the most from cheaper subscriptions is increasingly about routing work intelligently rather than always clicking the strongest model. The model picker is becoming less like a ranking and more like a toolbox.
Should Astra Just Delegate More Work to Luna?
Once I understood the cost difference better, an obvious question followed: if Astra is expensive and Luna is cheap, why doesn’t Astra automatically hand more mechanical work to cheaper agents? Claude’s larger coding models have often seemed more willing to delegate on their own, while I found myself explicitly telling Astra or Sol when I wanted them to use Luna agents.
OpenAI’s documentation again validates the observation more directly than I expected. Its Astra model guide says the model “may delegate less often than desired for your workflow” and recommends specifying when and how much it should use subagents. So yes, apparently we have reached the point where the frontier model is capable of managing other AI agents but may need to be reminded to do more delegating.
Reddit is currently full of people trying to engineer the perfect Astra/Sol/Terra/Luna hierarchy. One popular approach is to use Astra as an advisor or architectural brain while Sol or Luna performs the bulk of implementation. Other users have gone much further, creating persistent managers, investigator agents, implementation workers, and reviewers designed to preserve Astra’s expensive reasoning for decisions that actually need it. This makes intuitive sense, especially on Plus where using Astra continuously is not realistic for most heavy development sessions.
Unfortunately, orchestration can also become its own form of token slop. Other users testing Astra with Luna agents have found that Astra sometimes consumes more when managing workers because it has to create instructions, wait for results, read large amounts of agent output, resolve problems, and verify the work afterward. One recent test concluded that Astra Low was surprisingly efficient when working alone and lost much of that advantage once cheaper agents were inserted into the loop. The fact that Luna is cheap does not make communication between Astra and Luna free.
My current view is therefore less exciting than “build an AI company inside Codex.” Delegation makes sense when a task genuinely decomposes into separate work that a cheaper model can perform without constant supervision. For many smaller jobs, the simplest optimization is to select Terra or Luna directly. Creating a miniature management bureaucracy so Astra can supervise another model changing a CSS property may technically be agentic, but I am not convinced it is efficient.
Claude Code Still Sometimes Fits My Development Work Better
One awkward result of all this testing is that I occasionally switch from Astra or Sol into Claude Code and immediately think Claude approaches certain development work better. I had this reaction while cleaning up some of the CSS architecture and technical SEO from the static site. Opus seemed naturally inclined to inspect the existing structure, find consolidation opportunities, and organize the cleanup in a way I liked. I have noticed the same general tendency for months: Claude is particularly good at entering something complicated that already exists, taking its structure seriously, and extending or cleaning it up without trying to reinvent everything.
That does not prove Opus is smarter than Astra. The coding product around the model matters almost as much as the benchmark score once all the models are this capable. The harness determines how the agent reads a repository, verifies changes, delegates work, preserves context, uses the browser, and decides when to refactor. Default behavior matters too. I have generally let Claude Code take larger chunks of professional work while using Codex more interactively on personal projects, which inevitably shapes my impressions of both products.
I wrote about that division during Anthropic’s release week, when Claude Code was becoming my primary workplace development tool even while I continued preferring ChatGPT for personal ideation and creative work. The comparison is also messy from a usage perspective. Claude Code’s temporary 50% increase in weekly limits is scheduled to run through September 13, so the amount of Claude capacity I have recently become accustomed to is not necessarily a stable baseline either. Users on both sides are now spending an absurd amount of time optimizing around five-hour windows, weekly limits, effort settings, and which model deserves which task.
For me, that is another reason not to turn this into a tribal comparison where Astra has to defeat Claude or Claude has to defeat Astra. I pay for both because they are good at overlapping but not identical things, and my preferences change depending on the project. Sometimes Astra is clearly worth the extra capability. Sometimes Sol is more practical. Sometimes Claude Code sees the structure the way I do faster than either of them.
Astra’s Computer Use May Be the Most Important Part I Did Not Test
I did not use Astra’s computer-control abilities during these website experiments. That was deliberate rather than an oversight. My own WordPress sites use custom Underscores-based themes, and my other recent projects have been static HTML, so letting Astra visually click around software when Codex can directly edit the files would be an excellent way to burn an already-limited Astra allowance for no reason.
I am not new to letting AI interact with interfaces. I have let Sol control my computer and also work with a phone while I was building my Android app. Both Codex and Claude have used browsers during website work. I also deliberately tested Claude in Chrome editing a WordPress page builder because that was a situation where the AI genuinely had to use the visual interface instead of solving everything through the command line. It worked, but it was much slower than a human who actually knows the builder, which made the experiment interesting rather than transformative. I also do not normally use page builders on my own websites, so this is not a bottleneck I personally encounter very often.
This is why some of the Astra demonstrations and community experiments involving Blender, Unreal Engine, video tools, design software, spreadsheets, and other GUI-heavy applications interest me more than making it control my own development environment for the sake of saying I tested computer use. OpenAI reports that Astra scored 72.6% on OSWorld 2.0 and completed its simulated computer-use tasks about 47% faster than Sol. The release materials show it filling forms, working in Power BI and Excel, performing frontend QA, installing software, troubleshooting visual problems, and moving between specialized applications.
If that improvement translates into real-world speed, computer use may be one of the strongest arguments for Astra. A model that can inspect a rendered WordPress page, understand what I dislike, move through Elementor or another builder, make the appropriate changes, check responsive breakpoints, and verify the result would be much more interesting than having an even smarter model edit another static CSS file. I am especially interested in this from a professional perspective because developers and marketers do encounter platforms where the GUI is unavoidable, even if my personal preference is to stay as far away from page builders as possible.
I just have not tested Astra deeply enough in that kind of workflow to tell you it has solved the problem. The benchmark improvement and the things other users are doing with visual software are cool. For my own Astra testing so far, direct file access was the sensible interface, so that is what I used.
Is GPT-6 Astra Worth It on ChatGPT Plus?
For $20 a month, I think getting any meaningful Astra access is excellent value. Plus includes Astra inside Work and Codex, although GPT-6 Pro in ordinary Chat is reserved for eligible higher-tier plans. I am not scandalized that I can destroy my Astra allowance quickly while paying twenty bucks, especially when OpenAI is giving me Sol, Terra, Luna, ChatGPT, Work, Codex, browser access, and a pile of other capabilities inside the same subscription.
If my livelihood depended on running Astra continuously for long autonomous tasks, I would need to pay for more capacity and treat that as a business expense. What changed over the last week is that I no longer see Astra as the obvious model to select merely because it is available. Sol already clears the competence threshold for an enormous amount of what I do. Terra is proving much more useful than I initially assumed. Luna can handle a shocking amount of focused implementation when I already know what needs to happen. Astra becomes compelling when the problem is genuinely difficult, unfamiliar, deeply agentic, or calls for the computer-use abilities that distinguish it more clearly from the rest of the family.
This is also why my $40 ChatGPT Plus + Claude Pro experiment still makes sense to me after Astra rather than being invalidated by it. The highest-end model is not automatically the best value for every step. I get more out of both subscriptions by treating them as collections of different capabilities and routing work based on what I actually need. Sometimes that means Astra. Sometimes it means Claude. Quite often it means Sol or Terra, and sometimes the correct model is Luna because I would like to still have a weekly allowance tomorrow.
GPT-6 Astra Is Not AGI, and That Is Fine
I am confident we have not reached AGI, although that statement now requires the annoying caveat that different people use wildly different definitions of AGI. Astra can outperform previous frontier models on difficult benchmarks, operate software, write and debug code, reason across long tasks, find security vulnerabilities, and carry out increasingly autonomous workflows. Those capabilities are extraordinary. I still do not think they amount to the kind of robust general intelligence I would call AGI.
The weird mixture of extraordinary capability and ordinary mistakes is part of why I am comfortable saying that. Astra can score 99.9% on ARC-AGI-3, work across specialized software, and outperform Sol substantially on several agentic evaluations. It can also make a website where I eventually wonder why the hell there are so many CSS classes. That does not mean the model is secretly unimpressive. It means benchmark capability, autonomy, architectural taste, and general intelligence are not all the same thing.
Heavy use also makes these models feel less mystical because you repeatedly encounter the edges of what they do well. Someone who knows nothing about Android development can now build a useful Android app with Sol. Someone who knows websites can use Astra to produce and iterate at ridiculous speed while still finding plenty to criticize. As the models improve, less-experienced users will keep crossing competence thresholds that previously required specialized knowledge, while experts will keep finding another layer of things the models could have done better.
That is already enough of a technological shift for me without pretending Astra is AGI. I am still using it, but I have stopped treating it as an upgrade button I should press every time I open Codex. Sometimes I want Astra. I still use Sol constantly. Increasingly, Terra is enough, and Luna gets a lot of the small stuff. Apparently one consequence of increasingly capable AI is that I now spend time deciding which level of artificial intelligence deserves to edit my website. I can live with that.
