GPT-6 Astra: repeated 503 overload followed by apparent routing/quality inconsistency on Pro

Subscription / model

• ChatGPT Pro
• Model selected by the client: gpt-6-astra
• Reasoning effort shown by the client: max
• Provider/route label shown by the client: openai-auto
• Responses endpoint observed in the request log: /v1/responses

Issue

On September 7, 2026 (UTC+8), GPT-6 Astra repeatedly returned server-capacity errors during an agent task:

Error: server_error: Our servers are currently overloaded. Please try again later.

Error: OpenAI API error (503): {"message":"Our servers are currently overloaded. Please try again later.","type":"server_error"}

Error: Retry failed after 3 attempts: server_error: Our servers are currently overloaded. Please try again later.

After several failed retries, a request eventually succeeded, but the returned behavior was inconsistent with the selected model identity. The prompt included the condition (translated):

If you are not Astra, stop immediately.

The successful response said (translated):

I am not Astra, so I will stop as requested.

At the same time, the client status still showed:

(openai-auto) gpt-6-astra • max

A backend request record for the same period showed:

• model: gpt-6-astra
• reasoning effort: Max
• endpoint: /v1/responses
• request group: GPT-PRO
• timestamp: 2026/09/07 17:38:07 (UTC+8)
• time to first token: approximately 31.03 s
• total request duration: approximately 1m 08s

The task was graphical/SVG generation based on the visual style of top-tier computer-architecture/systems papers. During the same period of repeated overload, the resulting SVG/design quality also appeared substantially below the user's earlier Astra experience and subjectively resembled older-model output.

Why this may be a routing/serving issue

I am not claiming that the model's self-identification is reliable evidence of the actual serving model. The model may simply not know its deployment identity. However, the combination of:

1. repeated 503 overload errors,
2. very high TTFT on the requests that do succeed,
3. a selected/requested model of gpt-6-astra,
4. the successful response explicitly claiming it was not Astra, and
5. an apparent quality regression during the same overloaded period

makes it worth checking whether overload handling, alias resolution, account-level capacity routing, or any fallback path can cause a request selected as Astra to be served differently.

Requested clarification / expected behavior

Could the Codex/Astra team please verify server-side, using the request period above, whether:

• a gpt-6-astra request can transparently fall back to another model or serving tier when Astra capacity is constrained;
• openai-auto can resolve the request to a different model under overload;
• the response metadata exposes the final/resolved serving model separately from the requested model;
• there is any known Astra quality degradation or altered serving behavior during periods with elevated 503 capacity errors.

If fallback is possible, it would be very helpful for Codex to expose requested_model and resolved_model separately so users can distinguish a true Astra response from a fallback response.

Reproduction pattern

The issue is intermittent and seems correlated with capacity pressure:

1. Start a fresh or existing task with gpt-6-astra at max reasoning.
2. Submit a non-trivial agent/design task.
3. Observe repeated 503 / Our servers are currently overloaded failures and automatic retries.
4. Eventually receive a successful response.
5. In at least one observed case, the successful response claimed it was not Astra even though the client/request log continued to identify the request as gpt-6-astra.

This report is primarily asking for server-side verification of routing/serving behavior rather than treating model self-identification as conclusive evidence.

Start with the request record for 2026/09/07 17:38:07 UTC+8, including /v1/responses, gpt-6-astra, openai-auto, and the GPT-PRO group. Verify server-side routing and overload behavior, then document whether requested and resolved models can differ and whether response metadata exposes that distinction.