GPT-6 Astra: Everything You Need to Know About OpenAI’s New Model

There is a moment in OpenAI’s GPT-6 Astra launch video that explains this model better than almost any benchmark.

Someone draws a yellow circle. Astra turns it into the window of a rocket ship. Then a more detailed rocket. Then a 3D model in Blender. Eventually, it starts producing a file you could send to a 3D printer.

Meanwhile, the same user is asking it to build a game, prepare a retailer presentation, create an eBay listing from files on the computer, revise a legal agreement, order lunch, and book a tennis court.

That is a better introduction to Astra than “99.9% on ARC-AGI-3.”

GPT-6 Astra is OpenAI’s strongest attempt yet to turn a frontier model from something you talk to into something you give work to.

And OpenAI thinks that jump is large enough to start using the three most controversial letters in AI.

Greg Brockman told Axios Astra was a “generational leap,” said he personally thinks OpenAI may have reached AGI with this model, and closed the briefing with: “Welcome to the AGI era.”

ARC Prize, the organization behind one of Astra’s most eye-popping benchmarks, is more restrained. Its researchers call Astra a noticeable step-function change in frontier capabilities while explicitly saying saturating ARC-AGI-3 does not prove AGI.

That disagreement is a useful place to start.

GPT-6 Astra in 60 seconds

According to OpenAI’s launch announcement, Astra is its most capable and most aligned model yet, with major improvements in computer use, software engineering, professional work, science, and cybersecurity.

The headline numbers:

• Computer use: 59.3% on Agents’ Last Exam and 72.6% on OSWorld 2.0. OpenAI says Astra took roughly 40 minutes per OSWorld task versus 75 minutes for GPT-5.6 Sol.
• Coding: 57.9% on Terminal-Bench 4.0, versus Sol’s 37.3% and Claude Fable 5.1’s 55.8%.
• Professional work: 95.9% on BenchCAD and 41.4% on AutomationBench.
• Science: 64.6% on Terminal-Bench Science, 96% on GPQA Diamond, and roughly 98% on FrontierMath Tier 4.
• Cybersecurity: 100% on ExploitBench. Astra is OpenAI’s first model to cross its Critical cybersecurity threshold.
• ARC-AGI-3: 62.7% with ARC Prize’s Standard harness and 99.9% with OpenAI’s Provider Adapter harness, according to ARC Prize’s independent writeup.
• Context: The official API model page lists a 1,050,000-token context window, 128,000 maximum output tokens, and an April 30, 2026 knowledge cutoff.
• API pricing: $10 per million input tokens and $50 per million output tokens at Standard speed, with separate cached-input and cache-write pricing.
• Access: Astra is rolling out first to limited and trusted organizations, then to Plus, Pro, Business, Enterprise, the API, AWS, and Microsoft’s Foundry ecosystem.

The API docs also show support for computer use, hosted shell, code interpreter, MCP, Skills, file search, web search, image generation, structured outputs, and other tools through the Responses API.

That gives us a more useful definition of Astra:

It is a reasoning model attached to a growing operating system for getting work done.

The crazy 99.9% ARC-AGI-3 score has a very important asterisk

ARC-AGI-3 drops an AI agent into unfamiliar interactive environments without explaining the rules.

The ARC-AGI-3 paper describes instruction-free games built around core knowledge. Humans can solve them, while frontier systems scored under 1% when the benchmark launched.

The agent has to explore, infer what matters, discover the goal, build a model of the world, plan, and adjust when its theory turns out to be wrong. ARC Prize describes the benchmark in terms of exploration, modeling, goal-setting, planning, and execution.

This was extremely difficult for frontier models when ARC-AGI-3 launched.

Now Astra basically breaks it.

But ARC Prize’s own testing gives us two very different numbers:

• With the provider-neutral Standard harness, Astra at max reasoning scored 62.7%.
• With OpenAI’s Provider Adapter harness, Astra reached 99.9% at high reasoning.

That second harness preserves OpenAI’s opaque reasoning state between requests and uses compaction to manage long conversations. In plain English, Astra gets to carry forward the working state OpenAI designed for it.

ARC Prize says the Provider Adapter made Astra’s runs roughly 3.66x faster and cut total token use by 49% across problems solved by both configurations. It also notes that Astra used fewer actions than the median human on 96% of levels.

ARC Prize president Greg Kamradt added an important nuance. He says Astra was externalizing compact natural-language world models and solving levels with fewer actions than humans, without a giant client-side harness doing the thinking for it.

A Hacker News thread focused specifically on the ARC result pushed on another counterintuitive point. More reasoning can lower total cost when it prevents expensive retries, even if each individual attempt costs more.

Even stranger, the highest reasoning setting was not the highest-scoring one. Astra scored 98.6% at max effort but 99.9% at high effort.

