GPT-6 Astra: What It Actually Changes for AI Agents

OpenAI released GPT-6 Astra on September 3, 2026 as a limited preview for organizations in its Daybreak Access program, then opened it to ChatGPT Plus, Pro, Business and Enterprise users and to API developers over the following days. It is also served on Amazon Bedrock. Enterprise workspaces get it switched off by default until an administrator turns it on.

The specification sheet, from OpenAI's own model page:

• Model id: gpt-6-astra
• Context window: 1,050,000 tokens — 922,000 maximum input, 128,000 maximum output
• Knowledge cutoff: April 30, 2026
• Price: $10 per million input tokens, $1 per million cached input, $12.50 per million cache writes, $50 per million output
• Reasoning effort: low, medium, high, xhigh, max — the none setting from earlier models is gone

The training run is the largest OpenAI has done. VP of research Aidan Clark said it was the first time the company pretrained on more than 100,000 GPUs at its Stargate site in Texas, and it is the first release where earlier OpenAI models supervised the training of the new one.

President Greg Brockman called it a generational leap and closed the launch with "Welcome to the AGI era." That framing has dominated the coverage. It is also the least useful part of the release if you build agents for a living, so the rest of this post is about the parts that change what you can ship.

Most launch charts measure things agents never do. These are the ones that map onto real agent work, with GPT-5.6 Sol — the model most teams are running today — as the comparison.

Computer and browser use. OSWorld 2.0 goes from 65.7% to 72.6%, and Astra completes those tasks in roughly 47% less time. ScreenSpot-Pro, which measures whether the model can actually find the right UI element, jumps from 76.9% to 92.7%. Mind2Web completes about 1.9x faster. Agents' Last Exam moves from 53.6 to 59.3.

Long-context retrieval. This is the least glamorous number and possibly the most important. On MRCR v2 in the 512K-1M token band, Astra retrieves at 96.3% against Sol's 73.8%. A million-token window that loses the thread at 600K is a marketing number; this one holds up deep into the range.

Long-horizon coherence. OpenAI reports the model's no-chain-of-thought time horizon extending to 30.9 minutes, against 3.6 minutes previously. In plain terms: it stays on a task, holding the original constraints, for the length of real work rather than the length of a demo.

Coding. Terminal-Bench 4.0 at 57.7 (Claude Fable 5.1 sits at 55.8), DeepSWE v1.1 at 74.1% against Sol's 67.4%. Notably not a sweep — Meta's Muse Spark 1.3 scores 75.4% on DeepSWE, and several FrontierCode rows favour the Fable models.

Reasoning. FrontierMath Tier 4 at 97.6%, GPQA Diamond at 96.0%. But on Humanity's Last Exam with tools it scores 57.2% against Fable 5.1's 65.0% — a reminder that "world's most intelligent model" is a claim about a chart selection, not a property.

The independent read is more measured than the launch deck. Artificial Analysis places Astra at 61.2 on its Intelligence Index, roughly level with Sol at 60.9 and behind Fable 5.1 at 65.7. The clearest unambiguous win in their data is hallucination rate, which drops from 92% to 51%.

Read as a whole: this is a large, uneven step forward that is largest exactly where agents operate — driving interfaces, holding context, staying on task — and modest where the frontier is already crowded.

The number in every headline is ARC-AGI-3, and it deserves the fine print because it is the single easiest way to set your own expectations wrong.

ARC Prize ran the verification itself and published both figures:

• Standard harness, max reasoning: 62.7%, at a total cost of $26,098
• Provider adapter harness, high reasoning: 99.9%, at a total cost of $18,817

The difference is not prompting. The standard harness is a neutral interface across providers that lets a model carry forward notes it chooses to keep. The provider adapter harness preserves opaque reasoning state between requests and uses compaction across long conversations, so the model reuses prior work instead of rebuilding it. That architectural difference is worth 37 points.

Secondary analyses running the model statelessly report scores anywhere from roughly 17% to 63% depending on the reasoning tier. So: if your agent makes plain, stateless API calls — which is what most agents do — you will not see launch-chart behaviour. You will see the lower number.

ARC Prize is also explicit about what the result does not mean. They state that saturating the benchmark would not represent proof of achieving AGI, that the benchmark has tightly bounded scope with deterministic, closed-ended mechanics, and that they are not claiming Astra is AGI. Worth restating: the organization whose benchmark produced the headline is the one telling you not to over-read it.

The useful takeaway is not that the number is fake. It is that state management in your harness is now a first-order performance variable, on the same tier as model choice. That is genuinely new, and it is the most actionable thing in the entire launch.

Four changes shipped alongside the model, and they matter more to day-to-day agent quality than any benchmark row.

Async function calling. Set async: true on a tool and the model keeps reasoning while your application executes it, returning results later against the original call_id. Every agent that waits on a slow API — enrichment, search, a build — gets its dead time back.

Mid-turn steering. You can send corrections or changed requirements over a WebSocket during an active turn. The API preserves completed work and folds your update into the continuation, instead of forcing you to kill the run and start over. For long agent runs, this converts a restart into a nudge.

