GPT-6 Astra: Priced Like a Frontier, Gated Like a Weapon

OpenAI shipped GPT-6 Astra on 3 September 2026 under the banner “Welcome to the AGI era”. What actually landed is a 1.05-million-token computer-use model that is very good at operating machines, priced at two and a half times its predecessor, and the first model the company has rated Critical against its own cybersecurity framework. Three separate things, and only one of them is about intelligence.

I went looking for the practical answer — should I switch, what does it cost, what do I configure — and ran into a fourth thing nobody put in a headline: my account cannot run it at all. Not the API key, not the Codex login. Worth checking before you read another benchmark chart.

What Actually Shipped

Astra is a computer-use model before it is anything else. The pitch is that it drives software — browsers, terminals, spreadsheets — for long stretches without a human re-steering it every few minutes. OpenAI's own framing leans on autonomy and duration, not on raw reasoning.

One line in that table earns a second look. The cutoff is 30 April 2026 and the model shipped in September. A release date is not a knowledge date. Anything from the last four months — SDK changes, security advisories, framework migrations, the API you are actually integrating against — has to arrive through your prompt, your repository or a retrieval layer. A bigger window does not fix a stale cutoff; it just gives you more room to paste the fix in.

The number that actually describes the change is not a benchmark. On OSWorld, average time per task dropped from roughly 75 minutes to roughly 40 — a bit under half the clock removed, on the same class of work. For anyone running agents on long jobs, that is the headline, and it is a throughput claim rather than an intelligence claim.

The Benchmarks, Minus the Harness

The launch table is genuinely strong. It is also doing some work that deserves to be named.

The ARC-AGI-3 result is the one to be careful with. It measures the model plus the agent system — a stateful harness that retains reasoning between turns. That is a legitimate way to build an agent and a dishonest way to read a model card. If your harness discards reasoning between turns, you are not buying 99.9% of anything, and the number tells you nothing about what you will get.

Then there is the shape of the sheet. Saturated on maths and exploits, mid-70s on coding, low-40s on ExploitGym. That is a specialist profile. It is not a model that got uniformly smarter; it is a model that got dramatically better at operating a computer and stayed roughly level on the task most of us actually buy models for. On Humanity's Last Exam with tools it trails Claude Fable 5.1 and Opus 5.

The Bill, And The Cliff Inside It

The surcharge is the part that will surprise people. It is not metered on the overage. Cross 272,000 input tokens and the entire request reprices. There is no gentle slope — there is a step.

Concretely. A 270K-token input with 8K of output costs about $3.10. Push that same call to 280K of input — one more file in the context — and it costs about $6.20. You added 4% more input and doubled the bill. If you are stuffing a large repository into context on every turn, that boundary is the single most expensive line in your architecture, and it is invisible until the invoice arrives.

The honest counterweight is the clock. OpenAI reports the same class of task finishing in roughly 40 minutes instead of 75. That is a real number and it is not a token number — elapsed time and price per token are different units, and one does not cancel the other. Whether the trade works depends on something only you can measure: what an hour of waiting costs you against what the extra tokens cost. If nobody is waiting on the run, the speedup buys you nothing and you are simply paying more.

When 2.5x Is Worth It

For most people reading this, the row that decides it is the second one. If your agent runs while you do something else, you are paying 2.5x for a speedup you will not perceive.

Can You Even Run It? Two Commands

Before configuring anything, check. This takes ten seconds and saves an afternoon.

# 1. Codex CLI
codex exec --model gpt-6-astra "say ok"

# 2. Raw API, if you have a key
curl -s https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-6-astra","input":"say ok","max_output_tokens":16}'

On my machine, today, signed in to Codex with a ChatGPT account, the first returns:

The 'gpt-6-astra' model is not supported when using Codex with a ChatGPT account.

And the second returns, in the error body:

{
  "message": "The model `gpt-6-astra` does not exist or you do not have access to it.",
  "code": "model_not_found"
}

A launch announcement is not an entitlement. Astra is going to the Trusted Access and Daybreak programmes first, with the paid ChatGPT tiers, the API and AWS following. I have no visibility into where any other account sits in that order — which is precisely why the two commands above beat reading about it.

So do not repoint your global config at it today. If you set model = "gpt-6-astra" in ~/.codex/config.toml before you have access, every Codex invocation fails until you undo it. Check first, then switch.

The Configuration, For The Day It Lands

Two lines in ~/.codex/config.toml. That is the whole change. Everything below was run against codex-cli 0.153.0; check your own version before copying, because launch-week CLIs move.