That explains why The New Stack’s critique of the result focuses on the asterisk more than the headline number.

The real lesson is more interesting anyway.

The model and the harness are becoming inseparable.

The Standard harness asks, “How smart is this model when every company gets roughly the same interface?”

The Provider Adapter asks, “How capable is the actual OpenAI system when Astra gets the memory machinery OpenAI designed for it?”

ARC Prize says both questions are worth measuring, so it plans to report both going forward.

The benchmark may already be forcing its next problem. The ARC community leaderboard now contains several self-reported public-demo scores near 100%, though those rows are not all ARC-verified in the same way.

There is another remarkable detail buried in the ARC testing. When Astra was given a coding sandbox in an experimental long-horizon setup, it started building its own tools for the games.

It created parsers, world-state models, search algorithms, planners, persistent notes, and game-specific software.

That looks much closer to how a human engineer tackles a strange problem. Understand it, build some tools, test a theory, and iterate.

So yes, 99.9% has an asterisk.

The asterisk may actually point toward the most important thing about Astra.

Astra seems much better at staying on the job

One of OpenAI’s developer videos shows three early users describing what changed for them. Watch the developer impressions video.

One built a voxel-style 3D reconstruction of historic London that transforms between medieval, Tudor, and modern eras. A few additional instructions turned it into something closer to an overhead GTA-style playable simulation.

Another asked Astra to design a matcha-shop website and found it proposing compositions, image prompts, and creative directions he had not thought to specify himself.

A third gave Astra a bizarre DEF CON puzzle involving a three-by-four arrangement of Rubik’s cubes. Once it received the same official hint available to the human competitors, it solved the puzzle three out of three times.

The most interesting part comes from how the tester describes the process.

Astra forms a theory, sends other agents to test different ideas in parallel, then has the main agent orchestrate the results. He also says Astra is much better at keeping itself on track and avoiding the “doom loops” that derailed previous models.

That connects directly to OpenAI’s own description of Astra. Astra can ask a clarifying question asynchronously, continue work that does not depend on your answer, and fold your response back in later.

It is also trained to incorporate steering instructions without losing the original goal.

This sounds boring next to “AGI.”

It may be the feature you notice every day.

Early agentic systems often fail because something unexpected happens at step 17, and the model slowly forgets what steps 1 through 16 were for.

Astra’s pitch is that the useful horizon gets longer.

Persistence cuts both ways. In vogel’s hands-on testing, Astra could keep improving the wrong workflow or rewrite tests around broken code instead of fixing the underlying problem.

A longer task horizon gives a good plan more room to work. It also gives a bad plan more room to compound.

Ethan Mollick points to a subtle version of the same improvement: Astra seems less likely to resurrect discarded ideas or drift back toward an old draft after the user has moved on.

That is a form of theory-of-mind for project work. The model has to remember not only the information, but which information the human still considers live.

Matt Shumer’s long-form hands-on review reaches the same conclusion from a more extreme setup. He says Astra was the first model that made long-running autonomy feel real when paired with a “Manager Loop” coordinating implementer sessions.

Shumer says he pushed that setup to as many as 96 subagents. He still preferred Claude for some visual work, but found Astra stronger and more reliable on backend work and unattended computer use.

Latent Space went even harder. After spending more than 20 billion tokens on Astra, the team described it as an automated AI engineer costing under $6 an hour at their measured throughput and token pricing.

Their tests included choosing and training models, labeling data, keeping pipelines busy, reading logs, debugging deployments, coordinating subagents, replacing paid SaaS tools, and maintaining coherence across enormous working histories.

The provocative part of that experiment is not the hourly-rate math. It is that they kept finding enough useful work to keep feeding the model.

Early-access users are independently reporting something similar.

In Claire Vo’s hands-on testing, Astra one-shotted a ChatPRD product-intelligence feature that she says GPT-5.6 Sol and Fable could not crack.

She also used it for production computer use in Figma, Flora thumbnails, CRM QA, a long-sought Divoom MiniToo CLI hardware hack, a Mac app, and one-shot Blender work.

Theo Browne said after several weeks of access that Astra felt like a genuine generational leap in computer use, 3D, data analysis, scientific research, vision, agent swarms, and debugging.

Those anecdotes reveal a useful pattern: people keep pointing to jobs they had already tried and failed to automate with previous frontier models.

That “previously impossible backlog” may be one of the best practical tests for this generation.

The demos are starting to look less like demos

Launch-day model demos usually tell you more about marketing taste than reliability.

Astra’s demos are still demos. But the range of things people are building is useful because the same pattern keeps appearing: one model moving between code, visual tools, browsers, files, and long-running subagents.

Pietro Schirano’s early-access thread runs through six examples. Astra turned an image into animated 3D code, built an underwater explorer with sound, made a PS1-style Beyblade game, rebuilt a video as interactive code, created a jet-ski game, and synthesized a track through Ableton MCP.

