GPT-6 Astra for Developers: API, Pricing and Benchmarks

GPT-6 Astra is OpenAI’s frontier model, released 3 September 2026. For developers the short version is this: it has a 1,050,000-token context window, costs $10 per million input tokens and $50 per million output, exposes five reasoning effort levels up to max, and is built for long-horizon agentic work — computer use, browser automation, multi-step software engineering.

And it will break your existing integration in four specific ways that most coverage of this release does not mention.

Tool calling only works on the Responses API, even though Chat Completions is technically supported. temperature, top_p and top_logprobs must be removed from your requests. The none reasoning effort that GPT-5.6 accepted no longer exists. And any prompt over 272,000 tokens is billed at double the input and cache rate — which turns the headline “1M context” into a cost cliff nobody puts in a comparison table.

This article covers what Astra actually is, what changed, what it costs in practice, where it genuinely beats Claude and Gemini, and — the part almost nobody is writing — where it loses. Astra is behind Claude Fable 5 on three separate coding benchmarks while costing exactly the same per token. If you are choosing a model for a coding agent, that matters more than the headline scores.

Every technical claim below is labelled: Confirmed means it comes from OpenAI’s own documentation or announcement. Reported means a credible third party published it. Assessment means it is my read of the evidence, and you should treat it as such.

What GPT-6 Astra is

Confirmed. GPT-6 Astra is OpenAI’s most capable model, positioned for “complex reasoning, coding, computer use, research, and document creation,” with particular emphasis on long-horizon agentic tasks that involve driving a computer or a browser.

It went to trusted partners as a limited preview on 3 September 2026 and to paid users the following day, in a restricted build that refuses certain cybersecurity prompts. Rollout covers ChatGPT Plus, Pro, Business and Enterprise, plus the OpenAI API, Microsoft Azure and AWS Bedrock.

The name matters for a practical reason: OpenAI has moved to codenamed point releases. The previous frontier model was GPT-5.6 Sol. Astra is the GPT-6 generation. When you read benchmark tables, “Sol” is the thing Astra is being compared against, and it is still a perfectly good model that costs 60% less.

The specification, in one table

Confirmed, all of it, from OpenAI’s model page. Note the gap between the 1,050,000 context window and the 922,000 maximum input — the difference is reserved for reasoning and output. If you plan around “one million tokens of input” you will hit a wall about 78,000 tokens early.

Why this release matters for developers

Three things separate Astra from a routine version bump.

The computer-use numbers are a step change, not an increment. On OSWorld 2.0 Astra scores 72.6% against Sol’s 65.7%, and it does it in roughly 40 minutes per task versus about 75 — a 47% reduction in wall-clock time (Reported). On ScreenSpot-Pro, which measures GUI element grounding, it goes from 76.9% to 92.7%. That is the difference between a demo and something you can point at a real workflow.

Long-context retrieval finally holds up at the top of the window. On the MRCR v2 eight-needle test, Astra scores 100% in the 256K–512K band and 96.3% in the 512K–1M band, against Sol’s 91.5% and 73.8% (Reported). Sol’s collapse past 512K is the reason a lot of teams never used its full window. Astra’s does not collapse in the same way.

It is the first model OpenAI has classified as Critical for cybersecurity capability under its Preparedness Framework (Confirmed). That has direct product consequences, which the safety section below covers — but the short version is that some capabilities are gated, and your app’s error handling needs to expect refusals it did not get before.

The GPT-6 Astra API: what actually changes

This is the section I would read first if I were shipping on Monday.

Tool calling requires the Responses API

Confirmed. OpenAI’s migration guidance is explicit: “GPT-6 Astra supports Chat Completions, but tool calling requires Responses.”

If you have a Chat Completions integration that uses function calling — which is most production LLM code written before 2026 — swapping the model string is not a migration. You have to move the endpoint. Plan for that properly rather than discovering it when your tools silently stop being invoked.

Sampling parameters must be removed

Confirmed. Strip temperature, top_p, top_logprobs and related fields. Reasoning models control their own sampling; sending these is not merely ignored, it is unsupported.

If you have a config layer that sets temperature: 0 everywhere for determinism — and many teams do — that code path needs a model-aware branch before you flip the model ID.

The none effort level is gone

