What GPT-6 Astra can actually build, from 3D cities to native Mac apps

A model that can look at your screen, take control of your mouse and keyboard, and finish a multi-hour project without you touching a single line of code sounds like science fiction. It isn't anymore. OpenAI just shipped a model that does exactly that, and the early demos floating around are the kind of thing that make you double-check the upload date isn't April 1st.

This guide breaks down what GPT-6 Astra actually is, what real people have already built with it, and how you can start using it today without getting lost in benchmark jargon.

What is GPT-6 Astra, and why is everyone talking about it?

GPT-6 Astra is described by OpenAI as the most intelligent and aligned model in the world, setting a new state of the art for computer use, browsing, software engineering, cybersecurity, science, and professional work. The pitch is simple: anything you can do on a computer, Astra can do for you.

That's not marketing fluff about "better answers." OpenAI positions it as their most capable model, built for the hardest end-to-end work, meant for complex reasoning, coding, computer use, research, and document creation. The rollout itself has been fast. GPT-6 Astra started rolling out to a limited set of organizations before becoming available to all ChatGPT Plus, Pro, Business, and Enterprise users, as well as through the OpenAI API, Microsoft Azure, and AWS Bedrock.

You can read the official announcement on OpenAI's GPT-6 Astra page, and developers can dig into the technical specs on the GPT-6 Astra model documentation.

How does GPT-6 Astra compare to what came before it?

The jump over the previous flagship, GPT-5.6 Sol, isn't subtle. Astra scores 72.6% on the OSWorld 2.0 computer-use benchmark while taking roughly 47% less time per task than Sol, and it saturates FrontierMath Tier 4 with a 97.6% score and ExploitBench with a 100% score. On the notoriously difficult ARC-AGI-3 reasoning benchmark, Astra surpassed the human action-efficiency baseline on 96% of levels, effectively reaching human parity, which OpenAI called the best model they've ever tested and a meaningful step change in frontier performance.

Speed matters just as much as accuracy here. With Astra, ChatGPT is nearly twice as fast at computer use than before. That's the difference between watching a progress bar for an hour versus getting a finished result while you grab coffee.

Pricing sits at a premium tier. GPT-6 Astra is priced at $10 per million input tokens and $50 per million output tokens, positioning it as OpenAI's new frontier flagship succeeding GPT-5.6 Sol. If you're on a Pro, Business, or Enterprise plan, a GPT-6 Astra Pro tier is also available, alongside API access and Amazon Bedrock support.

Can GPT-6 Astra really rebuild a real-world landmark in 3D?

Yes, and the results hold up to scrutiny rather than falling apart the moment you look closely. This is where the "computer use" upgrade actually shows up in practice: instead of describing what a 3D scene should look like, Astra can open a 3D engine, place geometry, texture it, and iterate until the lighting and proportions look right, without a human nudging every step.

This kind of task leans directly on the model's improved agentic execution. The changes in Astra cluster around agentic execution, using a computer, producing finished professional artifacts, maintaining context across long coding sessions, and staying within authorized boundaries. A landmark rebuild is a perfect stress test for that combination, since it requires dozens of small decisions made consistently over a long session rather than one clever one-shot answer.

What happens when you hand it a full 3D city simulator?

Procedural generation, where the computer lays out a scene algorithmically instead of a human placing every asset by hand, is one of the harder agentic tasks you can throw at a model. It requires holding a huge amount of internal logic in memory across a long build session, something earlier models tended to lose track of halfway through.

This is exactly the kind of "long-horizon agentic task" Astra was built for. The model is suited for advanced analysis, software engineering, deep research, scientific work, and document creation, with particular strengths in long-horizon agentic tasks that involve computer and browser use. A working city simulator with weather and tide variation is a showcase for that strength specifically, because it's not one output, it's a system that has to keep working after the model stops touching it.

How fast can it finish something like Pokémon?