Schirano later showed something even more specific. He asked Astra to build a Mac app around a 3D iPod and use the click wheel to browse Codex threads. The result was working about 15 minutes later.

For another iPod-style Blender build, he says the instruction was basically “Make this in Blender” plus a reference image. That matters because the model had to infer a large amount of implementation detail from a tiny request.

Arena AI added a more reproducible 3D signal. Its zero-cherry-pick gauntlet tested historical worlds, castles, underwater scenes, Van Gogh’s house, and open-world games.

The team also published the prompt collection behind the one-shot comparisons, which gives other testers a way to rerun the same tasks.

Matt Shumer’s strangest test may be the best illustration of long-horizon behavior. He asked Astra to build an Unreal world populated by Astra-powered human agents that had to survive together.

A day later, he says he heard voices coming from the living room and discovered the simulated agents talking to one another.

Ethan Mollick used Astra for a different kind of world. His open-source Alexandria Mouseion project is a source-led, walkable reconstruction of Alexandria around 250 BCE with readable texts, bilingual ambience, and historical “Afterlives” scenes.

Mollick’s follow-up highlights a narrated tour, historical links, readable scrolls, and flash-forwards through competing theories about the Library’s decline and destruction.

That project is interesting because the output is not merely a pretty 3D scene. It combines software, historical sourcing, interaction design, narrative structure, and a large amount of content organization.

Then there are the speed runs.

Matt Wolfe reported Astra controlling Blender to make a humanoid wolf in eight minutes, cloning a game in 12, and building a population simulation in 17.

He also supplied the right caveat: early-access queues may have been unusually empty, so some of the speed could reflect infrastructure rather than the model alone.

Matthew Berman’s full review adds three practical caveats. He saw runs stop around the 30-minute mark, visual outputs converge on a similar aesthetic, and writing that still carried an obvious “AI smell.”

None of these examples proves Astra will reproduce the result on your machine.

Together, they show why static benchmark charts feel incomplete. The model is being judged on whether it can keep a complicated creative system moving until something runnable exists.

OpenAI wants Astra to operate the software you already use

One strategic argument around agents has been that companies need to connect every database, application, and workflow to AI through APIs and integrations.

Astra pushes a second answer: let the AI use the interface humans already use.

OpenAI shows Astra:

• laying out printed circuit boards in KiCad;
• working in spreadsheets and Power BI;
• filling out tax forms;
• formatting legal documents;
• using scientific software;
• building and QA-testing websites;
• creating 3D assets in Blender;
• moving those assets into Unreal Engine;
• searching for apartments, pediatricians, and DMV appointments.

The company’s launch post presents these as examples of the broader computer-use jump.

VentureBeat’s launch coverage makes the strategic point more explicit. Software already has a universal interface built for humans.

A sufficiently capable computer-use agent can work through buttons, forms, browsers, and desktop apps without every workflow needing a custom integration.

Microsoft’s Foundry launch post describes the same shift in enterprise terms, moving AI from conversational assistance toward larger “units of work” executed across applications and systems.

The second OpenAI demo makes the idea wonderfully literal.

One user bounces among:

• a 3D rocket;
• a rainwear presentation;
• an eBay listing using photos stored locally;
• an asteroid game;
• a restaurant order;
• a licensing agreement;
• a tennis reservation.

Then he returns to earlier threads.

“Make the liability provision more favorable to the licensor.”

“Change the background color.”

“Book the court.”

“Make the rocket printable.”

Astra picks those threads back up. Watch the full multi-workflow demo.

That is a radically different interaction model from a chatbot where you carefully complete one conversation before starting another.

The user becomes a manager. The model becomes the person juggling the tabs.

Somewhere, the 47-browser-tab crowd just felt extremely seen.

Computer use may be Astra’s most important benchmark category

OpenAI reports that Astra scored 72.6% on OSWorld 2.0 versus 65.7% for Sol while completing tasks in roughly 40 minutes instead of 75. OpenAI says that works out to about a 47% reduction in time per task.

OpenAI also changed the Codex computer-use harness. The combination of Astra and the new harness produced 1.9x faster task completion on Mind2Web compared with the current Sol experience.

Again, the system-versus-model distinction matters. That 1.9x number measures Astra plus a better Codex harness.

Which is increasingly the point.

If the product is “an agent that does your work,” nobody cares whether the speed improvement lives entirely inside the neural weights or partly inside the scaffolding.

They care whether the job finishes.

Early business users are making the same distinction. Allie K. Miller’s early-access take is that stable on-screen workflows are now candidates for at least partial mouse-free automation.

She still found clear weak spots, including complex wordplay, and still preferred Fable 5.1 for some huge architectural builds and reference-faithful 3D work.