Reasoning effort you can change mid-conversation. A configuration_update input item adjusts reasoning effort without rewriting the prompt and without invalidating your cached prefix. Cheap thinking for the boring middle of a task, expensive thinking for the hard part — in one conversation, at cache prices.

Native context compaction. Built in rather than bolted on, for long multi-turn workflows.

OpenAI's model migration guide keeps the checklist short and mechanical: set model to gpt-6-astra; replace reasoning_effort: "none" with "low", which is now the floor; move tool calling to the Responses API; swap prompt_cache_retention for prompt_cache_options.ttl: "30m"; and delete temperature, top_p and top_logprobs, which the model does not accept. Fast mode is unavailable under EU data residency.

OpenAI's own prompting guidance is unusually specific about behaviour changes. Astra asks for clarification more readily, so it recommends explicit autonomy instructions if you want it to push through. It also recommends telling the model to prioritize user instructions over guidance loaded from skill files — which brings us to the change that matters most for anyone in the skills ecosystem.

Astra's supported tool list includes web search, file search, image generation, code interpreter, a hosted shell, patch application, computer use, MCP, tool search — and skills.

That last one is not a new proprietary format. It is the open Agent Skills standard: a versioned bundle of files with a SKILL.md manifest, front matter carrying name and description, and a Markdown body of instructions. Exactly one SKILL.md per bundle, up to 500 files, 50 MB compressed. You attach skills by reference to a hosted shell, by local path, or inline as a base64 ZIP, and the platform adds skill metadata to the prompt so the model decides for itself when a skill applies.

If that sounds familiar, it should. It is the same standard we covered in Claude Skills vs. ChatGPT GPTs vs. Gemini Gems — the format Anthropic opened as a public standard in December 2025 and that OpenAI, Microsoft, JetBrains, Cursor, Gemini CLI, Block's Goose and dozens of other tools adopted through early 2026. It is the format OpenClaw skills are written in.

The practical consequence is portability that now runs in both directions. A skill you write is readable by OpenAI's flagship model, by Claude, by the coding agents, and by your OpenClaw deployment, without a rewrite. The bet that skills would outlast any single vendor's container format looks better this week than it did last week.

One caution straight from OpenAI's documentation: Astra is stronger at general instruction following than previous models and, as a direct result, more sensitive to instructions contained in skills and other files such as AGENTS.md. Guidance you wrote loosely for a weaker model — a stylistic preference, an over-broad rule, a stale constraint — will now be followed literally. Before you point Astra at a mature skill library, audit it for rules that contradict each other or that you never actually meant as hard requirements. Teams are hitting this, and it reads as a model regression when it is really an instruction-quality problem you inherited.

List price is $10 per million input tokens and $50 per million output. That is roughly 2.5x GPT-5.6 Sol per token, and about 8x what the cheapest credible frontier alternatives charge.

The part that surprises people is the tier cliff. Those rates apply to requests at or below 272,000 input tokens. Cross that line and the entire request bills at 2x input and 1.5x output — $20 and $75 per million. A million-token context is available; it is not priced as a casual default. If your agent stuffs history into every call, you can cross that boundary without noticing and roughly double your bill on the requests that were already your most expensive.

The rest of the pricing surface:

• Cached input at $1 per million, cache writes at $12.50 per million
• Batch and Flex processing at 50% of standard rates
• Fast mode at 2x price for up to 2x speed, and not available under EU data residency
• Hosted tool calls such as web search bill per call on top of tokens

Per token is the wrong unit anyway. Per finished task, the picture splits. On coding work, reported results have Astra matching Fable 5's capability at less than half the cost, because it burns far fewer tokens getting there. On general work at maximum reasoning effort, Artificial Analysis measured it at roughly 75% more expensive per task than Sol.

So the honest cost guidance is: token efficiency partly offsets the sticker price, and where it does, it is on exactly the long agentic tasks Astra is built for. Everywhere else you are paying a premium for capability you may not be using. Measure your own cost per completed task before and after — not cost per million tokens, which will mislead you in both directions.

Two facts here should change how much authority you hand this model, regardless of what you think about the AGI framing.

It is the first model OpenAI has designated Critical for cybersecurity under its Preparedness Framework — meaning it can find and exploit previously unknown vulnerabilities in well-protected systems without step-by-step human guidance. It scored 100% on ExploitBench against Sol's 78.5%, 88% on SRE-Bench against 55.9%, and discovered two zero-day vulnerabilities during testing. That designation is why the rollout is staged and why offensive capabilities such as proof-of-concept exploit creation are gated behind the Daybreak program with refusals enforced at the API level. Secure code review and patching are enabled at launch; the offensive half is not generally available.

It is harder to monitor than its predecessor. Astra uses a recurrent depth reasoning technique that obscures part of its reasoning process, and it no longer verbalizes chains of thought the way earlier models did. Researchers have flagged this directly: Ryan Greenblatt, chief scientist at Redwood Research, called it "extremely concerning," and Gary Marcus noted the system appears less monitorable than prior ones, which is not great from a safety perspective. Reported chain-of-thought controllability drops to 93% in some controlled scenarios.