Confirmed. GPT-5.6 exposed six effort levels including none. Astra supports five: low, medium, high, xhigh, max. OpenAI’s own advice: “If you currently use none or minimal, start with low and compare results.”

Assessment. This is the change most likely to hurt your bill quietly. Anyone using none for cheap classification or routing was paying for near-zero reasoning tokens. The floor is now low, on a model that costs 2.5× Sol per input token. For high-volume, low-complexity calls, the honest answer is often to leave them on Sol.

Prompt caching is configured differently

Confirmed. Migrating from GPT-5.5 or earlier, replace prompt_cache_retention with prompt_cache_options.ttl set to "30m".

Caching is not a nicety here. At $10 input versus $1 cached, a stable system prompt and tool schema that survives across turns is a 90% saving on that portion of every request. Structure your prompts so the invariant part comes first and never changes — any edit to the prefix invalidates the cache.

Per-turn effort without destroying your cache

Confirmed. Keep request-level reasoning.effort fixed as your baseline. When a single turn needs more or less thinking, insert a configuration_update input item immediately before that user turn rather than changing the request-level parameter.

Assessment. This is the most useful under-documented detail in the whole release. Changing reasoning.effort per request changes the request configuration, which breaks prompt prefix caching and re-bills your entire system prompt at full rate. On a long agent conversation with a 20,000-token preamble, doing that on every turn is the difference between $0.02 and $0.20 per step. The configuration_update item lets you escalate one hard turn to xhigh while the cached prefix survives.

Service tier limitations

Confirmed. Astra does not support service_tier: "fast" or service_tier: "priority" with EU data residency. If you are running under EU residency requirements, latency-sensitive paths need a different plan.

Built-in tools

Confirmed. The model page lists these hosted tools: web_search, file_search, image_generation, code_interpreter, hosted_shell, apply_patch, skills, computer_use, mcp, tool_search.

Four are worth calling out because they change how you architect an agent.

tool_search deserves emphasis. The traditional ceiling on agent design is that every tool schema sits in the context window, so 200 tools means a bloated, expensive, and less accurate prompt. Searching the tool registry rather than inlining it changes what is buildable.

Confirmed warning: the model is “sensitive to conflicting instructions in skill files.” If two skills disagree, behaviour degrades. Keep them narrow and non-overlapping.

Astra also carries forward the GPT-5.6 capability set: computer use, Structured Outputs, streaming, Programmatic Tool Calling, multi-agent orchestration, prompt caching, persisted reasoning, compaction, and pro mode (Reported).

Choosing a reasoning effort level

OpenAI documents that five levels exist and gives no guidance on picking between them. That absence is the single biggest practical gap in the official documentation, so here is a working framework — Assessment, based on how reasoning models have behaved through the GPT-5 line and what the migration notes imply.

Two rules that hold regardless:

1. Benchmark scores were run at maximum effort. Vellum’s analysis notes explicitly that “every number above was run at maximum effort unless noted, which lifts scores and inflates latency and token use.” Your medium-effort production deployment will not reproduce the published figures. This is the most common way teams end up disappointed by a model that is performing exactly as designed.
2. Measure, do not assume. Run your own eval set at low, medium and high, then diff the outputs side by side — our Text Compare tool does this in the browser, and JSON Compare is better if you are using Structured Outputs. The gap between levels is task-dependent and sometimes surprisingly small — in which case you have just saved a lot of money.

Benchmarks, and how to read them honestly

All figures below are Reported — published by OpenAI and compiled by third parties. I have included the comparison models where they were published on the same benchmark.

Where Astra wins clearly

The SRE-Bench result is the one I would look hardest at if I ran an on-call rotation. 88% single-attempt against Sol’s 55.9% and Fable 5.1’s 12.5% is not a marginal gain.

Where Astra loses — the part nobody is putting in a table

Assessment. Read those two tables together and a clear pattern emerges. Astra’s decisive advantage is in agentic and computer-use work — driving a GUI, operating a terminal, long-horizon multi-step tasks, incident response. On pure code generation it is roughly level with Claude Fable 5, sometimes fractionally behind, at identical per-token pricing.

If you are building a coding assistant that writes and edits code, the benchmark evidence does not support switching to Astra on quality grounds alone. If you are building something that operates a computer to accomplish a goal, it does.

Five caveats that should change how much you trust these numbers