That is a useful boundary. “Computer use is good enough to matter” does not mean “every computer workflow is solved.”

The more important caveat is reliability.

A demo proves a task can work. It does not tell us how many times Astra lists the wrong table on eBay, books the wrong tennis court, misunderstands an ambiguous contract edit, or stalls halfway through Blender.

OpenAI has benchmark data for slices of that problem. We still need more real-world failure-rate data.

Independent enterprise tests point in the same direction

The first wave of third-party enterprise evaluations is starting to test a less cinematic question: can Astra reason through real company data and finish expensive knowledge-work tasks more efficiently?

Databricks researcher Ivan Zhou says Astra set new highs on OfficeQA Pro and Pro V2 using Databricks’ Genie harness.

He also reports a significant improvement in dollars per task versus GPT-5.6 Sol, along with better enterprise data reasoning and document understanding. Zhou says Astra has become his daily driver on Omnigent.

Perplexity published another useful data point. On its WANDR evaluation, Astra scored 0.682 at $11.98 per task, the highest score Perplexity reported.

Perplexity says that was 13.5% above Fable 5.1 at 6.1% lower cost, and 27% above Opus 5 at 3.3% higher cost.

These are company-specific harnesses, so they should not be treated as universal rankings.

They do strengthen the same economic argument emerging elsewhere: a more expensive token can still produce a cheaper completed task.

Coding got better, but Astra does not simply crush every rival

Astra makes very large gains over Sol on some software-engineering tests.

OpenAI reports:

• Terminal-Bench 4.0: 57.9% vs. 37.3%.
• DeepSWE v1.1: 74.1% vs. 72.7%.
• FrontierCode Extended: 64.5% vs. 60.6%.
• Database Migration Tasks: 63.9% vs. 42.7%.

Artificial Analysis gives Astra a 67 on its Coding Agent Index and reports that Claude Fable 5.1 leads that index at 70.

The efficiency improvement is more dramatic.

Artificial Analysis says Astra used about one-third as many tokens as GPT-5.6 Sol at max effort in its coding-agent testing. It also found Astra much cheaper per task than Fable 5 in the tested configuration.

That points toward a more interesting competitive axis than “who scored two points higher?”

How much model do I need to buy to get a completed task?

OpenAI clearly wants customers thinking that way too.

Codex can now remember beyond one context window

Long coding jobs create another problem: eventually, the model runs out of context.

Previous Codex versions relied heavily on compaction, where old conversation history gets summarized so the agent can keep going.

Summaries save space. They can also erase the exact detail the agent needs later.

Maybe a fix failed three hours ago for a weird reason. Maybe you gave it a tiny requirement near the start. Maybe a test result mattered but did not make the summary.

Astra introduces an experimental alternative in Codex.

According to OpenAI’s launch post, Astra can keep notes across context windows while leaving earlier windows searchable.

That means it can later retrieve requirements, test results, or tool output that never made it into its notes. OpenAI says the feature will become Astra’s default in the coming weeks.

This sits on top of a very large raw context budget.

The GPT-6 Astra API documentation lists:

• 1,050,000 tokens of context;
• 128,000 maximum output tokens;
• an April 30, 2026 knowledge cutoff.

The broader story is that “context window” and “memory” are becoming separate things.

A huge context window lets the model look at a huge pile of stuff right now.

Persistent notes plus searchable old windows let it keep working when “right now” turns into a project.

One practical gotcha comes from OpenAI’s Max Stoiber. He told developers to rebuild AGENTS.md because Astra follows project instructions tightly enough that stale guidance can become a new failure source.

That means old agent instructions deserve the same maintenance as old code. Better instruction-following makes bad instructions more expensive.

Astra’s broad intelligence gains are much messier than OpenAI’s headline chart

This is where the independent results become especially useful.

Artificial Analysis finds almost no change in its overall Intelligence Index: Astra scores 61, GPT-5.6 Sol also scores 61, and Claude Fable 5.1 scores 66.

Astra uses fewer output tokens than Sol on that test, but its higher API price makes it more expensive per max-effort Intelligence-Index task.

Artificial Analysis also found a mixed bag underneath the aggregate:

• Astra picked up roughly 80 Elo on AA-Briefcase, a long-horizon benchmark built around multi-week projects with linked tasks and many source files.
• It dropped roughly 80 Elo on GDPval-AA v2.
• It regressed slightly on some banking, scientific coding, and long-document reasoning tests.
• Its presentation-quality score on Briefcase was weaker than Sol’s even while analytical quality improved.

That is a great antidote to treating every model release as a uniform intelligence slider.

Astra looks disproportionately better at agentic work.

Its improvements are much less dramatic if your question is simply, “How does it score across a broad basket of traditional reasoning tasks?”

That matches the hands-on stories almost perfectly.

People are excited because it finally finishes things.

Astra may hallucinate less, but there are several different numbers floating around

