GPT-6 Astra is out: price, 1M context, and real-world use

OpenAI released GPT-6 Astra on September 3, 2026 — in its own words, "our most capable model, built for the hardest end-to-end work." The model ships with a 1.05 million token context window, $10/$50 pricing (input/output, per 1M tokens), and new async tool calling plus mid-turn steering capabilities. In this piece I walk through GPT-6 Astra's actual price math, how it differs from the GPT-5.6 family, and when you should pick which model — all grounded in primary sources.

💡 Pro Tip: Astra's $10/$50 pricing isn't fixed — prompts exceeding 272,000 tokens get the ENTIRE request billed at 2x input/1.5x output rates. Plan your cost model around this threshold for long-context work, or the bill will surprise you.

Table of Contents

• GPT-6 Astra at a glance (date, price, limits)
• Price math: the real cost of input/output/cache
• Difference from GPT-5.6 Sol/Terra/Luna
• Responses API and the tool surface
• What async tool calling + mid-turn steering change
• Async tool calling
• Mid-turn steering
• Misalignment monitoring
• When to use Astra, when Terra/Luna
• Access, quotas, and cost control
• FAQ
• When did GPT-6 Astra launch and what does it cost?
• What's the difference between GPT-6 Astra and GPT-5.6 Sol?
• How many tokens are GPT-6 Astra's context window and output limit?
• For which jobs is GPT-5.6 Terra enough instead of GPT-6 Astra?
• Can I set `temperature` or `top_p` on Astra?
• Will my old Chat Completions code work with Astra?
• Conclusion
• Sources

GPT-6 Astra at a glance (date, price, limits)

GPT-6 Astra's model ID is gpt-6-astra, and the official model page lists these core numbers:

These numbers matter because, in terms of context window size, Astra shares exactly the same limits with the GPT-5.6 family (Sol/Terra/Luna) — 1.05M context, 922K input, 128K output. The real differences lie in reasoning depth, price, and two new behavioral features: async tool calling and mid-turn steering. The knowledge cutoff is also a notable detail: April 30, 2026 is roughly 10 weeks fresher than the GPT-5.6 family's February 16, 2026 cutoff.

Astra's reasoning effort levels come in five tiers: low, medium, high, xhigh, max. But note — unlike the GPT-5.6 family, Astra does not support the none reasoning effort level. So even a simple classification request still costs the model at least some reasoning. On top of that, Astra doesn't support custom temperature, top_p, or logprobs output either — a real constraint if you fine-tune behavior with those classic parameters.

Price math: the real cost of input/output/cache

The raw price table alone can be misleading. Three rules govern Astra's actual cost behavior:

1. The 272K threshold triggers a whole-request multiplier. For prompts exceeding 272,000 tokens, input and cache rates jump to 2x and the output rate to 1.5x — and this multiplier applies not just to the portion above the threshold but to the entire request. So if you send a 300K-token prompt, even the part under 272K gets priced at 2x.
2. Cache-write costs 1.25x the uncached input price. At $12.5/1M, cache-write adds a premium on top of the normal $10 input price — worth factoring in for frequently repeated long system prompts.
3. OpenAI's own claim: fewer output tokens = lower cost per task. The official model guide states that Astra delivers "stronger results while using significantly fewer output tokens" than prior models, so even though it's more expensive per token, the estimated API cost per task can be lower. This is OpenAI's own assessment — read it as vendor positioning, not an independently verified benchmark.

A simple cost calculator example:

1# Astra price calculator (simplified)
2INPUT_PRICE = 10 / 1_000_000
3OUTPUT_PRICE = 50 / 1_000_000
4LONG_CONTEXT_THRESHOLD = 272_000
5 
6def estimate_cost(input_tokens: int, output_tokens: int) -> float:
7    if input_tokens > LONG_CONTEXT_THRESHOLD:
8        input_cost = input_tokens * INPUT_PRICE * 2
9        output_cost = output_tokens * OUTPUT_PRICE * 1.5
10    else:
11        input_cost = input_tokens * INPUT_PRICE
12        output_cost = output_tokens * OUTPUT_PRICE
13    return round(input_cost + output_cost, 4)
14 
15# 300K input + 5K output: threshold crossed, ENTIRE request at 2x/1.5x
16print(estimate_cost(300_000, 5_000))  # -> 6.375
17# 200K input + 5K output: below threshold, normal pricing
18print(estimate_cost(200_000, 5_000))  # -> 2.25

