How Strong Is GPT-6 Astra? Features, Capabilities, API, JSON Output, and a ChatGPT Guide

Quick overview

Item	As of 2026-09-03	What it means for developers
Model ID	gpt-6-astra; there is also an Astra Pro tier	Use this ID on new projects; tool calling goes through the Responses API
Window / price	1.05 million tokens (~922k input + 128k output); standard price $10 / $50 per million	Inputs over 272k surcharge the whole request; only cached prefixes pay off
JSON	Official default for new projects is Structured Outputs	text.format.json_schema plus host-side validation again

Launch day went first to Daybreak / Trusted Access; Plus, Pro, Business, Enterprise, API, AWS, and Azure follow “in the coming days.” Free ChatGPT is not on the list. Numbers will change; treat developers.openai.com as source of truth.

What GPT-6 Astra is, and when you can use it

Astra is the GPT-6 flagship. It retires the GPT-5.6 Luna / Terra / Sol split. Knowledge cutoff is April 30, 2026. Input is text and images; output is text. Official copy calls it the “smartest and most aligned” model: better at finishing multi-step work, and more willing to stop and ask when instructions are unclear.

Rollout is staggered. September 3 went first to cybersecurity-oriented Daybreak and Trusted Access enterprises; the following days add ChatGPT Plus / Pro / Business / Enterprise, plus the API, Codex, AWS, and Azure. Enterprise workspaces are off by default—an admin has to turn it on. Free ChatGPT does not get Astra. Pro / Business / Enterprise also get Astra Pro, with higher reasoning effort.

It is also the first model tagged at OpenAI’s “critical cybersecurity capability threshold”: the company believes it can find and exploit vulnerabilities in hardened systems with almost no step-by-step human direction. Full offensive capability stays inside Daybreak (Blue / Red); the public version adds tighter refusal boundaries and asynchronous misalignment monitoring. If you write agents, remember: the model is more willing to finish the job on its own—and that makes host-side Schema, permissions, and approvals more necessary, not less.

Brockman’s “AGI era” is keynote language. The same day’s System Card also says chain-of-thought monitorability dropped versus GPT-5.6 Sol. Both sentences come from OpenAI; read them together. This article does not argue AGI. It only covers what you can wire into a pipeline.

Features and capabilities: where it is strong, where it is not

Official materials stress five areas: computer use, browsing, software engineering, science, and professional documents (sites you can actually stand up and run, plus more complete docs, spreadsheets, and decks). If you run JSON pipelines, the more useful claim is that it walks the “pick a tool → call the tool → return an object” chain more reliably, and on several evals finishes the same job with fewer output tokens.

Numbers from the launch materials (all OpenAI’s 2026-09 framing; different scaffolds will move the score):

• FrontierMath Tier 4 v2 97.6%; GPQA Diamond 96%; DeepSWE v1.1 74.1% (113 long-horizon engineering problems, five languages).
• ARC-AGI-3: 62.7% on the ARC Prize standard scaffold, 99.9% on the OpenAI Provider Adapter. Same model, a 37-point gap—the difference is mostly memory and context compression, not “a new name made it smarter.”
• Versus GPT-5.6 Sol: SRE-Bench reverse 99.2% pass@4 (Sol 68.7%), about a quarter of the output tokens; Sandbox Bench solved 10 of 22 targets (Sol: 1).

Weak spots are equally specific. On fully hardened targets, independent lab Irregular saw 0 successful attacks. Open-ended experimental-protocol Q&A (ProtocolQA Open-Ended) is 41.36%, below the PhD 80th percentile of 54%. In the UK AISI supply-chain simulation: without a written scope limit, 60 of 499 runs went out of bounds; with an explicit limit, 2 of 500. Scaffold and constraints are worth more than a leaderboard percentage.

Official docs also list new runtime capabilities. This is the “actually nicer to use than last gen” part:

1. Async tool calling. Set async: true on a function / custom tool. The model can keep reasoning, call other tools, or answer the independent slice first; your app fills results back in by the same call_id.
2. Mid-turn steering. While the model is still working, you can push a correction or a changed requirement over WebSocket; the Responses API keeps what already finished and folds the update into the continuation.
3. Change reasoning effort mid-conversation. Raise or lower reasoning.effort with a configuration_update input item. You do not have to rewrite the whole prompt prefix, so the cache still hits.
4. Misalignment monitoring. The system watches tool traffic asynchronously and alerts when needed. This is not the validator in your app. It does not replace Schema.

Everything GPT-5.6 already had is still there: computer use, Structured Outputs, streaming, Programmatic Tool Calling, multi-agent, prompt caching, persisted reasoning, compaction, pro mode. The limits are also written down: none reasoning is not supported; EU data residency has no Fast mode and no service_tier: "priority". Fast mode itself has no latency SLA.

API: which endpoint to use, which parameters to change

On new projects, set model to gpt-6-astra and use the Responses API. Chat Completions still works, but tool calling must use Responses. That matches the direction we wrote in DevDay 2026 predictions: production agents have already converged on Responses + the Agents SDK, and the Assistants API retired on August 26.

A minimal request looks like this:

{
  "model": "gpt-6-astra",
  "input": [
    { "role": "user", "content": "把这段工单分类，只返回 JSON。" }
  ],
  "reasoning": { "effort": "low" }
}

When you migrate from GPT-5.x, start with this list:

• Reasoning effort. If you currently use none / minimal, switch to low first and compare. Keep the other effective tiers you already use. Responses uses reasoning.effort; Chat Completions uses reasoning_effort. Options: low, medium, high, xhigh, max.
• Removed parameters. Drop temperature, top_p, top_logprobs. On Chat Completions also drop logprobs; on Responses, stop include-ing message.output_text.logprobs.
• Caching. When you migrate from GPT-5.5 or earlier, replace prompt_cache_retention with prompt_cache_options.ttl, e.g. "30m". Do not flip request-level reasoning.effort back and forth—use configuration_update so the prefix can still hit cache.
• Tools. Use Responses tools[]. Prefer async tools for long jobs so a whole reasoning stretch is not stuck on one HTTP round trip.

Pricing (standard tier, per million tokens, 2026-09-03): input $10, cache read $1, cache write $12.50, output $50 (including reasoning tokens). Once input crosses 272,000, the whole request is billed at 2× input and 1.5× output. Batch / Flex are about half of standard; Fast is about 2×. A prefix you cache once and never reuse costs more than not caching ($12.50 vs $10). Stuff the whole repo into one request and also cross 272k, and the bill nearly doubles. Treat 272K as a hard budget in the orchestration layer. That is more reliable than hoping the model will save tokens for you.

Official notes also say: Astra asks more questions, follows instructions more closely, prefers lists and tables, and tests more often on coding tasks. If you want it to finish the job itself, write in the system prompt that the default is to act—produce a reviewable result first, then ask. Otherwise it will stall on “should I continue?” Conflicting instructions in skill files and AGENTS.md bother it more than the last generation—audit those files before you blame the model for “not listening.”

JSON output: Structured Outputs is the default, not “please return JSON”

OpenAI’s structured-outputs docs are blunt: new projects start with gpt-6-astra. Structured Outputs guarantees the output matches the JSON Schema you supply—missing required keys and invented illegal enums should not happen, per the docs. What it adds over JSON mode is Schema conformance, not merely “this is valid JSON.” On the Responses API the hook is text.format.

The REST shape looks like this (the same fields as the official math-tutor example, swapped for ticket triage):

{
  "model": "gpt-6-astra",
  "input": [
    { "role": "system", "content": "只按 Schema 分类，不要散文。" },
    { "role": "user", "content": "订单 A-1042 迟到两天，用户要退 99 元。" }
  ],
  "text": {
    "format": {
      "type": "json_schema",
      "name": "ticket_triage",
      "strict": true,
      "schema": {
        "type": "object",
        "properties": {
          "intent": { "type": "string", "enum": ["refund", "exchange", "human"] },
          "order_id": { "type": "string", "pattern": "^A-[0-9]{4,}$" },
          "amount": { "type": "number", "exclusiveMinimum": 0 },
          "confidence": { "type": "number", "minimum": 0, "maximum": 1 }
        },
        "required": ["intent", "order_id", "amount", "confidence"],
        "additionalProperties": false
      }
    }
  }
}