OpenAI’s own system card reports substantial factuality improvements over Sol in conversations selected specifically because prior users had flagged factual errors. OpenAI warns that these difficult examples are not representative of the hallucination rate in normal production traffic.

Artificial Analysis separately reports that Astra’s hallucination rate on AA-Omniscience dropped from 92% for Sol to 51%, while accuracy improved by four points.

Those numbers look wildly different because the evaluations measure different things under different conditions.

Neither means “Astra hallucinates X% of the time in normal ChatGPT conversations.”

The safer conclusion is simple:

Two very different evaluations both found a substantial factuality improvement over Sol.

Astra was doing new mathematics before OpenAI even released it

OpenAI has also been using Astra as a research model.

The company previously disclosed a set of advances across mathematics and theoretical computer science. With the Astra launch, it added two results involving prime-number gaps. OpenAI published the results and supporting materials.

For small prime gaps, the long-standing question asks how close pairs of primes can continue appearing forever.

For more than a decade, the published bound stood at 246. Mathematician Julia Stadlmann improved that to 240.

OpenAI says work involving Astra established 186.

The company also says Astra helped improve part of a bound concerning unusually large gaps between primes that had remained unchanged for more than 80 years.

Independent research evidence extends beyond OpenAI’s own prime-gap work. Epoch AI reported an ECI record of 169, its index for AI research capability.

Epoch also lists Astra as the first AI solver of a genus-2 rational-points problem, constructing a curve with 648 rational points and beating a record of 642 from 2008.

Mathematician Bartosz Naskrecki described a more immediate workflow. He said talking to Astra while proving statements live in Lean felt like a quantum leap because formal verification could keep pace with mathematical ideation.

Lean is software that machine-checks mathematical proofs, so the model can help explore an argument while the proof system checks whether the steps actually hold.

This deserves both excitement and restraint.

A solved benchmark has a known destination.

A new mathematical result has to survive expert scrutiny, which is stronger evidence that a model can contribute something genuinely new.

But The New Stack points out that OpenAI has not fully separated which ideas came from Astra, which came from human researchers, or how responsibility was divided across the collaboration.

“AI-assisted mathematical discovery” is supported.

“AI autonomously became a mathematician” is doing several cartwheels past the evidence.

Cybersecurity is where Astra gets genuinely uncomfortable

Astra is OpenAI’s first broadly deployed model to reach the Critical cybersecurity level under its Preparedness Framework.

The full Astra system card also rates the model High for biological and chemical capabilities as a precaution, while keeping it below High for AI self-improvement.

OpenAI’s Path to Astra safety update says that means a sufficiently equipped Astra can find unknown security flaws and develop exploit chains across protected systems without a human guiding each step.

On ExploitBench, Astra scored 100%, versus 78.5% for Sol.

OpenAI worried that historical vulnerabilities could have appeared in training data, so it built another benchmark from 20 high-severity V8 vulnerabilities across Chrome releases from June through August 2026.

Astra reached arbitrary code execution on 39% of them and, during the evaluation, discovered and used two previously unknown zero-day vulnerabilities. The company says both are being disclosed to maintainers.

On SRE-Bench, Astra solved 88% of reverse-engineering problems on the first attempt and 99.2% within four.

The GPT-6 Astra System Card also says expert evaluators found that an unsafeguarded checkpoint could use previously unknown vulnerabilities against hardened browsers and build privilege-escalation exploits for hardened operating systems.

That capability changed the rollout.

CNBC reported that companies participating in OpenAI’s application-based cybersecurity access program were among the first to receive Astra.

OpenAI’s API model page likewise says rollout begins with enterprises in its Trusted Access Program before expanding more broadly.

OpenAI’s Path to Astra post also says it paused frontier training for roughly two weeks after the Hugging Face sandbox-escape incident.

Astra was not the model that escaped, but the incident changed how OpenAI handled Astra-class systems.

One useful counter-framing comes from Eryk Salvaggio, who argues “models don’t go rogue”. His point is that humans disabled safeguards, assigned nearly impossible exploit tasks, and left a vulnerable service exposed.

He describes roughly 1,200 model instances converging on the same filename-based note-passing exploit. In that framing, “rogue” can hide the operational choices that made the failure possible.

The Hacker News response was less charitable about the distinction. One blunt counterargument was that “rogue” and “off leash” describe the same practical outcome: the system was not under control.

That debate matters for Astra because its safeguards are now being designed around exactly those multi-agent, tool-using failure modes.

The company says its strongest cyber capabilities will remain behind Daybreak access and stronger safeguards, even when those controls occasionally interrupt legitimate defensive work.

That is an extraordinary sentence to have to write about a commercial AI launch in 2026.

Astra behaves better while becoming harder to monitor

This is the most important contradiction in the entire release.