Speedrunning a full game isn't really about "intelligence" in the traditional sense, it's about planning under constraints, adapting when something unexpected happens, and not wasting moves. That's a near-perfect match for the reasoning gains OpenAI is highlighting.

On a difficult-task evaluation, Astra solved 88.0% of tasks in a single attempt and 99.2% within four attempts, compared with 55.9% and 68.7% for GPT-5.6 Sol respectively. That kind of first-try reliability is what lets a model blast through a long game faster than a model that has to backtrack constantly.

Can it build a native Mac app from scratch?

This is arguably the most practical example for anyone who codes for a living. Astra doesn't just generate a code snippet and hand it back to you, it can build, test, and QA an entire application inside a real development environment.

OpenAI describes GPT-6 Astra as the best model for software engineering to date. That claim is backed by more than a slogan: OpenAI notes that Astra pairs advances in computer use with targeted training for professional environments, combining the intelligence required for complex problems with the ability to carry out multistep workflows and produce polished documents, spreadsheets, and presentations. An hour-long QA pass that checks every button in a finished app isn't a party trick, it's the model doing the tedious part of software development that usually eats a developer's afternoon.

If you want to try this workflow yourself, Codex is the fastest on-ramp. Astra ships alongside an updated Codex harness that OpenAI says delivers 1.9x faster task completion versus the previous GPT-5.6 Sol experience on the Mind2Web benchmark.

What about creative projects, like an entire art-style world or a short film?

Turning a painter's style into an explorable environment, or producing a five-minute science film with narration, visuals, and pacing that actually holds together, requires a model to juggle creative judgment and technical execution at the same time. That combination is where a lot of models still fall apart, either the visuals look good but the logic breaks, or the structure works but everything looks generic.

This is also where instruction-following quality matters more than raw horsepower. A model that ignores half your prompt or drifts from your style guide three steps in isn't usable for a real creative pipeline, no matter how good its benchmark scores look on paper.

How do you actually start using GPT-6 Astra today?

Getting hands-on is straightforward if you already use ChatGPT or the OpenAI API:

1. Check your ChatGPT plan. Astra is rolling out to all ChatGPT Plus, Pro, Business, and Enterprise users, so if you're subscribed, look for it in the model picker.
2. For developers, call it directly through the API. It's available through the OpenAI API, Microsoft Azure, and AWS Bedrock using the model slug gpt-6-astra, per the model documentation.
3. Set your reasoning effort based on the task. The reasoning.effort parameter supports low, medium, high, xhigh, and max, so simple tasks don't need to burn tokens on deep reasoning, while a full app build should get the higher settings.
4. Use Codex for coding-heavy work. The updated Codex harness is purpose-built for agentic software tasks and pairs naturally with Astra's computer-use skills.
5. Compare pricing tiers before committing to production use. With output tokens priced well above input tokens, long generative tasks like film scripts or full codebases can get expensive fast, so it's worth checking OpenRouter's GPT-6 Astra pricing page if you're routing through multiple providers.

What are the real limits you should know about?

None of this comes without trade-offs, and the safety documentation is refreshingly blunt about it. GPT-6 Astra is described as a significant step up in cyber capabilities, meeting OpenAI's Critical threshold, meaning that with the right tools and access, it can find previously unknown security flaws largely on its own. That's a big part of why access is gated and monitored more heavily than previous releases.

On the reliability side, the news is better. Astra is significantly more robust to prompt injections than GPT-5.6 Sol, which matters a lot if you're letting it browse the web or operate a live app unsupervised. Still, "significantly more robust" isn't "immune," so anyone running Astra on sensitive systems should treat it the way you'd treat a very capable junior employee: give it clear boundaries and check its work on anything high-stakes.

If you want the full technical rundown, the GPT-6 Astra safety overview is worth reading before you plug it into anything production-critical.

The gap between "AI that writes text" and "AI that finishes projects while you're not watching" just closed faster than most people expected. The real question isn't whether a model like this can build a city simulator or ship a native app anymore. It's whether you've figured out which of your own backlogged projects you can finally hand off.