The Python SDK can use Pydantic + responses.parse; the result is in output_parsed. JS uses Zod + zodTextFormat. A safety refusal may not match the Schema; the response will carry a refusal field—the host must check that before JSON.parse.

Two old facts have not changed, and a stronger Astra will not do them for you:

• strict: true only constrains the model side. Tool arguments can still be a string. The host still parse → validate → execute. We wrote this in Why AI Agents Now Need JSON Schema: without host validation, change the snapshot or turn off strict and the contract disappears.
• Tool results and handoffs need a Schema too. Astra is better at continuing on its own, so a bad shape is more likely to be treated as fact by the next hop. Document all four layers—inputs, outputs, handoffs, and checkpoints—instead of only writing “please return JSON” in the system prompt.

When you debug nested JSON the model emitted, first format and syntax-check it locally in the browser, then Diff it against last week’s working Schema. Do not paste responses that contain user data or secrets onto a public JSON site.

ChatGPT guide: pick the model, write the task, collect JSON

The product surface and the API are not the same pipe. In ChatGPT, Astra burns paid-tier quota; if you need a stable Schema, you still end up on the API. For the first few days after launch, this is a usable playbook.

1. Confirm your tier can see it. Plus gets standard Astra and spends the existing quota; Pro / Business / Enterprise can see Astra Pro. If the workspace is Enterprise, ask an admin whether it is on. The model picker should show GPT-6 Astra, not still GPT-5.6 Sol. If it is missing, do not rewrite production prompts yet. Wait for rollout.

2. Treat it as an executor, not a search box. Official copy says it is better at finishing multi-step work: stand up a site, change a repo, produce docs and tables. Write the goal, the definition of done, and the boundaries it must not touch (prod databases, secrets, outbound sends). It defaults to asking questions; if you want it to act first, say so: “Give me a reviewable draft first, then ask about the irreversible step.”

3. When you want JSON, paste the Schema into the chat. ChatGPT does not have Responses-style hard constraints. The minimum that works:

只输出一个 JSON 对象，不要 Markdown 围栏，不要解释。
必须符合：
{
  "type": "object",
  "properties": {
    "intent": { "enum": ["refund", "exchange", "human"] },
    "order_id": { "type": "string" },
    "confidence": { "type": "number" }
  },
  "required": ["intent", "order_id", "confidence"],
  "additionalProperties": false
}

After you copy the result, format it locally and check it against the Schema. “Looks like JSON” in the chat is not enough; field types, enums, and extra keys all have to pass a validator. The same Schema can later go into the API’s text.format without a rewrite.

4. Treat long context as a budget, not a dumpster. A 1.05 million token window does not mean you should paste the whole repo and a year of tickets. On the ChatGPT side you cannot see the 272K surcharge line, but the longer the paste, the more it will wander into irrelevant detail. Retrieve first, then paste the relevant files. To compare two JSON versions, use a local Diff—do not ask the model to “say what changed from memory.”

5. Safe defaults. Do not paste secrets, cookies, or customer PII into ChatGPT. Astra’s network and tool abilities are stronger, so going out of bounds costs more. The official System Card includes a simulated incident of “give the assistant full permissions and turn off step-by-step approval.” The smallest human-side defense: least privilege, confirm irreversible actions, treat tool results as untrusted input.

6. When you use it with Codex / agents. Official docs suggest $openai-docs migrate this project to GPT-6 Astra as a migration prompt. “Ask first, then act” in skill files will stop it more often. Change the skills; do not paste the same warning into every turn.

Developer checklist: stabilize the JSON contract before you switch to Astra

When the model generation changes, the expensive failure is “the prompt still runs; object shape is luck.” A few things you can do immediately, independent of rollout:

• Pin schemas/tools/, schemas/handoffs/, and schemas/outputs/ in the repo. Every file gets an $id and a version.
• Export the same Schema as Function Calling parameters, MCP inputSchema, and Responses text.format. Do not hand-write a second “almost the same” definition for Astra. Protocol differences: MCP Tool Schema vs Function Calling and A2A Extensions.
• In CI, run ajv (or an equivalent) on examples, historical fixtures, and redacted production samples. When Astra’s snapshot changes, Diff Schema and fixtures first, then touch the prompt.
• Default new objects to additionalProperties: false and an explicit enum. Put open extension in a separate metadata field.
• Hard limits in the orchestration layer: per-request input budget under 272K; cache only system prefixes you will reuse; change reasoning effort with configuration_update, not the request-level field.
• Inspect secret- or user-bearing payloads only in the browser: format, Diff, zero upload.

How to write the keywords is still in the JSON Schema tutorial. Astra did not invent a new field language; it only makes Schema-violating output rarer and “just keep going” more common. The more stable the contract, the cheaper the upgrade.

Common pitfalls

• Treat “the AGI era” as a buying reason. Pick models on task completion, tokens, latency, and out-of-bounds rate. Keynote sentences do not belong in an RFC.
• Assume Chat Completions plus gpt-6-astra can call tools. Tool calling needs Responses. Chat-only can stay put for now.
• Keep sending temperature. The docs say drop it. Leave it in and it is ignored at best, or the whole request fails.
• Treat the 1.05 million window as a free lunch. After 272k the whole request surcharges; a cache write costs more than no cache. Long context is a capability and a bill.
• Ask ChatGPT for JSON and call it a production contract. The product surface has no strict. Production uses the API plus host validation.
• Turn off host validation because “Astra listens better.” Listening better means it is better at passing a bad shape to the next hop. Monitoring is OpenAI’s; the gate is yours.
• Turn on Fast / priority under EU residency. Astra does not support that. Use Standard.

FAQ

Can I use Astra on free ChatGPT right now?

No. The public list is Plus, Pro, Business, Enterprise, plus API / Codex / cloud vendors, and rollout is day by day. If it is not in the picker, your account is not in the wave yet.

What is the difference between GPT-6 Astra and Astra Pro?

Astra is the standard flagship; Plus uses this tier. Astra Pro is for Pro / Business / Enterprise—higher reasoning effort, more expensive. The API docs’ model ID is gpt-6-astra; treat the Pro-tier ID as whatever actually appears on your account.

If I only need JSON, do I still need Structured Outputs?

Yes. JSON mode only guarantees valid JSON; Structured Outputs guarantees keys, types, and enums. Official guidance for new projects is the latter. The host should still re-validate against the same Schema.

Will pricing change soon?

Yes. Numbers here are the 2026-09-03 standard tier: $10 / $50 per million, cache read $1, write $12.50, surcharge after 272K. Open the official Pricing page before you buy.

How do I debug bad JSON Astra emitted?

Check for a refusal first, then format locally, compare against the Schema for a missing required or an out-of-enum value, then Diff against the previous version. JSONSort does not upload data. Do not paste secret-bearing responses onto a public site.

Conclusion

GPT-6 Astra is strong at finishing long jobs: engineering, computer use, browsing, professional documents, and reasoning that spends fewer output tokens. It is weak where “change the scaffold and the score moves,” it still cannot punch through fully hardened targets, and the chain of thought is harder to watch. For JSON developers the upgrade list is short: switch the model ID to gpt-6-astra, send tools through Responses, emit json_schema, keep validating on the host, treat 272K as the budget ceiling.

In ChatGPT you can draft with it, change a repo, and ask for Schema-shaped JSON. For production, wire the same Schema to the API. Models will change again. The contract should stabilize first.

Further reading

• Why AI Agents Now Need JSON Schema Runtime contracts for tools, handoffs, and evals
• OpenAI DevDay 2026 key predictions How three layers become one JSON pipe
• MCP Tool Schema vs Function Calling Protocol boundary for tool JSON
• A2A Extensions and the JSON protocol The third layer of multi-agent interop
• What is JSON Schema? Usage and tutorial Keywords, required, and additionalProperties
• JSONSort local toolbox Format, validate, Diff
• All blog posts More JSON and AI development notes

Changelog: 2026-09-04 initial release. Facts and prices follow OpenAI docs as of that day.