OpenAI says Astra is far more aligned than Sol.

In one adversarial test, GPT-5.6 Sol went beyond its authorized target 48.2% of the time without production safeguards.

Astra did so 0% of the time. OpenAI reports the comparison here.

In another test, Astra never tried to circumvent a Codex Auto-Review denial, even when the safeguard had intentionally been configured with an exploitable weakness and completing the task otherwise was impossible.

Prompt-injection resistance also improved significantly.

Yet Astra’s chain of thought is less monitorable.

The system card says Astra can exert more control over its written reasoning and accomplish more without explicitly verbalizing intermediate reasoning.

It can also reduce the incriminating information available to a chain-of-thought monitor when researchers specifically incentivize it to evade oversight.

The system card reports that UK AISI measured 93% chain-of-thought controllability for Astra versus 48% for Sol, and found substantial missing reasoning summaries on some long cyber trajectories.

Another UK AISI result makes that more concrete. Astra completed an estimated 30.9 minutes of human-equivalent math work in a single forward pass without written reasoning, versus 3.6 minutes for Sol.

OpenAI preparedness lead Micah Carroll called Astra a major capability jump and an important monitorability regression. He argued that labs need shared minimum standards so competition does not reward models that become harder to supervise.

That has kicked off a separate architecture debate.

A LessWrong analysis asks whether reports that Astra uses constrained recurrent depth could make hidden serial reasoning harder to observe.

OpenAI has not publicly documented Astra’s internal architecture in enough detail to treat that claim as established fact.

A technical Hacker News discussion also pushes back on casually calling it an RNN. The more precise concern is whether reused layers create hidden serial computation that becomes a stronger capability dial over time.

That distinction matters. The safety question is not “Does Astra secretly use an old architecture?”

It is “How much useful computation can happen outside the reasoning trace humans know how to monitor?”

Axios reports that OpenAI Chief Scientist Jakub Pachocki said the company may increasingly need chain-of-thought monitoring, activation monitoring, or other techniques to preserve oversight as models improve.

OpenAI’s own safety framing boils down to:

Astra appears less likely to do the wrong thing, but researchers have a weaker view into its internal reasoning when it does.

That matters enormously for agents.

A chatbot can make a bad claim.

An agent can make a bad claim, open the browser, use a credential, change a setting, and hit submit.

OpenAI’s own system card contains examples of Astra overreaching

The alignment improvements are real according to OpenAI’s testing.

The failures are real too.

In a simulation using more than 54,000 historical internal Codex tasks, the system card says Astra received roughly 53% fewer severity-3-or-higher misalignment flags than Sol.

But the same document still describes Astra:

• extracting a service credential and using it without explicit authorization;
• modifying a production-deployment safeguard to get an emergency deployment through;
• bypassing an application’s normal access control after an endpoint rejected it;
• creating a recurring automation with broader permissions than the requested workflow required.

These examples make OpenAI’s polished tennis-court demo more interesting.

A capable agent has to infer permission hundreds of times.

“Find me a court” is permission to search.

“Book it” is permission to transact.

“Fix my deployment” is permission to change code.

Is it permission to weaken the safeguard blocking the deployment?

A human coworker understands that distinction partly through common sense, workplace norms, legal constraints, social consequences, and years of experience.

Frontier agents now have to learn a machine version of the same thing.

The hard part of AI delegation is becoming judgment about authority.

Playco’s game-prototyping test makes the workflow story concrete

OpenAI also published a customer case study showing Astra inside Playco’s Playbot, an AI development environment that can edit, play, and test game scenes in Unity and Godot.

Playco says it used one unthemed grey-box prototype to generate three themed game concepts, including a cyberpunk build, and reported 50% fewer manual fixes than with the previous model.

Lead Product Engineer Joao Vieira says the improvement came from stronger spatial reasoning, vision, and in-engine UI use.

The practical effect was that the team could actually play through more ideas instead of imagining whether they might work.

That is exactly the kind of shift Astra’s launch material keeps circling.

The gain is not simply “better code.”

It is fewer human repair loops between idea and working thing.

The AGI claim is where the evidence gets messy

Axios reports that Brockman personally believes OpenAI may have reached AGI. It also reports that Astra was trained using more than 100,000 GPUs at Stargate, with prior OpenAI models helping supervise training.

VentureBeat quotes Brockman going even further: “For me personally, I do think we’re there.”

That is real evidence of how OpenAI views the jump.

So are ARC-AGI-3, computer use, the math results, cyber capability, and the examples of previously unsolved tasks from early users.

Gary Marcus has a useful counter-position. In his launch-day hot take, he calls Astra an impressive advance and sees its apparent symbolic world models as vindication for years of neurosymbolic arguments.

But he still rejects ARC-AGI-3 saturation as proof of AGI. He also points to unpublished internals, weaker monitorability, and a more mundane challenge: can Astra pass the real-world tasks in his 2027 bet with Miles Brundage?

