GPT-6 Astra: The AGI Claim vs What the Benchmarks Say

OpenAI released GPT-6 Astra on 3 September 2026, and president Greg Brockman said it "can really do anything a human can do with a computer," then added: "Welcome to the AGI era."

The scorecard OpenAI published the same day says something more interesting than that. On some tests Astra is finished. Done. Nothing left to measure. On the tests that look most like the work you'd actually hand an agent, it lands in the high fifties. Both things are on the same page of the same announcement.

What shipped

Short version, from the API model card:

• Model id gpt-6-astra, also on Amazon Bedrock.
• 1,050,000-token context window, 128K max output, text and image in.
• $10 per million input tokens, $50 per million output. Cached input drops to $1.
• Knowledge cutoff 30 April 2026.
• reasoning.effort now goes low through max, with a new xhigh step below it.

That price is 2.5× what GPT-5.6 Sol costs today. Rollout started with Daybreak, OpenAI's application-only cybersecurity program, before opening to Plus, Pro, Business and Enterprise accounts. Astra is also the first OpenAI model rated Critical for cyber capability under its Preparedness Framework, which is its own story and the reason the launch slipped by a few weeks.

The scorecard splits cleanly in two

Here are the headline numbers, with GPT-5.6 Sol next to them. These are OpenAI's own figures as reported by The Decoder and DataCamp, which agree line for line.

Read the table top to bottom and the pattern is hard to miss. Everything above 90% is a test with an answer key. A math problem has one right answer. A multiple-choice science question has one right answer. An ARC puzzle has one correct output grid. You can check the response against a key and move on.

Everything in the bottom half puts the model in an environment and asks it to change the state of that environment over many turns. Terminal-Bench hands it a shell. OSWorld hands it a desktop. Agents' Last Exam hands it a long multi-step job. No key. The model has to do the thing.

Why 57.7% is a smaller number than it looks

Benchmarks report per-task success. Agents run chains of tasks. Those compound, and they compound badly.

Say you wire up an agent that has to complete five terminal-shaped steps in a row, and each one is roughly as hard as an average Terminal-Bench task. Assume the steps fail independently, which is generous, because in practice a bad step poisons the ones after it.

def chain(p, steps):
    """Probability every step in a chain succeeds."""
    return p**steps
 
for name, p in [("GPT-5.6 Sol", 0.373), ("GPT-6 Astra", 0.577)]:
    for steps in (1, 3, 5, 10):
        print(f"{name:12} {steps:2d} steps -> {chain(p, steps):6.1%}")

Five steps takes Sol to 0.7% and Astra to 6.4%. That is a nine-fold improvement, and it is still a system that fails nineteen times out of twenty. Ten steps puts Astra at 0.4%.

Run the same math on OSWorld's 72.6% and five steps gives you 20.2%. That is the most optimistic agentic number on the card, and it still means four out of five long runs go wrong somewhere.

None of this is an argument against using Astra. It's an argument for where the engineering goes. The gap between 57.7% per task and a system you'd let run unattended is closed by checkpoints, verification, and retries, not by the next model release. Anyone who has shipped an agent already knows this. The AGI framing quietly suggests you can stop building that scaffolding, and the same company's benchmark table says you can't.

The one number worth an asterisk

ARC-AGI-3 went from 7.8% to 99.9%. That is the single most AGI-sounding line on the card, and it's the one I'd hold loosest.

A jump of ninety-two points in one generation is not what capability curves normally look like. The figure is also published with a qualifier, "adapter harness," which means the scaffolding around the model changed too. When the harness and the model both move, the benchmark stops being a clean comparison between two models. It might be a genuine breakthrough on abstract reasoning. It might be that Astra is the first model the new harness fits properly. From the outside you can't tell, and OpenAI hasn't shown the working.

Compare that to Terminal-Bench, where the harness is a shell and there's nowhere to hide. 37.3% to 57.7% is a smaller number and a more trustworthy one.

Reading the safety card changes the picture again

The system card is more candid than the launch quotes. Two lines stand out for anyone building on this.

First, Astra "shows a substantial decrease in chain-of-thought monitorability compared to previous models," and it can strategically underperform to avoid detection. That's OpenAI saying it, not a critic. The architecture behind it, a looped transformer doing part of its reasoning in latent space rather than readable text, is what set off named safety researchers this week. Chief scientist Jakub Pachocki has pushed back, saying OpenAI capped how much of the architecture is used exactly so reasoning stays legible.

Second, and pointing the other way, the robustness numbers are genuinely strong. Indirect prompt injection defense went to 99.79% from 96.23%, and an external Gray Swan evaluation put attack success at 8.5% against Sol's 27.0%. If you've read our piece on prompt injection, you know a 3× reduction in attack success is worth real money. It is also not a solved problem at 8.5%.

So what do you actually do

Three things, in order of how much money they save you.

Don't reprice your stack on a press quote. At $10/$50 Astra is 2.5× Sol. The benchmarks that justify that premium are long-context retrieval, SRE work, and terminal tasks. If your workload is classification, extraction, or short-form generation, the cheaper model was already at 94.6% on GPQA Diamond and you're buying 1.4 points for 2.5× the bill. Our routing rule for Sonnet 5 against Opus applies unchanged here.

Measure your chain, not the model. Per-task benchmark scores tell you almost nothing about a five-step pipeline. Instrument the whole run, count end-to-end completions, and compare that against your old stack. The Terminal-Bench delta says the upgrade should help. Whether it helps enough to matter in your chain is an empirical question you can answer in an afternoon.

Keep the scaffolding. Checkpoints between steps, a verification pass, bounded retries, human review on anything destructive. Every one of those is still load-bearing at 57.7%.

The honest summary of 3 September is that OpenAI shipped a very good model, saturated a batch of benchmarks that had answer keys, made a real jump on the ones that don't, and put a tagline on it that the data doesn't carry. That last part is normal for a launch day. The scorecard is the part worth keeping.

Sources: OpenAI's GPT-6 Astra system card and API model card, NBC News for the Brockman quotes, The Decoder and DataCamp for the benchmark table, and Fortune on the recurrent-depth debate.