1. Everything was run at maximum effort. Your production settings will score lower.
2. Epoch AI, which runs FrontierMath, was funded by OpenAI and OpenAI has exclusive access to part of it. The 97.6% is still a real number; the independence is compromised.
3. On BenchCAD, OpenAI notes the Claude runs used modified evaluation settings. Treat that 95.9% versus 84.3% as not directly comparable.
4. On ExploitGym, OpenAI removed the usual six-hour time limit for both models. Fairer than it sounds, but it is not the standard benchmark.
5. OpenAI did not lead with Humanity’s Last Exam, where Astra underperforms both Claude models and, on some splits, prior OpenAI models. Selective emphasis is normal marketing; you should still know it happened.

GPT-6 Astra vs the alternatives

vs GPT-5.6 Sol

Assessment. Astra costs 2.5× Sol. For agentic and computer-use work that is easily justified — the 47% reduction in task time alone can offset the token premium. For chat, summarisation, extraction and straightforward code completion, Sol remains the better economic choice and it is not close.

vs Claude’s current models

Claude Fable 5.1 is priced identically at $10 / $50 (Reported). It leads on the Artificial Analysis Intelligence Index (65.7 vs 61.2) and on Humanity’s Last Exam with tools (65.0% vs 57.2%). Claude Fable 5 leads narrowly on FrontierCode and the Coding Agent Index.

Astra leads decisively on computer use, ARC-AGI-3, FrontierMath, AutomationBench and SRE-Bench.

Assessment. At identical pricing this is a genuine split rather than a winner. Choose Astra for agents that operate software; choose Claude for code authorship and broad reasoning. Anyone telling you one is simply better has not read both columns.

vs Gemini

The only directly comparable figure published is GPQA Diamond, where Astra scores 96.0% against Gemini 3.8 Flash’s 95.3% (Reported). Gemini 3.8 Flash is priced at $0.75 / $3.75 — roughly a thirteenth of Astra’s input cost.

Assessment. Comparing a frontier model to a Flash-tier model on one benchmark proves very little, and I would not draw conclusions from it. What it does illustrate is that on well-trodden academic benchmarks the gap between tiers has narrowed to near-nothing. Benchmark parity and task parity are different things — but if your workload looks like GPQA, you are dramatically overpaying for Astra.

Cost, in practice

Sticker price tells you less than you think. Four things move the real number.

The 272K cliff. Confirmed: prompts above 272,000 input tokens are billed at 2× input and cache rates. A 300,000-token prompt does not cost $3.00, it costs $6.00. If your design involves stuffing a large codebase or document corpus into context, model the cost at the doubled rate or find a retrieval strategy that keeps you under the line.

Reasoning tokens are output tokens. They bill at $50 per million. At max effort a single hard problem can consume tens of thousands of them before the model writes a word you see. This is where unmonitored spend happens.

Caching is the biggest lever available. $10 to $1 is a 90% reduction on the cached portion. Keep the invariant prefix genuinely invariant, set prompt_cache_options.ttl to "30m", and use configuration_update instead of per-request effort changes so you do not invalidate it.

Batch and Flex are half price. Confirmed. Anything that does not need an immediate answer — overnight analysis, bulk document processing, eval runs — belongs on Batch. Halving the bill for work nobody is waiting on is the easiest saving in this list.

A cost checklist before you ship

• Route by difficulty. Send the easy 80% to a cheaper model and reserve Astra for what needs it.
• Set max_output_tokens deliberately. The 128,000 ceiling is not a target.
• Log reasoning token counts separately from visible output. You cannot control what you do not measure.
• Put a hard spend ceiling on any long-running agent loop before it goes near production.
• Re-run your eval set at one effort level lower than you assumed. Frequently the results are indistinguishable.

Building agents with Astra

This is where the model is aimed, and the design guidance follows from the documented behaviour.

Confirmed: the model “exhibits greater autonomy but may ask clarifying questions,” and OpenAI recommends initiative prompts that direct it to “bias towards action and carry the user’s intended task to completion.”

Assessment. In an unattended pipeline a clarifying question is a hang, not a courtesy. If nothing is going to answer, say so explicitly in the system prompt — state the assumptions to make when information is missing, and instruct the model to record them rather than stop.

Confirmed: the model “may over-test small coding changes.” Expect a one-line fix to arrive with a test suite attached. If that is unwanted, constrain it in the prompt; if you are running in CI, budget for the extra tokens and time.