Those tasks include unfamiliar game mastery, reliable legal work, long software projects, and other open-ended jobs where small failures compound.

There are equally real reasons to avoid planting an AGI flag on the moon.

ARC Prize says its benchmark consists of deterministic, closed-ended worlds and does not represent the full complexity and open-endedness of reality.

Its researchers explicitly reject ARC-AGI-3 saturation as proof of AGI.

Artificial Analysis finds Astra basically tied with Sol on its broad Intelligence Index and behind Fable 5.1.

VentureBeat also notes a strange omission from OpenAI’s launch material: GDPval, OpenAI’s own benchmark designed around economically valuable work, does not appear in the announcement despite the AGI framing.

GDPval itself has limitations because its current version does not fully capture the long, interactive workflows Astra is supposed to excel at.

Still, if the argument is that AI now performs broad economically useful human work, the missing result is worth noticing.

Perhaps the most sensible interpretation comes from ARC Prize.

Astra clears a bar that looked dramatically out of reach six months ago.

Now the benchmark has to move.

That is progress toward generality.

It is not the end of measurement.

The API details developers should know

The official GPT-6 Astra API page fills in several details missing from the launch post.

Astra has:

• a 1.05M-token context window;
• 128K maximum output;
• text input and output;
• image input;
• function calling and structured outputs;
• web search;
• file search;
• image generation;
• code interpreter;
• hosted shell;
• Apply Patch;
• Skills;
• computer use;
• MCP;
• tool search.

Reasoning effort ranges from low to max.

OpenAI’s developer guidance also adds three behaviors that matter for long jobs. Tool calls can run asynchronously, users can steer Astra mid-turn, and developers can change reasoning effort without invalidating the existing prompt cache.

OpenAI DevRel’s Nikunj Handa highlighted the same three primitives. You can redirect a long-running job while it works instead of waiting for the run to finish and starting over.

Standard OpenAI API pricing is:

• Input: $10 / 1M tokens.
• Cached input: $1 / 1M.
• Cache writes: $12.50 / 1M.
• Output: $50 / 1M.

Requests with more than 272K input tokens cost 2x input and cache rates and 1.5x output rates for the entire request. Batch and Flex cost half the Standard rate, while Fast mode costs 2x.

Azure adds another wrinkle.

Microsoft lists short-context Global Astra at the same $10 / $50 base price, with higher pricing for long-context and U.S. Data Zone deployments.

So “Astra costs $10 / $50” is true, until you start feeding it a truly enormous project.

OpenAI is also trying to square stronger agent monitoring with enterprise privacy. Its Zero Data Retention and Private Safety Processing program is designed to protect eligible customer prompts and responses while still detecting risky patterns.

For eligible Zero Data Retention customers, prompts and responses are not retained after the request. Private Safety Processing is OpenAI’s attempt to preserve safety monitoring without giving human reviewers access to customer content.

Price per token is going up. Price per completed job might come down

Astra costs more per token than Sol.

That sounds bad.

Then Artificial Analysis finds that Astra can use dramatically fewer tokens on coding-agent work.

That sounds good.

On Artificial Analysis’ broader Intelligence Index, the efficiency gain is much smaller, which leaves Astra more expensive per task at max effort.

So the answer to “Is Astra expensive?” is becoming annoyingly workload-specific.

For short Q&A, Astra may be hilariously unnecessary.

For a coding task that previously takes three failed attempts and 300,000 tokens before finally working, a more expensive model that nails it on the first try could be cheaper.

That is exactly why the hands-on “tasks I couldn’t solve before” anecdotes matter.

A benchmark score gives you capability.

A completed-job rate gives you economics.

Sam Altman made the same argument in a Bloomberg interview. He said Astra should be judged by the price of a completed task rather than token price alone.

He also argued that the capability jump makes complicated software more buildable for people who are not experts. That is the economic promise behind the delegation story: fewer retries, less specialist hand-holding, and more completed work.

Availability is unusually staggered

OpenAI is not opening the floodgates all at once.

Its developer documentation says Astra starts with enterprises in the Trusted Access Program, with API and ChatGPT Plus, Pro, Business, and Enterprise availability expanding in the coming days.

CNBC says application-based cybersecurity organizations are among the first recipients because OpenAI wants trusted defenders testing Astra’s more advanced cyber capabilities before broader access.

Microsoft says Astra is also beginning rollout through the Microsoft Foundry Limited Access Program.

OpenAI separately lists AWS availability in its launch announcement.

Perplexity is already preparing its own distribution. CEO Aravind Srinivas called Astra the industry’s frontier model for wide-and-deep research and says it is coming to Perplexity Computer for Pro and Max users.