The example above compares 300K vs 200K input, so both the threshold multiplier and the 100K extra-input difference are in play — but the truly striking part is this: crossing the threshold by a single token (272,000 → 272,001) exactly doubles the input cost — not a gradual increase, but a sudden jump. When analyzing a long document or a large codebase, consciously managing this threshold — splitting the request if needed — is a practical cost-control strategy.

Difference from GPT-5.6 Sol/Terra/Luna

To understand GPT-6 Astra you first need to know where the GPT-5.6 family stands. The family has three general-purpose models: Sol (flagship), Terra (balanced), and Luna (cost-focused) — plus a GPT-5.6 Cyber reserved for authorized security research, though the price/use comparison in this piece runs on the general-purpose trio.

(GPT-5.6 Sol's $4/$20 price is a promotional discount announced on August 21, 2026, valid through at least November 21, 2026 — a campaign independent of this Astra launch.)

All four models share the same 1.05M context / 922K max input / 128K max output limits — so "1M context" marketing isn't an Astra-specific advantage. The real differentiators:

• Reasoning effort flexibility: the GPT-5.6 family supports the none level (you can turn reasoning off entirely); Astra doesn't.
• Knowledge freshness: Astra's April 30, 2026 cutoff is ~10 weeks newer than GPT-5.6's February 16, 2026 cutoff.
• Two new features only on Astra: async tool calling and mid-turn steering (details below).
• Big price gap: Astra costs 5x Terra's and 50x Luna's input price.

1# Model selection in the Responses API (curl example)
2curl https://api.openai.com/v1/responses \
3  -H "Authorization: Bearer $OPENAI_API_KEY" \
4  -H "Content-Type: application/json" \
5  -d '{
6    "model": "gpt-6-astra",
7    "reasoning": { "effort": "high" },
8    "input": "Bu kod tabanındaki race condition riskini analiz et."
9  }'

You can swap the model field for gpt-5.6-terra or gpt-5.6-luna to try different cost/performance points with the same request shape — the Responses API schema is identical across all four models.

OpenAI's own launch post evaluations back up this gap: in the latency-simulated OSWorld 2.0 computer-use test, Astra scores 72.6% (Sol 65.7%, at ~40 minutes per task vs ~75 minutes), and on the ExploitBench test measured without production safeguards, Astra reaches 100% (Sol 78.5%). From a separate source, Artificial Analysis's AA-Omniscience Index — which measures knowledge reliability and hallucination on a -100 to 100 scale where higher is better — gives Astra 43.4 versus GPT-5.6 Sol's 22.0 (both measurements taken on the models' max effort variant). Since the OSWorld 2.0 and ExploitBench figures are OpenAI's own marketing evaluation, they should be read as vendor positioning rather than official independent verification.

Responses API and the tool surface

Astra's tool calling works only via the Responses API. If you're using tools with Chat Completions, you'll need to follow the Responses migration guide before moving to Astra — it's worth knowing upfront that the old integration won't just work as-is.

The supported tool set is fairly broad:

• web_search: live web search
• file_search: search within documents/files
• image_generation: image generation tool (the model itself doesn't generate images — this is a tool)
• code_interpreter: code execution sandbox
• hosted_shell: hosted shell access
• apply_patch: applying file/code patches
• skills: predefined capability packages
• computer_use: screen/desktop interaction
• mcp: Model Context Protocol integration
• tool_search: search across a large tool catalog

On the other hand, Astra does not support these endpoints: Realtime, Assistants, Fine-tuning, Embeddings, image/video generation endpoints, and audio endpoints. Only the Chat Completions, Responses, and Batch APIs are supported. This shows that Astra is a text-and-image-INPUT, text-only-OUTPUT reasoning-and-tool model, not a multimodal generation model — image/audio generation still requires a separate model.

1{
2  "model": "gpt-6-astra",
3  "tools": [
4    { "type": "code_interpreter" },
5    { "type": "web_search" },
6    { "type": "mcp", "server_label": "example", "server_url": "https://example.com/mcp" }
7  ],
8  "input": "Depodaki test dosyalarını tara ve eksik test kapsamını raporla."
9}

Being forced onto the Responses API also opens the door to new features like async tool calling and mid-turn steering — we look at those in the next section.

What async tool calling + mid-turn steering change

The two mechanisms that arrived with Astra on September 3 genuinely change behavior in agent-type work.

Async tool calling

When you add async: true to a tool definition, the model can keep thinking, call other tools, or produce output for independent parts of the request without waiting for that tool's result. Important detail: OpenAI does not take over background job management — your own application still runs the tool, and it's on you to match the result to the original call_id and send it back to the model.

1// Async tool definition example (Responses API, TypeScript)
2const tools = [
3  {
4    type: "function",
5    name: "run_long_analysis",
6    async: true,
7    parameters: {
8      type: "object",
9      properties: { repoPath: { type: "string" } },
10      required: ["repoPath"],
11    },
12  },
13];
14 
15// The model won't block on this tool call immediately;
16// feed the result back with the same call_id once it's ready:
17async function sendToolResult(callId: string, output: unknown) {
18  return fetch("https://api.openai.com/v1/responses", {
19    method: "POST",
20    headers: {
21      Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
22      "Content-Type": "application/json",
23    },
24    body: JSON.stringify({
25      model: "gpt-6-astra",
26      previous_response_id: "resp_abc",
27      input: [{ type: "function_call_output", call_id: callId, output }],
28    }),
29  });
30}

Mid-turn steering

Steering is available only on Astra, and only via the Responses API over a WebSocket connection — GPT-5.6 and earlier models don't support it. You can send additional instructions to an in-progress response via a response.steer event; the API confirms it with response.steer.accepted. But note: "accepted" means "queued," not a guarantee the model will act on it.

Critical boundary: steering cannot undo output already sent to the application, cannot cancel prior actions, and cannot stop tool calls already in progress. So this isn't a "live editing" feature — it's a mechanism for steering the rest of an ongoing turn.

Also, with the configuration_update input item, you can raise or lower reasoning effort mid-conversation without breaking the original prompt prefix (and therefore the cache advantage) — but only on Astra, and only in standard single-agent mode. The item is appended to the input array before the next user message without changing the request-level reasoning.effort; the request-level value stays the same (the cache prefix isn't broken), and only the next response (and subsequent ones, until overridden) uses the new effort:

1{
2  "model": "gpt-6-astra",
3  "previous_response_id": "resp_abc",
4  "reasoning": { "effort": "low" },
5  "input": [
6    {
7      "type": "configuration_update",
8      "reasoning": { "effort": "xhigh" }
9    },
10    {
11      "role": "user",
12      "content": "Bu değişikliğin geriye dönük etkilerini analiz et."
13    }
14  ]
15}

You can raise effort when a hard subtask comes up and lower it again for a routine follow-up — without rewriting the cached prefix.

Misalignment monitoring

Alongside this new degree of freedom, Astra ships with an asynchronous "misalignment monitoring" system for agent work: it inspects the model's reasoning and actions (in critical contexts like sensitive data transfer, sensitive data access, or destructive changes) and can halt the conversation if it detects a problem. But this only works automatically under certain conditions: Responses API requests using persisted reasoning, WebSocket mode, or OpenAI compaction can be monitored and auto-stopped; Responses requests that don't use these mechanisms only produce a webhook alert (no auto-stop); Chat Completions requests are outside this system's scope entirely. A blocked request returns HTTP 403 with error code misalignment_policy_violation before streaming starts, and the API offers no general way to resume a halted conversation — since monitoring runs asynchronously, an action may already have completed before the problem is detected.

When to use Astra, when Terra/Luna

The price gap is stark: Astra is $10/$50 while Terra is $2/$12 and Luna is $0.2/$1.2 — a 5x to 50x difference on the input side. OpenAI's official positioning is clear: Astra is recommended for "the hardest end-to-end work," Terra for "balancing intelligence and cost," and Luna for "cost-sensitive, high-volume workloads."

In practice, the decision points can be summarized as:

• If you need async tool calling or mid-turn steering → Astra is mandatory, because these two features only exist there. In long, multi-step agent tasks that may require user intervention, this alone can be decisive.
• Simple classification, summarization, high-volume routine work → Terra or Luna. With none reasoning effort you get near-instant, very cheap responses — that option doesn't exist on Astra.
• Long-context work above 272K → note: all three models are subject to the same 2x/1.5x multiplier. So Astra's cost disadvantage stays proportional even at large context, it doesn't shrink. The "use the cheap model" logic for long context still holds for Terra/Luna too.
• Everyday coding and standard reasoning work → per official pricing, Terra costs half of Sol's input and ~40% less on output ($2/$12 vs $4/$20) — sufficient, in my observation, for most production work. OpenAI's model selection guide gives no per-model decision matrix; it recommends "fix your accuracy target first, then step down to the cheapest/fastest model that preserves it" — the recommendation above is my own application of that principle, not an absolute rule.

My general recommendation: plan to prefer Astra for computer-use or multi-step agent orchestration work where fault tolerance is low; for routine work like everyday code review or documentation generation, start with Terra and upgrade if needed. I covered this approach in more detail in my LLM benchmarks guide.

Astra's reasoning-heavy nature can be seen as a natural continuation of the first major reasoning leap that came with GPT-5 — but the removal of the none option means some of that earlier flexibility has been traded away.

Access, quotas, and cost control

Official changelogs and model pages show no region-specific access restriction for Astra; access works through the standard API key and the same pricing. The August 21, 2026 changelog entry mentions an option called "regional processing," selectable per-request in projects with the Global geography setting — but this is a general platform feature, not an Astra-specific restriction.

The real practical limit is on the quota side: Astra's standard rate-limit table scales up with your usage tier. At Tier 1 you start at 500 RPM / 500,000 TPM; by Tier 5 that rises to 15,000 RPM / 40,000,000 TPM. When integrating Astra into a new project, checking which tier you're on first — combined with the 272K threshold — helps avoid unexpected rate-limit errors.

Concrete, sourced recommendations for cost control:

1. Manage the 272K token threshold deliberately. Cross it and the bill automatically jumps 1.5-2x — split long document/codebase analyses into chunks below this limit where possible.
2. Adjust effort dynamically with `configuration_update`. Raise effort when work gets harder, lower it for routine follow-ups, without breaking the cache.
3. Route routine work to Terra/Luna, and reserve Astra only for genuinely "hard end-to-end" work. The price gap (5-50x) makes this distinction economically necessary.
4. Account for cache-writes. For frequently repeated long system prompts, the $12.5/1M cache-write cost can contribute more to the total bill than expected.

1# A simple token-threshold warning script (bash + jq)
2INPUT_TOKENS=$(echo "$REQUEST_JSON" | jq '.usage.input_tokens')
3if [ "$INPUT_TOKENS" -gt 272000 ]; then
4  echo "UYARI: 272K eşiği aşıldı — istek 2x/1.5x fiyatlanacak."
5fi

Adding a simple check like this to your CI/CD or agent orchestration layer is the easiest way to prevent surprise bills.

FAQ

When did GPT-6 Astra launch and what does it cost?

OpenAI released GPT-6 Astra on September 3, 2026. API pricing is $10 per 1M input tokens, $1 for cached input, $12.5 for cache-write, and $50/1M for output — but for prompts over 272,000 tokens, input+cache is billed at 2x and output at 1.5x, and this multiplier applies to the entire request.

What's the difference between GPT-6 Astra and GPT-5.6 Sol?

Both models share the same context window (1.05M), the same output ceiling (128K), and the same 272K long-context threshold. The real differences: Astra's knowledge cutoff (April 30, 2026) is about 10 weeks fresher than Sol's (February 16, 2026), the none reasoning effort option has been removed on Astra, and async tool calling plus mid-turn steering are only available on Astra. On price, Astra also costs 2.5x Sol's input/output cost ($10/$50 vs $4/$20).

How many tokens are GPT-6 Astra's context window and output limit?

The total context window is 1,050,000 tokens, of which a maximum of 922,000 can be used as input, with an output limit of 128,000 tokens. These figures appear verbatim on the official model page.

For which jobs is GPT-5.6 Terra enough instead of GPT-6 Astra?

Terra is the mid-tier model between Sol and Luna; per official pricing it runs at $2/$12 (per 1M tokens) — half of Sol's input cost and ~40% cheaper on output ($4/$20). In my observation, Terra is sufficient on cost/performance grounds for most everyday production work — outside computer-use, multi-step agent orchestration, or research/code work needing the highest accuracy. OpenAI's model selection guide gives no per-model decision matrix — it only recommends fixing your accuracy target first, then stepping down to the cheapest/fastest model.

Can I set `temperature` or `top_p` on Astra?

No. Astra doesn't support custom temperature, top_p values, or logprobs output. Old integrations relying on these parameters need to be updated when moving to Astra.

Will my old Chat Completions code work with Astra?

Code that uses tool calling won't work — Astra's tool calling is only supported via the Responses API. Simple completion requests without tools are still supported on Chat Completions, but you'll need to move to the Responses API to take advantage of new features (async tool calling, mid-turn steering).

Conclusion

GPT-6 Astra is OpenAI's new flagship model, positioned for "the hardest end-to-end work" — but its $10/$50 price and 272K threshold multiplier don't automatically make it the right choice for every job. The real decision point is whether you need async tool calling and mid-turn steering: if you do, Astra is mandatory; if not, GPT-5.6 Terra or Luna are both sufficient and far cheaper for most routine work.

To see Astra's reasoning-heavy approach in a broader context, you can check out the first major reasoning leap that came with GPT-5 and OpenAI's o3/o4 reasoning models. If you want to back your model choice with benchmark data, my 2026 LLM benchmark comparison and the Grok vs Claude vs GPT-5 real-world comparison will be useful. To understand caching logic in more depth, you can also check out Claude's prompt caching guide — the logic is similar, the implementation details differ. When taking Astra's async/agent capabilities to production, my agentic AI tool-use and planner-loop guide can be a practical starting point.

Sources

• OpenAI Changelog — GPT-6 Astra launch announcement, async tool calling and mid-turn steering feature notes (September 3, 2026)
• GPT-6 Astra Model Page — official pricing, context window, supported tools and endpoint list
• GPT-6 Astra Usage Guide — Astra's cost-efficiency claim, summary of new features
• OpenAI Model Selection Guide — accuracy-first/cost-second principle, doesn't give a per-model decision matrix
• Reasoning Models Guide — mid-conversation effort changes via configuration_update, reasoning effort table
• Async Tool Calling Guide — async: true tool definition and call_id matching mechanics
• Mid-turn Steering Guide — steering over WebSocket, limitations
• GPT-5.6 Sol Model Page — price, knowledge cutoff, reasoning effort options
• GPT-5.6 Terra Model Page — price and limit comparison
• OpenAI — GPT-6 Astra Launch Post — OSWorld 2.0 and ExploitBench evaluation figures, latency-simulated and safeguard-free test conditions
• Artificial Analysis — GPT-6 Astra vs GPT-5.6 Sol — AA-Omniscience Index comparison (max effort variants; independent third-party measurement)