The alignment numbers genuinely improved in places — 0% on honeypot cheating evaluations against Sol's 48.2%, and misaligned outcomes in cyber scenarios falling from 18.8% to 3.4%. Both things are true at once: it behaves better, and you can see less of why.

For anyone deploying agents, the operational reading is simple. A more capable model that reasons less legibly is a model whose permissions you scope more tightly, not less. The permission modes, workspace-anchored filesystem access and explicit credential handling that shipped in OpenClaw 2.0 are the right posture for exactly this model. Capability going up is not a reason to widen the blast radius.

No, and the interesting part is that almost nobody with something to lose is saying otherwise.

Brockman said he personally believes OpenAI has reached AGI. That is a belief stated by an executive at launch, not a demonstrated or independently settled result. ARC Prize, whose benchmark supplied the headline, says explicitly it is not making that claim. Gary Marcus — who has argued for a decade that models need exactly the kind of symbolic world-model building Astra appears to be doing, and who credits the result as impressive — still lands on the same place: success on ARC-AGI is not proof of AGI, and the open question is whether the capability is robust or task-specific.

The substantive criticisms are worth holding onto because they are all testable:

• Gains are uneven once cost and non-cherry-picked evaluations are included
• Astra was evaluated through OpenAI's Responses API harness with two settings changed, while comparison models were evaluated under different setups
• OpenAI funded part of FrontierMath's development, one of its strongest results
• Evaluations ran at maximum effort, which inflates both latency and token spend relative to any configuration you would run in production
• Alignment improvements may partly paper over specific failure modes rather than resolve them

None of that makes the model unimpressive. It makes the launch charts a marketing artifact, which is what launch charts have always been. The way to find out what Astra does for you is to run your own tasks against it, at the reasoning effort and harness you can actually afford in production, and compare finished outcomes. That takes an afternoon and beats a month of discourse.

OpenClaw supports Astra through the standard OpenAI provider. One command — openclaw models set openai/gpt-6-astra — and you are on it.

That works with an OpenAI API-key profile or with a ChatGPT/Codex subscription that has Astra access — OpenAI explicitly supports subscription OAuth in external tools. If you are on 2.0, live model discovery pulls what your provider actually offers rather than a baked-in catalog, so it appears once your account has it.

The question is not whether you can use it. It is which skills should touch it.

Route to Astra the skills whose value is judgment over long, multi-step work where a wrong answer is expensive:

• Deep Research Agent — long-horizon retrieval across a large context is precisely the improvement, and the drop in hallucination rate matters most where output is cited
• Legal Contract Reviewer and Financial Analyst — long documents, expensive mistakes, retrieval that has to hold across the whole file
• Fullstack Architect and Code Reviewer — where token efficiency makes the premium roughly wash on a per-task basis
• Competitor Intel Analyst — multi-source synthesis that benefits from staying coherent across a long run

Do not route high-volume, low-judgment skills to it. A Customer Support Agent answering hundreds of routine WhatsApp messages, a Meeting Summarizer, a Social Media Manager drafting posts — these were never limited by frontier reasoning, and at $50 per million output tokens the upgrade is a pure cost increase. The per-skill model selection that OpenClaw has always had is the entire point: a fast, cheap model for volume, a frontier model for judgment.

Two OpenClaw-specific notes. First, if your skills are mature, audit them before switching — Astra's stronger instruction following means loose or contradictory guidance in a SKILL.md now gets obeyed literally. Second, a model that reasons less legibly deserves tighter permission scoping, not looser: keep sessions in restrictive permission modes, keep filesystem access anchored to the workspace, and keep credentials in masked prompts rather than in context.

A short, boring checklist beats a take.

1. Pick your three highest-value tasks — the ones where a better answer is worth real money — and run them on Astra and on your current model, at a reasoning effort you would genuinely pay for in production. Compare finished outcomes, not vibes.
2. Measure cost per completed task, not per token. The sticker price is 2.5x; the real delta on long agentic work is frequently smaller and occasionally negative. You cannot know which without your own numbers.
3. Check your input token sizes against the 272,000 cliff. If your agent routinely crosses it, trimming history is the highest-ROI change available to you this week.
4. Audit your skill files. Stronger instruction following is only good news if your instructions are good. Look for contradictory rules and preferences you never meant as hard constraints.
5. Fix your harness before you blame the model. State preservation and compaction were worth 37 points on ARC-AGI-3. If your agent calls the API statelessly on every turn, that is now a performance bug, not an architecture choice.
6. Do not widen permissions to celebrate. More capability plus less monitorability is a case for tighter scoping.

The genuinely new thing in this release is not a benchmark. It is that how you run the model — state, compaction, tool async, effort routing — now moves results as much as which model you picked. That is an engineering problem, which means it is one you can actually go and solve.