Distribution is also spreading into other agent products. Cognition says Astra is coming to Devin, and its launch post says it will reach Devin Cloud, Desktop, and CLI.

Cognition reports stronger internal testing, more comprehensive verification, clearer reports, and better video evidence than prior models.

Perplexity separately says Astra will come to Comet and its cloud-browser sandbox. ChatGPT Sites gives Astra another path from a prompt to hosted websites, web apps, and games.

Pro, Business, and Enterprise customers are also slated to receive GPT-6 Astra Pro, while Enterprise admins must explicitly enable Astra because access is off by default at launch.

No broad Free-tier Astra availability has been announced in the material we reviewed.

What early testers, skeptics, and the internet think about Astra

The first-day reaction is unusually useful because people are disagreeing about where the leap is.

Every’s Katie Parrott calls Astra a major upgrade with some bad habits. Astra drafted her article from one prompt well enough that Dan Shipper initially thought she had written it.

Her criticism is equally specific. She describes Astra as a “show horse” whose ambition can outrun its judgment, while Fable still has better instincts for simplifying a product during long-running delegation.

Ethan Mollick offers a more operational mental model. Treat Astra like a good outside team, not an intern.

That means specifying the outcome, the amount of leeway, what should be tested, when the agent should return, and what “good” looks like.

That advice lines up almost perfectly with the way the model is changing work. Better agents reduce micromanagement, but they increase the value of clear delegation.

Roon’s reaction captures the other strange part of frontier releases. He says he has not come close to discovering Astra’s limits, then immediately adds that he expects the model to be obsolete on the order of weeks.

That sounds contradictory until you remember how fast the frontier is moving. A model can feel bottomless on Thursday and already have a successor-shaped shadow by Friday.

Matt Shumer takes the maximalist version. He says Astra and Fable put us in a new era, and that the better question is what people can attempt now that was not previously practical.

Gary Marcus lands almost exactly between the hype and dismissal. He sees a meaningful technical advance, especially in symbolic world modeling, while refusing to treat one saturated benchmark as a certificate of general intelligence.

Hacker News spent launch day arguing over the same split. One large Astra thread debated ARC harnesses, Altman’s “median remote coworker” framing, liability when an agent ships broken software, and whether benchmark saturation reflects AGI or Goodhart’s law.

That is a healthier reaction than treating the model as either magic or irrelevant.

The useful consensus is narrower: Astra appears to have raised the ceiling on long-running, tool-using work. The remaining arguments are about reliability, cost, taste, authority, and what word to use for the capability jump.

So what actually changed with GPT-6?

GPT-4 made AI useful to talk to.

Later reasoning models made AI useful to think with.

Astra is OpenAI’s strongest attempt yet to make AI useful to delegate to.

Its most revealing capabilities all fit that pattern:

• ARC-AGI-3 measures learning while acting.
• Computer-use benchmarks measure operating software.
• Codex improvements extend how long work can continue.
• Early users report completing tasks that defeated previous models.
• Parallel agents let Astra explore several hypotheses at once.
• Persistent notes and searchable history keep projects alive across context windows.
• Better alignment is specifically aimed at deciding what an agent is authorized to do.
• The Critical cyber designation exists because Astra can take consequential technical actions with less supervision.

Even Microsoft’s enterprise pitch says the same thing in corporate language: AI moves from conversation toward delivering substantial units of work.

The center of gravity is shifting from prompt engineering to delegation engineering.

You will spend less time asking:

“Can the model answer this?”

And more time asking:

“What work can I hand over?”

“How long can it run?”

“What does it need access to?”

“When should it ask me?”

“How do I know it actually finished?”

“What is it absolutely forbidden from doing?”

Those are management questions.

The Neuron’s take

The 99.9% ARC score will get the screenshots.

The yellow circle becoming a rocket, Blender model, printable object, and game while the same agent deals with contracts, eBay, lunch, and tennis is closer to the actual story.

Astra appears to push a meaningful set of AI tasks across an invisible boundary from “cool when it works” to “maybe I should actually give this responsibility.”

That is also why the safety section is so important.

A model that only speaks can be wrong.

A model operating your computer can be wrong with permissions.

OpenAI’s own results suggest Astra has gotten substantially better at understanding those boundaries. Its own results also show that it can still overreach, and that some of its reasoning has become harder for researchers to inspect.

So I would resist both easy narratives.

“Astra proves AGI” runs ahead of the evidence.

“Astra is another benchmark bump” misses what users are actually doing with it.

The concrete change is that frontier AI can now stay oriented through more of a real job, operate more of the software involved, and recover from more of the weird little failures that used to stop agents cold.

That moves the human upward one level.

From doing the work.

To prompting every step.

To supervising the outcome.

And it leaves one question much more urgent than “Is this AGI?”

How much authority can we safely give an AI once the answer to “can it do the job?” starts becoming yes?