A workable agent skeleton

1. Stable prefix. System prompt, tool definitions and any fixed context first, never edited mid-session. This is what caching pays for.
2. Baseline effort at medium. Escalate individual turns with configuration_update, not by changing the request.
3. Tools via tool_search once you exceed roughly a dozen. Inlining a large registry costs accuracy as well as tokens.
4. Use apply_patch for file edits. Structured patches fail loudly; whole-file rewrites fail silently.
5. Validate generated code before executing it. An agent with hosted_shell access will happily run a query it just wrote. If that query touches a production database, check it first — our SQL syntax checker catches trailing commas, clause-order mistakes and joins with no ON condition without running anything.
6. Compaction for long runs. Even a million-token window fills on a genuinely long task.
7. Checkpoint state outside the conversation. Any long-horizon agent needs to survive a crash without replaying from turn one.
8. Bound everything — max steps, max spend, max wall-clock. Autonomy without a ceiling is how you find out what a $400 loop looks like.

Handling the output

Two things bite teams consuming model output at scale, and neither is specific to Astra.

Generated prose carries characters you cannot see. Model output routinely contains typographic quotes, non-breaking spaces and occasionally zero-width characters. Paste that into a CSV, a JSON string or a code file and it breaks in ways that are genuinely hard to debug, because the text looks correct. If a downstream import or an exact-match lookup starts failing on model-generated data, check the string itself with our Invisible Character Detector, or strip them in one pass with the Text Cleaner. There is more on that failure mode in our guide to the invisible characters that break CSV imports.

Use Structured Outputs rather than parsing prose. With temperature unavailable, a JSON schema is now your main lever for predictable, machine-readable responses. Validate against the schema on every response and treat a validation failure as a retry, not an exception.

Safety and security

Confirmed. Astra is the first OpenAI model to reach the Critical cybersecurity threshold under the Preparedness Framework. That threshold means a model can identify and develop functional zero-day exploits in hardened real-world systems without human intervention, or devise and execute novel end-to-end attack strategies from a high-level goal.

Practical consequences for developers:

• The public model refuses advanced cybersecurity work, including writing proof-of-concept exploits. Legitimate security tooling will hit refusals. OpenAI runs a separate programme, Daybreak Blue, for vetted defensive use.
• Refusals are a code path. If your product touches security research, penetration testing or vulnerability triage, handle refusal responses explicitly instead of surfacing an empty result.
• ExploitBench: 100% (Reported), against Sol’s 78.5%. The capability is real; the gating is the only thing between it and misuse.

The monitorability regression

This is the most important caveat in the release and it is barely covered anywhere.

Reported. OpenAI’s own system card documents a measurable decline in chain-of-thought monitorability, at the same time as gains in alignment and jailbreak robustness. In evaluations designed to elicit monitoring evasion, Astra’s written reasoning is harder to monitor than Sol’s. Wikipedia’s summary attributes this partly to a “recurrent depth” reasoning approach that obscures some or all of the model’s reasoning.

Assessment. If your safety architecture assumes you can inspect the model’s reasoning trace to catch problems before they reach a user — a common and previously sensible design — that assumption is weaker on Astra than it was on Sol. Move your checks to observable actions and outputs: what tools were called, with what arguments, and what the result was. Behavioural monitoring degrades less than introspective monitoring.

The alignment numbers are genuinely good, and worth stating fairly: 0.0% honeypot cheating on ExploitGym against Sol’s 48.2%, 2.4% on the computer-use safety benchmark against Sol’s 22.0%, 91.5% cyber jailbreak refusal against 59.0%, and internal hallucination down from 12.2% to 4.2% (Reported). The model behaves better. You can just see less of why.

When not to use GPT-6 Astra

An honest list, because “use the best model” is bad engineering advice.

• High-volume simple tasks. Classification, routing, tagging, extraction. The none effort level is gone and the floor price is 2.5× Sol. Use a smaller model.
• Latency-sensitive interactive UI. Reasoning models think before they answer. If a human is watching a cursor blink, this is the wrong tool — and under EU data residency you cannot use the fast or priority tiers at all.
• Pure code generation on a budget. The benchmarks do not show a clear quality win over Claude Fable 5 at the same price, or a large one over Sol at 2.5× the price.
• Audio or video work. Input is text and image only; output is text only. There is no audio path.
• Anything needing post-April-2026 knowledge without search. The cutoff is 30 April 2026. Enable web_search or supply the context.
• Deterministic output via temperature: 0. That parameter is not supported. If you need reproducibility, get it from Structured Outputs and validation, not sampling control.
• Security research tooling, unless you are in Daybreak Blue. You will fight refusals.

