GPT-6 Astra: Release Timing and What OpenAI Has Confirmed

On the evening of September 2, 2026, someone spotted an oddity in OpenAI's Responses API: a request for the model gpt-6-astra comes back 404 Not Found rather than the 400 Bad Request any made-up name gets. The gap between those two status codes is the only technically verifiable GPT-6 signal available today. Below: how to reproduce the probe yourself, what it proves and what it doesn't, what OpenAI has actually confirmed about Astra, and how to prepare an integration so the release costs you one config change.

404 vs 400: what was found

The probe is one command away — you only need your own OpenAI key:

# model exists but isn't available to you → 404
curl -s -o /dev/null -w '%{http_code}\n' https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-6-astra","input":"ping"}'

# slug that definitely doesn't exist → 400
curl -s -o /dev/null -w '%{http_code}\n' https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-7-qwerty","input":"ping"}'

The logic runs like this. 400 is the validator talking: the string matches nothing in the catalog, so the request is rejected before routing. 404 is the router talking: the name parsed, the model was found in the registry, and this particular key just doesn't have access. That's how internal and gated models behave — per the same observers, 5.6 Cyber, which is known to exist, also returns 404.

Observers separately report a second identifier surfacing, gpt-6-astra-aeon, which they read as a distinct tier for long multi-step runs. That one has no official confirmation, unlike the status-code pair itself, which any key holder can check.

What the probe proves: the string gpt-6-astra is known to OpenAI's backend. What it does not prove: no release date, no final product name, not even that the model will ship under that slug. A 404 is equally explained by access rights, deployment configuration, or an internal alias that never goes public. It's a staging signal, not an announcement.

What OpenAI has officially confirmed

The record here is harder, because these are the company's own publications.

August 1, 2026. In Ten advances in mathematics and theoretical computer science, OpenAI calls Astra "our next major model" for the first time. An internal version closed ten open problems, each unsolved for at least a decade: high-dimensional geometry, coding theory, arithmetic circuit complexity, group theory, operator algebras, quantum complexity, lattice cryptography, extremal combinatorics. The headline result is the first explicit construction of a non-sofic group, a question open since 1999. The proofs shipped with machine-checkable Lean certificates: 249 pages, and roughly $2,000 worth of tokens at GPT-5.6 Sol rates.

August 7, 2026. OpenAI slowed the release and paused part of the work, citing cybersecurity.

September 1, 2026. The post Path to Astra: critical capabilities and frontier safeguards: Astra is the company's first model to cross the Critical cybersecurity threshold in its Preparedness Framework. The threshold is defined as the ability to independently find and exploit zero-days across well-defended systems, or to run a full attack on a hardened target from a single high-level instruction. What the tests showed:

• a perfect score on ExploitBench, the benchmark for turning known vulnerabilities into working exploits;
• against a hardened browser, the model found previously unknown vulnerabilities and assembled a chain that escaped the sandbox and executed commands on the host;
• in a hardened OS, a local privilege-escalation chain from an unprivileged user up to root.

Hence the release shape. Advanced cyber capabilities are not part of the default configuration: access runs through the Daybreak Blue program for vetted defenders, with extra chain-of-thought monitoring and restricted responses for higher-risk accounts. On timing, the wording is "plan to make Astra available soon" — no date.

Industry context: Anthropic did exactly the same thing with Claude Mythos 5.1, limiting it to a narrow set of vetted institutions while shipping the broadly available Fable 5.1 alongside. "General model in production, dangerous tier by application" is becoming the norm, not a one-off OpenAI decision.

What OpenAI did not say

Everything else making the rounds is inference, not a statement: the "10 trillion parameter MoE" and the "multi-agent coordination native from pretraining" alike. Internal codenames from leaks are mewfour and mozaik-alpha-fdm. Per the August 29–30 leaks, the model was run zero-shot at maximum effort, and the showcase examples burned roughly 56,000 tokens over ~38 minutes of reasoning per request. For planning purposes that matters more than parameter count: a run like that does not fit inside a synchronous HTTP request.

How to prepare your code today

The thing to prepare for isn't a new name in a config — that part is trivial — it's a mode of operation where a single answer takes tens of minutes. The GPTunneL API is OpenAI-compatible, so moving to any new model is one field:

curl https://gptunnel.ru/v1/chat/completions \
  -H "Authorization: <YOUR_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6-sol",
    "reasoning_effort": "high",
    "messages": [{"role": "user", "content": "Hi!"}]
  }'

The gateway takes reasoning depth in reasoning_effort — and that's the field worth lifting into a function parameter alongside the model name. The gap between low and high already shows up on the bill; on forty-minute runs it will be several times wider.

The second thing to do ahead of time is move long calls to streaming. A synchronous request without streaming survives your load balancer and proxies exactly until the first timeout; streaming holds the connection and lets you stop on a budget rather than on a dropped socket:

const BUDGET_MS = 15 * 60 * 1000;

export async function askStreaming(messages, onDelta) {
  const res = await fetch("https://gptunnel.ru/v1/chat/completions", {
    method: "POST",
    headers: {
      Authorization: process.env.GPTUNNEL_API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: process.env.MODEL_SMART ?? "gpt-5.6-sol",
      reasoning_effort: process.env.MODEL_EFFORT ?? "medium",
      stream: true,
      messages,
    }),
    signal: AbortSignal.timeout(BUDGET_MS),
  });

  const decoder = new TextDecoder();
  let buffer = "";

  for await (const chunk of res.body) {
    buffer += decoder.decode(chunk, { stream: true });
    const lines = buffer.split("\n");
    buffer = lines.pop();

    for (const line of lines) {
      const s = line.trim();
      if (!s || s.startsWith(":")) continue;    // gateway keepalive, not data
      if (s === "data: [DONE]") return;
      if (!s.startsWith("data: ")) continue;
      const delta = JSON.parse(s.slice(6)).choices[0].delta.content;
      if (delta) onDelta(delta);
    }
  }
}

Lines starting with a colon are the gateway's keepalive comments (: HELLO, : PROCESSING) sent before the first data chunk; a naive parser chokes on them, and we covered this separately. On a model that thinks for 38 minutes there will be plenty of them.

Once Astra is available, the move comes down to MODEL_SMART=<new id> in the environment and a run of your own 20–50 real requests — provided the transport already knows how to wait by then.

What will break when you move to Astra

This list comes from what is already known about how the model runs, not from rumors about how smart it is.

• The user-facing flow. Streaming saves the connection, not the interface: nobody waits forty minutes at a progress bar. If your product is synchronous, the release needs a queue, a job id and a completion notification — that's not an evening's work.
• The reasoning bill. 56,000 tokens for one answer is the normal price of maximum effort. Start recording usage per call now, or the first month on the new model will be a surprise.
• Restricted answers. The model will decline part of the security-adjacent requests in the default configuration, and that's expected behavior, not a fault. Your pipeline has to handle a refusal properly instead of treating it as a network error and retrying.
• Tool call shape. The number and order of tool calls in an agent loop shift between generations. A parser hardwired to "exactly one call per step" will break.
• Price and routing. A flagship above the current line will almost certainly cost more than Sol. Build the "simple goes to the cheap model, hard goes to the heavy one" split before the release, not after the first invoice.

Full request, streaming, and limit specs are in the docs and at docs.gptunnel.ru.

What to use today

Astra is available to nobody outside OpenAI's testers, so today's working line is the 5.6 family, already in GPTunneL with a 1M context:

• GPT-5.6 Sol — the current flagship for code, research and agent loops: $0.01 per 1K input tokens and $0.06 per 1K output. What it can do is covered separately, and its accelerated output mode is here.
• GPT-5.6 Terra — the middle tier: $0.004 and $0.024 per 1K.
• GPT-5.6 Luna — the cheap workhorse for bulk load: $0.0004 and $0.0024 per 1K.

All three run right in your browser with no VPN, local payment methods supported and no subscription — you pay per token. Current numbers for every model are on the pricing page. Claude, Gemini and Grok sit behind the same API, so one key runs your eval across every candidate.

GPT-6 Astra FAQ

When will GPT-6 be released? No date announced. OpenAI said "soon" on September 1, 2026. The API behavior on September 2–3 shows the model is registered, but that isn't a release schedule.

Are GPT-6 and Astra the same thing? Officially, no. OpenAI calls the model Astra and has never called it GPT-6. "GPT-6 Astra" is press shorthand, backed by little more than the gpt-6-astra slug in the API.

Can I try GPT-6 Astra already? No. The identifier isn't callable and there's no public access. Anything offering "GPT-6 access" today isn't GPT-6. Our breakdown of the early GPT-6 leaks still holds on the rumor side.

What does the 404 on gpt-6-astra mean? That the name parsed and was found in the model registry but isn't available to your key. Non-existent names are rejected earlier and return 400.

Why was the release slowed? Astra was the first model to cross the Critical cybersecurity threshold: it finds and exploits previously unknown vulnerabilities without step-by-step guidance. Additional safeguards were required before release.

What's OpenAI's strongest model right now? Of the available ones, GPT-5.6 Sol.

The bottom line

There are exactly three verifiable facts: Astra solved ten open math problems with Lean-checkable proofs, it became the first model rated Critical for cybersecurity, and its identifier is already staged in OpenAI's API. No date, no official GPT-6 name, no price.

Guessing at the date is pointless; transport that survives multi-minute answers is something you'll need either way — for Astra and for whatever follows it. Open GPT-5.6 Sol in GPTunneL and run your scenario on the same key you'll later call Astra with.