GPT-6 Astra: Theo’s Early Tests of Computer Use, 3D and Coding

GPT-6 Astra is the model I have been testing for the past few weeks. My usage shown here amounts to about $330,000 of inference, much of it on this model, during early access. I think its computer use, 3D work and ability to tackle long tasks feel like a generational leap over GPT-5.6 Sol, but it still has rough edges. My experience reflects an unusually heavy early-access workload.

Start with cost and availability as they stood at launch. OpenAI listed standard API prices of $10 per million input tokens and $50 per million output tokens. Fast mode offered up to twice the speed for twice the standard price. Total cost depends on how many tokens a task uses, not just the published rates; long autonomous runs can still be expensive.

I compare cache-read prices of $1 per million for Astra with $0.25 for Fable 5.1, while noting Astra's token efficiency can change the final comparison. The model supports a context window up to one million tokens, but the Codex default at launch was expected to be smaller. I discuss higher API rates above 272,000 tokens and say Codex would have an exception; these launch details are time-specific and should not be treated as current pricing.

The rollout is my biggest frustration: OpenAI said Astra was initially available to a limited set of organizations, with broader access to paid ChatGPT plans, the API and AWS to follow. I want viewers to try the examples immediately, but many cannot yet. The announcement also describes zero data retention for eligible API customers; eligibility and product terms matter.

OpenAI representatives said delayed Codex access would be compensated with banked usage resets, and I was told the staggered rollout was temporary. I speculate about possible reasons for the delay, but I do not know why it happened. Availability and subscription arrangements can change, so this is a snapshot of the launch rather than a lasting promise.

The launch materials show strong results on scientific and agent benchmarks. On Terminal-Bench Science, the chart compares Fable 5.1 at roughly 36% and $15 with Astra on low at roughly 54% and $11. I also discuss ARC-AGI-3, FrontierMath and Terminal-Bench 4, and notice that higher reasoning settings do not always produce the best result. These figures are benchmark-specific, not guarantees for every real task.

The ability to work for a long time and retain useful context through compaction feels like learning within a session. I do not mean the model's weights are being updated during the conversation. OpenAI also reports results from an exploit honeypot evaluation; that is one controlled safety test, not a general proof of alignment.

Computer use is the biggest practical leap for me. The OSWorld 2.0 chart reports Astra on high at 71.6% in about 23 minutes, versus Sol's best 65.7% in roughly 75 minutes. That is a comparison on a particular benchmark. In my own work, I find Astra much faster at navigating real applications, and improvements in Codex as well as the model contribute to that experience.

OpenAI demonstrates the model operating Excel through mouse and keyboard rather than merely editing a file programmatically. It may pause to plan, then move quickly. For me it retrieved medical records through a slow portal in about 15 minutes while I did something else. I am impressed by the speed, though one successful run cannot establish reliability for all sensitive workflows.

The 3D and CAD examples are striking as well. The BenchCAD chart reports a high score for Astra at a lower cost than the compared Fable result. OpenAI shows a house created in Blender and turned into a walkable Unreal Engine scene. By contrast, the slides I got in my own testing were not as polished as the company's demonstrations, possibly because my prompts or context differed.

My own Fish Slop demo generated an attractive 3D aquarium with recognizable fish, lighting and functional game loops. Its controls were much worse than Fable 5.1's: mouse movement was initially too fast, then too slow after a correction. I could steer it toward a better result, but the polished first image should not be confused with polished interaction.

Another improvement is asynchronous questioning in a compatible harness. The model can ask about a decision, continue unrelated work and incorporate an answer later. It also seems less likely than earlier models to abandon the original task when I send a steering message. That said, its understanding of my intent still has limits, and I have had failures I will discuss later.

For code, Astra feels much more mergeable than Sol in my experience. Sol often solved a problem but left an oversized PR, unnecessary tests or changes beyond the requested scope. Astra is more restrained overall, although that does not mean it never over-engineers. The displayed Deep SWE results are another useful data point, not a substitute for reviewing actual changes.

OpenAI presents strong science and cybersecurity results, including a perfect score on the particular ExploitBench setting shown. It also reports fewer misaligned outcomes on a computer-use stress test and improvements on respecting user boundaries. These are the company's reported evaluations under specified conditions; none establishes that a model is safe in all deployments.

The Artificial Analysis index placed Astra alongside models I considered much weaker in agentic work. I suspect its mixture of older knowledge and reasoning benchmarks underrepresents current computer-use and agent capabilities. The founder told me the suite was being revised. The cost-per-task comparisons can still be informative for that benchmark, but no single index captures everything I care about.

Frontend design is better than Sol but remains a weak point. My 2D Fish Slop interface contains more than 20 unnecessary labels and subtitles even after cleanup. Landing-page comparisons show better animations and starting points than earlier OpenAI models, yet I still prefer Fable 5.1 for getting a usable design with fewer prompts.

Other early testers show 3D work: a Minecraft-like game, an open-world demo, small walkable worlds and a Manhattan scene assembled over a week. These are impressive demonstrations, but they are examples with different prompts and amounts of iteration, not controlled comparisons. A browser-based macOS-like interface also illustrates breadth while still showing visual imperfections.

I built a player for music posts on an old blog that struggled with many embedded players. It was not a one-shot: I iterated until navigation and resume behavior worked the way I wanted. I also built a local-network iOS media player with Plex-like features. The initial version worked quickly, but I spent several more prompts fixing rough edges before relying on it.

For my Lakebed project, OpenAI had asked me not to use the preview model on public-facing code, so I tested it on this then-private project. I asked the agent to inspect performance, create tests and pursue improvements. In my measurements, some synchronization paths went from as much as 800 milliseconds to under 30 milliseconds, with a large reduction in p95 latency in some cases.

I allowed the agent to coordinate subagents and merge changes when it was satisfied, then tested the result myself because prior unattended merges had caused problems. Another model reviewed the changes too. Those are useful checks, not a proof that there can be no regressions or security problems. I want to explore the swarm behavior in more detail separately.

Video editing was much less successful. The model found some potentially useful moments for short clips, but I disliked the cuts and vertical layouts. I will keep relying on my editing team. I am also experimenting with a TypeScript-to-Rust port, but that work is not finished in this video.

One failure illustrates the rough edges. On an earlier Astra snapshot, I asked it to use the computer to diagnose a T3 Code scrolling bug and file a PR if confident. It opened a PR quickly, and review bots raised substantive concerns. When I asked whether comments were worth addressing, it said yes but did not act.

I explicitly asked it to fix and push changes and babysit the PR. It stopped monitoring before later comments arrived; I cannot isolate whether that was the model, the harness or rate limits. More frustratingly, when I asked about new comments, it again agreed they were valid without fixing them, despite the earlier instruction and skill context; a later fix was not pushed.

OpenAI made changes to the model and surrounding harness after that snapshot, and I found the behavior reduced, not eliminated. Astra can still over-engineer and get trapped in review loops. Some of my threads remain open longer because getting the change all the way to completion requires additional work, even when the model's underlying capabilities are impressive.

The model's significance for me is broader than a claim that it is the best coding model. I value computer use, 3D tools, coordinating agents and work across connected applications. In one example I used it with Gmail and Notion to help identify priorities while my assistant was away. That is my personal assessment of a particular workflow, not a universal result.

I see these capabilities as a taste of something new and use the term AGI-like to describe my reaction, not as a demonstrated scientific classification. I trust the model for many tasks, while acknowledging the failures I just described. The question I leave viewers with is where they set their own bar for checking work and how they evaluate whether a system has met it.