Codex "Selected Model Is at Capacity": Fixes and Retry Delays

Distinguish Codex capacity errors from exhausted usage, update the affected client, test another model, and investigate persistent account-specific failures. Understand OpenAI's Retry-After changes and preserve CI work with bounded recovery and a separately billed API fallback.

Contents
Codex "Selected Model Is at Capacity": Fixes and Retry Delays

Selected model is at capacity. Please try a different model. in Codex signals a capacity error, not proof that your usage allowance is exhausted. For developers blocked in the CLI, desktop app, or IDE extension, update the affected client and test another available model. If Codex is already waiting on a server-directed retry, let that wait finish before submitting another request.

Is this a capacity error or a usage limit?

Codex classifies this message as ServerOverloaded. Its API error bridge maps server_is_overloaded to that error. The separate UsageLimitReached type becomes UsageLimitExceeded in the client-facing protocol.

The error definitions also contain PolicyCapacityUnavailable, displayed as Policy-restricted capacity is unavailable. Please try again later. It shares the capacity retry strategy, but it is a distinct error. Neither message alone establishes that your account is banned.

Check your usage dashboard for remaining allowance. If the actual error identifies exhausted usage, follow the Codex usage-limit and reset guide. Buying more allowance is not the first diagnostic step for a capacity response.

What should you try first?

Update the client that actually failed

As of 2026-11-17, OpenAI’s latest stable Codex CLI release is 0.169.0. Update an older installation before investigating retry behavior.

For an npm-installed CLI, use Bash:

codex --version
npm install -g @openai/codex
codex --version

The final command should report the updated version. For other installation methods, follow the corresponding official update instructions. With Remote SSH, check the CLI on the remote host too.

Update the desktop app or IDE extension separately when that is where the failure occurs, then restart that client. Managed desktop updates may require your administrator’s approved deployment. The CLI, app, and extension comparison helps identify which interface needs attention.

Try one available model, or let the retry finish

In the CLI, use /model to select another listed model. Then use /status to confirm the selection, as described in the command reference. Send a small request such as Reply with OK. before returning to the interrupted task.

A completed reply confirms that this model and route worked for that request. It does not establish that the original model recovered. If several models fail, stop cycling through them and use the account checks below.

When the client is already retrying, allow the server-advised delay. Avoid repeatedly restarting the same request or launching parallel copies. Check OpenAI’s status page for an incident, but remember that its aggregate status does not establish availability for one account.

If the error returns after the wait, submit /feedback promptly. Keep the failure time, selected model, client version, and any feedback identifier for escalation.

Which route should you use while capacity recovers?

Stay with your existing route when the wait fits your deadline. Consider a separately billed API route when you need a fallback for local work.

RouteRequirements and billingWhen to choose it
Wait and retryYour existing account and access; no new billing setup. Respect any server-provided delay.The current model matters, and the delay is acceptable.
Choose another modelA model offered by /model for your account and workspace; your existing access rules still apply.A small test succeeds and the alternative can handle the task.
OpenAI APIAn API key, API billing, and access from a supported country or territory. Local Codex usage follows API token pricing.You need a direct, usage-based route rather than subscription access.
BetterToken APIYour own BetterToken account, API key, and balance funded through a payment method offered in the console; the documented Codex custom provider uses Responses. Charges follow the model’s token billing rules.You want a pay-as-you-go gateway route and can configure and test it before relying on it.

API billing is separate from ChatGPT subscription usage. Switching routes does not replenish that subscription allowance. Compare the workload against current BetterToken API prices before funding a fallback.

These API options concern local Codex workflows. OpenAI’s authentication documentation says Codex Cloud requires ChatGPT sign-in. Do not assume a local provider change moves an existing cloud task.

Use the Codex custom-provider setup guide for the configuration path. Test the chosen endpoint with a small request before handing it an unfinished repository task.

What did OpenAI change, and why can waiting get longer?

The reported improvement concerns fewer turns ending in a capacity error, not a guarantee of immediate service.

In Tibo’s November 16 post, @thsottiaux said the team might have fixed the recurring error. The accompanying chart reports the share of daily active users with at least one turn ending in a capacity error. It falls from 6.82% on October 19 to 0.085% on November 12, within an October 15–November 12, 2026 UTC window. That is not the percentage of all requests that failed.

