Skip to main content
GPT-6 Astra (gpt-6-astra) is the new-generation flagship OpenAI released on September 3, 2026, positioned for computer use, software engineering, science, and long-horizon agent work: 1,050,000-token context, 128,000-token max output, adjustable reasoning effort. APIYI has both the Responses and Chat Completions endpoints open and ran the same 74-check matrix on launch day across three lines: official relay via OpenAI direct, official relay via Azure, and Codex_Reverse.
GPT-6 Astra is live on APIYI: model name gpt-6-astra. The default / svip official-relay groups are priced line for line with OpenAI and are served by two official lines, OpenAI direct and Azure; the Codex_Reverse group (Codex reverse-engineered resources) bills at a 0.5x discount. Function calling and the agent toolchain live only on Responses, so start new projects there.
Chat Completions does not support function tools. A request carrying tools is rejected upstream on the official-relay lines (400, pointing you to Responses), regardless of reasoning_effort or tool_choice. This is a model-side limit, not a platform issue. Existing Chat code that uses function calling has to move to Responses when it moves to Astra.

Why it stands out

Built to finish tasks

Terminal-Bench 4.0 from 37.3% to 57.9%, ScreenSpot-Pro from 76.9% to 92.7%, OSWorld 2.0 at 72.6%. The biggest gains are all agentic; OpenAI reports average completion time on complex tasks dropping from about 75 minutes to 40.

1.05M context, measured

A 308K-character (210,657-token) needle test answered correctly in 10.3 s. OpenAI reports roughly 70% fewer tokens than GPT-5.6 Sol per task, so the real per-task cost gap is smaller than the 2.5x unit-price gap.

Complete Responses toolchain

Function calling passes single, parallel, round-trip, and streaming; the hosted web_search and code_interpreter tools work; encrypted reasoning items replay statelessly. Strict JSON Schema output matched the field set exactly.

Three lines measured, every deviation attributed

The same matrix ran on OpenAI direct, Azure, and Codex_Reverse. Model capability is identical across all three; the deviations are all in the pipeline, and this page labels each as upstream limit, group-specific, or line-specific.

Model information

Measured capability matrix

September 5, 2026, 74 checks per line (the official lines used a 70K-token long-context variant to hold cost down):

Reasoning effort

Same river-crossing puzzle on Responses, reasoning_tokens per line:
Do not send none or minimal. minimal is rejected everywhere (400 on official lines, rewritten to low on Codex_Reverse). none behaves three different ways: 400 on OpenAI direct, accepted on Azure, and on Codex_Reverse rewritten to medium with input_tokens jumping from 14 to 4394 (about 4.2K tokens of hidden instructions injected upstream). The usable levels are low / medium / high / xhigh.
Reasoning tokens bill at the $50 / 1M output rate. Use low / medium for deterministic steps and reserve xhigh for planning and debugging. Read usage from usage.output_tokens_details.reasoning_tokens on Responses or usage.completion_tokens_details.reasoning_tokens on Chat (present on the official lines).

Pricing

Official-relay groups (default / svip)

Two tiers by the input token count of each request; once input passes 272K the whole request bills at tier two, matching OpenAI:

Codex_Reverse group

0.5x the official price: tier one is $5.00 in / $25.00 out / $0.50 cached read / $6.25 cache write.
APIYI matches provider pricing item for item; discounts come through groups and recharge bonuses, see Promotions. Group differences are explained in What is the difference between the Codex, ClaudeCode and Default groups. Live prices are on the model pricing page.

Choosing a group

Examples

Chat Completions endpoint (migrating existing code, no function tools)

Deviation attribution

Running the same matrix on three lines sorts every deviation into one of three buckets.

Upstream limits (identical on all three lines)

Every Chat request carrying tools returns 400 on both official lines, with upstream text telling you to use Responses; omitting reasoning_effort or adding tool_choice: required changes nothing. The Codex_Reverse group passes only because its pipeline converts to Responses internally, so do not treat that as evidence of capability. Use Responses for function calling.
3/3 requests for max echoed xhigh on all three lines. On the official lines max spends clearly more reasoning tokens than xhigh (OpenAI direct 278 to 379 vs 246, Azure 342 to 516 vs 320), so the level may apply with a normalized echo; on Codex_Reverse there is no difference. We promise four levels.
The official lines reject the legacy max_tokens with 400 and ask for max_completion_tokens; temperature returns 400 unsupported, as usual for reasoning models. Codex_Reverse accepts both and ignores them. Strip both when migrating existing code.
All three lines return 400 “Tool ‘computer_use_preview’ is not supported with gpt-6-astra”. The computer-use capability in the launch material is not exposed to the API through this tool type right now.

Codex_Reverse group only (5 items)

Instruction-style and information-style system messages hit 0/3 each; the same content as a developer message hit 3/3; both official lines pass system 3/3. Use developer on Chat, which works on all three lines.
With max_output_tokens: 20, max_tokens: 20, or max_completion_tokens: 20, output was 403 tokens, and Responses echoed max_output_tokens: null. The official lines truncate correctly at 20 with incomplete / length. Use the official-relay groups when caps matter for cost control.
store: true still echoes false, and the second turn returns 200 with no memory of the first; both official lines recall correctly. In this group keep history on the client and pair it with include: ["reasoning.encrypted_content"] for stateless replay (verified on all three lines). GET /v1/responses/{id} returns 503 everywhere.
With an http(s) image link on Chat, prompt_tokens was 15 and the model said it saw no image; the same link works on both official lines. base64 works on both endpoints of all three lines. Send images as base64 on Chat in this group.
none is rewritten to medium and input_tokens rise from 14 to 4394 (4224 attributed to usage.attribution.request_fields.instructions at the cached rate); minimal is rewritten to low. This group also lacks the hosted code_interpreter tool (400).

Azure line only (1 item)

Requests carrying web_search / web_search_preview on the Azure line return 400 with a gateway notice that web_search is temporarily disabled while Azure Bing billing is under review, and that other tools are unaffected. The OpenAI direct line and the Codex_Reverse group work normally. This page will be updated when it is restored.

Migration guide

On Responses, change only the model field. On Chat, anything using tools must move to Responses, and strip max_tokens and temperature. The price is 2.5x Sol’s current promotional rate ($4 / $20 → $10 / $50), so run a head-to-head on agent, automation, and complex engineering tasks first; leave everyday chat, classification, and extraction on Terra / Luna.
messagesinput, reasoning_effortreasoning: {"effort": ...}, response_formattext: {"format": ...}, systeminstructions, max_completion_tokensmax_output_tokens. Tool definitions flatten from {"type": "function", "function": {...}} to {"type": "function", "name": ..., "parameters": ...}. Full mapping in the Responses migration guide.
Once input exceeds 272K tokens the whole request bills at tier two (input doubles, output 1.5x). Unless you genuinely need the whole repo in one shot, keep everyday context under 272K, and put stable prefixes first so they hit the cache (cached reads are one tenth of the standard input price).
Astra is the first model OpenAI has placed at the Critical cybersecurity level of its Preparedness Framework, and the public release refuses offensive tasks such as vulnerability discovery and exploit-code writing. Defensive work is unaffected: on all three lines, a request for engineering practices against SQL injection returned a complete answer covering parameterized queries, least privilege, and more.