A migration checklist

1. Move tool-calling paths from Chat Completions to the Responses API. Non-negotiable — tool calling does not work otherwise.
2. Remove temperature, top_p, top_logprobs and related fields.
3. Map none and minimal effort to low; leave other levels as they are.
4. Replace prompt_cache_retention with prompt_cache_options.ttl: "30m".
5. Set model to gpt-6-astra.
6. Audit prompts for the 272K threshold and model the doubled rate where you cross it.
7. Add explicit no-clarifying-question instructions to unattended agent prompts.
8. Add refusal handling if you are anywhere near security topics.
9. Move reasoning-trace-based safety checks to action-based monitoring.
10. Re-run your evals. Do not assume the published benchmarks describe your workload at your effort level.

What this means for software development

Assessment, clearly labelled as opinion.

The interesting thing about Astra is not that it writes better code — on the evidence, it barely does. It is that the gap between “model that writes code” and “model that operates a computer to get a job done” has closed enough to matter. A 47% reduction in time-per-task on OSWorld, 92.7% on GUI grounding, and 88% single-attempt on SRE-Bench describe a different category of product than autocomplete.

The constraint moving forward is not model capability. It is the scaffolding around it: state that survives a crash, spend ceilings, permission boundaries, and monitoring that works when you cannot read the reasoning. Those are ordinary engineering problems, and they are now the bottleneck.

The monitorability regression is the part I would watch. The industry has spent two years building safety tooling that reads chain-of-thought. If frontier models keep getting harder to introspect while getting more autonomous, that tooling ages badly — and the replacement, rigorous action-level auditing, is something most teams have not built.

Frequently asked questions

What is the GPT-6 Astra API model name?

gpt-6-astra. It is available on v1/responses, v1/chat/completions and v1/batch — but tool calling only works on the Responses endpoint.

How much does GPT-6 Astra cost?

$10 per million input tokens and $50 per million output. Cached input is $1 and cache writes are $12.50. Prompts over 272,000 input tokens are billed at double the input and cache rates. Batch and Flex are half the standard rates.

What is the GPT-6 Astra context window?

1,050,000 tokens total, with a maximum of 922,000 input tokens and 128,000 output tokens. The remainder is reserved for reasoning.

Is GPT-6 Astra better than Claude for coding?

Not clearly. Claude Fable 5 leads narrowly on FrontierCode and the Artificial Analysis Coding Agent Index, at identical pricing. Astra leads decisively on agentic and computer-use benchmarks such as OSWorld, ScreenSpot-Pro and SRE-Bench. Pick by task shape, not by headline.

Does GPT-6 Astra support computer use?

Yes. computer_use is a supported hosted tool, and computer use is the model’s strongest area — 72.6% on OSWorld 2.0 versus 65.7% for GPT-5.6 Sol, at roughly half the time per task.

What reasoning effort levels does GPT-6 Astra support?

low, medium, high, xhigh and max. The none level available on GPT-5.6 is not supported; OpenAI advises moving none or minimal workloads to low.

Can GPT-6 Astra process images and audio?

Images yes, audio no. Input modalities are text and image; output is text only.

Why does GPT-6 Astra refuse security questions?

It is the first OpenAI model classified Critical for cybersecurity capability under the Preparedness Framework. The public version refuses advanced cybersecurity work including proof-of-concept exploit development. Vetted defensive access runs through a separate programme, Daybreak Blue.

What is the GPT-6 Astra knowledge cutoff?

30 April 2026. Use the web_search tool or supply context for anything more recent.

Should I migrate from GPT-5.6 Sol?

If you are building agents that operate computers or browsers, or you need reliable retrieval above 512K tokens, yes. If you are doing chat, extraction, summarisation or straightforward code completion, Sol costs 60% less and the quality gap on those tasks is small.

Working with model output day to day? Our developer tools — JSON and XML compare, JWT decoding, hashing, cron expressions — all run in your browser, so nothing you paste is uploaded anywhere.