model = "gpt-6-astra"
model_reasoning_effort = "max"

Per-invocation, without touching the file — useful for exactly the check-then-commit sequence above:

codex --model gpt-6-astra -c model_reasoning_effort="max"

# non-interactive, same flags
codex exec --model gpt-6-astra -c model_reasoning_effort="max" "refactor this module"

Keep a profile for the fallback so switching back is one flag, not an edit:

[profiles.astra]
model = "gpt-6-astra"
model_reasoning_effort = "max"

[profiles.sol]
model = "gpt-5.6-sol"
model_reasoning_effort = "max"

Then codex -p astra or codex -p sol.

On the API, effort lives under reasoning.effort:

{
  "model": "gpt-6-astra",
  "input": "...",
  "reasoning": { "effort": "max" }
}

The Astra model page documents five values — low, medium, high, xhigh and max. The platform enum is wider than that. Sending a deliberately invalid value and reading what comes back is the fastest way to see the real list your account is talking to:

Invalid value: 'bogus'. Supported values are: 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', and 'max'.

That came back from a GPT-5.6 Sol request, so read it as what the platform accepts rather than proof of Astra's own set — run the same trick against Astra the day you have access, and trust that over any blog post including this one. Either way max is the ceiling, and effort is a token multiplier. At $50 per million output tokens, max on a task that medium would have solved is not thoroughness, it is a donation. Set it high where the work is genuinely hard and leave it lower everywhere else.

Headless: What Changed, What Didn't

If you drive Codex from CI or a script, the good news is boring: codex exec is unchanged. Same non-interactive entry point, same --model, same -c key=value overrides, same --json event stream, same --output-schema for structured results. Nothing to migrate.

What changed is on the model side, and it matters most precisely for headless runs. Notes replace compaction. Long agent runs used to compress their history as the window filled, and compression is lossy in the worst possible way — it throws away the failed attempts, which are exactly what stops an agent trying the same broken thing at minute forty that it tried at minute five. Notes keep that detail.

The second change is subtler: the model can ask a question and keep working on everything that does not depend on the answer. One unresolved decision no longer stalls the whole run. If you have ever come back to an agent that sat idle for twenty minutes waiting on a yes/no, that is the fix.

For interactive use that is pure gain. For headless runners it is a new design problem, and worth thinking about before it bites: a question no longer means the process stopped. Your runner has to distinguish a blocking question from a pending one, or it will either kill live work that was progressing fine, or sit waiting on something the agent already moved past. And the mirror risk is worse — an agent that keeps going while nobody answers will make the call itself.

So say it in the prompt: what it may decide alone, what needs approval, how long it may continue unanswered, and what counts as done. Notes preserve memory; they do not confer authority.

One more thing that belongs in the runner rather than the model: enforce the 272K boundary yourself. A headless agent will accumulate file contents, terminal output and tool observations while doing exactly what you asked, and cross the price step without ever doing anything wrong. Count the tokens where you control the loop.

The Cyber Gate Is The Real Story

Astra is the first OpenAI model to trip the company's own Critical cybersecurity threshold. Standard access refuses advanced cyber work including exploit discovery. Full capability sits behind an application-based programme.

Take that at face value for a second. A vendor shipped a product, measured it against its own safety framework, and concluded the thing it built is dangerous enough to require vetting its buyers. Whatever you think of the AGI framing, that is a genuinely new sentence in this industry — and it is a much larger claim than any benchmark on the sheet.

The practical read: expect refusals on security work that Sol handled, expect them to be inconsistent while the classifier settles, and do not build a security workflow on standard access assuming it will behave like the last model did.

What I'm Doing

Staying on GPT-5.6 Sol at max effort, because that is the only thing my account can actually run today. When Astra reaches me I will move the agent work that runs unattended for long stretches, and leave ordinary code generation where it is. Two and a half times the price for 74.1% against a competitor's 75.4% on the same coding benchmark is not a decision, it is a reflex — and reflexes are how token budgets die.

The interesting question is not whether Astra is smarter. It is what happens now that OpenAI has priced the frontier at $50 per million output tokens while the rest of the market moves the other way. Either agentic throughput is worth a premium that large — in which case measure your wall-clock, not your benchmark deltas — or this is the release where "frontier" stops meaning "default" and starts meaning "the expensive one you reach for on purpose."

My money is on the second. Which is fine. A model you reach for on purpose is a healthier thing than a model you reach for by habit.