The chart marks six Retry-After changes, which carry server advice about when to retry. On October 15, a desktop release carried a WebSocket retry fix. October 22 added delays for ordinary overloads; October 23 added retry times for service-tier overloads. On October 24, Codex began forwarding retry and stop instructions. October 30 added a delay for NO_MORE_RETRY. The November 6 change preserved that delay in WebSocket errors.

The current source assigns ServerOverloaded, PolicyCapacityUnavailable, and RetryLimit to RetryPolicy::ServerDirected. The released 0.169.0 code also uses the server-provided delay for those errors. This lets a request wait instead of ending immediately when retry advice is available.

A lower terminal-error rate can therefore coexist with longer waits. The chart does not measure p95 turn time, the time below which 95% of turns finish, or whole-job completion. Codex’s retry handler also retains retry budgets. Server advice controls timing; it does not promise unlimited retries or eventual success.

What if only one account keeps failing?

Investigate the account and authentication path without declaring a confirmed account restriction.

As of 2026-11-17, issue #60767 remains open. Reporter xiaogu12138 describes a Plus account failing across CLI and VS Code Remote SSH despite remaining usage. Another Plus account reportedly worked on the same server.

The report includes automatic retry delays of approximately 314–317 seconds. It also mentions a later 401 Unauthorized response and a separate token_revoked error. The report does not establish that these authentication errors caused the capacity failures, and the inspected logs could not independently identify the affected account.

Use that pattern to organize evidence, not to assume the same cause:

  1. Keep the comparison controlled. Record the account/workspace privately, client version, model, host, and timestamp with timezone. Try the same small prompt in the CLI and extension. An authorized colleague can test their own account independently; do not exchange credentials.
  2. Repair authentication only when there is authentication evidence. For a stored ChatGPT login showing 401 or token_revoked, use codex logout, then codex login. Retry the same small request afterward. A capacity message alone is not a reason to delete authentication files.
  3. Escalate repeated failures. Run /feedback immediately after another failure. Send the feedback identifier, reproduction steps, retry timings, and available request IDs through OpenAI Support.

Do not publish credentials, authentication files, or private repository contents in a GitHub issue. One successful retry is useful evidence, but an intermittent problem needs timestamps from repeated occurrences.

How do you keep a capacity failure from wasting a long run?

Split the task into reviewable checkpoints and preserve state when a turn fails. Keep deployment, payment, and other external side effects outside a blind retry loop.

For a read-only diagnostic run, this Bash example records events and preserves the CLI exit status. Run it in a dedicated job checkout:

umask 077
status=0
codex exec --json --sandbox read-only \
  "Inspect the repository and report the next unfinished step. Do not edit files." \
  >codex-events.jsonl 2>codex-stderr.log || status=$?
printf '%s\n' "$status" >codex-exit-code.txt
exit "$status"

Configure CI to retain these files even when the step fails. The non-interactive interface emits thread.started, turn.completed, turn.failed, and error events. Require a successful process exit, a completed turn, and your task-specific checks before downstream work proceeds.

Preserve the checkout and private Codex session storage too. The event log alone is not the saved session. Avoid --ephemeral for jobs you intend to resume, and do not upload an entire credential-bearing Codex home as a public artifact.

After the retry delay or underlying problem is resolved, resume the recorded session rather than choosing whichever job ran last. With jq installed, run this Bash command from the original checkout:

session_id=$(jq -ers \
  '[.[] | select(.type == "thread.started") | .thread_id] | first // empty' \
  codex-events.jsonl) &&
codex exec --sandbox read-only resume "$session_id" \
  "Inspect the existing work and report the next unfinished step. Do not edit files."

Set a wall-clock deadline and a bounded recovery budget in your job runner. Retry only a failure you have classified as transient, respecting available server timing advice. Stop on authentication, permission, or exhausted-usage errors instead of repeatedly replaying them.

If your deadline requires another provider, start from a saved checkpoint and a handoff describing completed work and remaining checks. Verify the existing diff before continuing, so the fallback does not repeat completed external actions.

Ready to optimize your LLM workflow?

Join thousands of developers building faster, smarter, and more cost-effective AI applications with BetterToken.

Get Started for Free