OpenAI has released GPT-6 Astra under the API model ID gpt-6-astra. “ChatGPT-6” is a convenient label spreading online, not the official model name. Access is still rolling out: a limited set of organizations received it first, with availability for Plus, Pro, Business, Enterprise, and API users expanding in stages. Not seeing Astra in an account yet does not disprove the release, but neither does the announcement mean every paid account already has it.

The headline specifications resemble GPT-5.6 Sol: both have a 1,050,000-token context window and a 128,000-token maximum output. Astra’s more consequential changes are about how an agent runs. It can continue useful work while a slow tool executes, accept new instructions during an active turn, and change reasoning effort across a conversation without unnecessarily breaking the cached prefix. A model request begins to look less like waiting for an answer and more like coordinating a continuing job.

Know the capability boundary

Astra accepts text and image input and produces text. Its documented knowledge cutoff is April 30, 2026. It does not natively accept audio or video and cannot be fine-tuned. Through the Responses API, it can use functions, Web Search, File Search, Code Interpreter, Hosted Shell, Apply Patch, Skills, Computer Use, MCP, and Tool Search. Support for an image-generation tool does not make images a native output modality of Astra itself.

Reasoning effort ranges from low through medium, high, xhigh, and max. The model does not support none or minimal. Low is the sensible starting point for classification, short conversations, and latency-sensitive workflows. Difficult coding, research, or work across multiple applications can justify higher effort after evaluation. Treating max as a universal quality switch will often buy more latency and tokens than the task needs.

Three changes are built for agents

The first is async tool calling. Marking a function or custom tool with async: true lets Astra issue the call and continue reasoning, use another tool, or finish an independent part of the response while the application runs the slow operation. The application still owns execution. It must persist the original call_id, return the result later, and handle restarts, timeouts, duplicate callbacks, and terminal failure. Async tools improve concurrency; they do not provide a background-job system for free.

The second is mid-turn steering. Over a Responses API WebSocket connection, a user can add a requirement such as “use the audited data source” or “do not change the database” while the model is working. An accepted steering event only means the instruction was queued. It does not retract text already shown, undo an action, or cancel a tool already running. Payments, deletions, messages, and deployments still need approval before execution.

The third is configuration_update. A long conversation can use lower effort for routine steps and raise the level for a difficult follow-up while keeping the original request-level setting stable for prompt caching. This feature has restrictions around single-agent operation, compaction, truncation, and history layout. The application must model those states deliberately.

The price behind a 1.05M context window

Standard API pricing is $10 per million input tokens, $1 for cached input, $12.50 for cache writes, and $50 for output. Once input exceeds 272K tokens, the entire request is charged at twice the input and cache rates and 1.5 times the output rate. The multiplier does not apply only to tokens above the threshold. Batch and Flex generally cost half of Standard, while Fast costs twice the applicable rate. Search, computer use, and other tools may add separate charges.

The 1.05M window is capacity, not a target for every turn. Stable system instructions, tool definitions, and document prefixes should be arranged for cache reuse. Older conversation material should be retrieved, summarized, or compacted rather than replayed without limit. OpenAI reports that Astra completes some evaluations with fewer output tokens than earlier models, potentially lowering cost per completed task despite higher token prices. That is a vendor result. A real bill still depends on context length, cache writes, tool calls, retries, and human repair.

Start with the Responses API

Install the current SDK and provide the API key through the environment:

pip install -U openai

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    reasoning={"effort": "medium"},
    input=(
        "Review this deployment plan. Identify rollback gaps, "
        "then return a prioritized checklist."
    ),
)

print(response.output_text)

OpenAI recommends the Responses API for applications that use tools. Chat Completions can remain a text-compatibility path, but the two endpoints should not be assumed to expose an identical agent runtime.

Migration requires more than a new model string

If an older configuration uses none or minimal, begin Astra evaluation at low. Remove unsupported parameters such as temperature, top_p, and top_logprobs. Move tool execution to the Responses API and replace older cache settings with prompt_cache_options. Then run a fixed evaluation set that measures factual errors, schema compliance, function arguments, duplicate tool calls, unauthorized actions, tokens, tool fees, and end-to-end time.

Astra’s token prices are 2.5 times those of GPT-5.6 Sol. A stronger model may still reduce the total price of a successful task by avoiding retries and human rework. It can also become dramatically more expensive when a product combines oversized context with unnecessarily high reasoning effort. “Cost to complete one accepted task” is the useful metric; intelligence per response is not a budget.

My assessment

GPT-6 Astra’s enduring contribution may be the ability to coordinate agents in real time. Async tools prevent every slow dependency from blocking the plan. Steering lets a person correct an active job without throwing away all completed work. Dynamic reasoning effort gives an application a finer control over cost and difficulty. Those interface changes may matter longer than a temporary benchmark lead.

Astra is still in phased rollout, its native modalities are limited, long context has a sharp pricing threshold, and safety monitoring may pause legitimate work. A careful adoption starts with low-volume trials in research, coding, and cross-tool workflows, keeps confirmation gates in front of irreversible actions, and expands only after successful-task cost is stable. GPT-6 Astra has arrived, but the new experience depends on combining the model with a durable agent state machine and explicit permissions.