Codex Model at Capacity? Wait or Switch Models

When Codex says "Selected model is at capacity. Please try a different model," do not buy credits, reinstall Codex, or delete task state. The message normally means the selected model cannot accept more work in your serving region at that moment. Preserve your prompt, check OpenAI status and your Codex usage page, retry once, then switch to another supported model if the error continues.

This guide owns the capacity error. Use the Codex usage-spike guide when the usage page or a limit banner says your allowance is exhausted. Use the model-not-found guide when Codex rejects a model name or says it is unavailable for your account. Use the stream-disconnected guide when the task repeatedly reconnects without showing the capacity message.

Identify Capacity Before Changing Anything

The wording matters because four failures that look similar need different responses.

An OpenAI collaborator clarified this distinction in Codex issue 19583: the capacity message did not mean that the reporter was rate-limited or out of usage. It meant that the selected model had too little serving capacity in that user's region. OpenAI has also recorded resolved Codex capacity and server-overload incidents on its public status site.

Capacity can still be intermittent. In issue 30073, another task returned the error and then accepted a later message in the same session. That is why one controlled retry is useful. Repeated rapid retries are not: they create noise without proving that the service has recovered.

Preserve the Interrupted Task

Before switching anything, copy the unsent prompt or the exact next instruction to a local scratch file. If the task produced edits, inspect the working tree from a normal terminal:

git status --short
git diff --stat

Do not reset the repository, delete ~/.codex, clear credentials, or discard the task. A capacity response is an admission failure before useful model work begins, not evidence that your local state is corrupt.

If several queued prompts are waiting, stop adding more. Let the active request settle, then test with one short, harmless continuation such as:

Report whether the task is still active. Do not edit files or run commands.

If that request succeeds, resume from the preserved instruction. If it returns the same capacity message, move to the status and usage checks.

Check Service Status and Usage Separately

Open OpenAI Status and look for a current Codex incident affecting the selected model or elevated errors. A green aggregate status does not prove that every model, region, and subscription tier is healthy, but a matching incident tells you to wait instead of modifying the client.

Then open the Codex usage page or the usage summary in your Codex client. OpenAI's plan documentation says that users near or at their Codex limit should use the usage page or limit banner to see the available options.

Interpret the two checks together:

• Capacity message, usage remains available: treat it as a model-capacity event.

• Capacity message and an active status incident: preserve state and wait for recovery.

• Explicit usage-limit banner or reset time: follow the usage-limit path, even if a capacity message appeared earlier.

• No usage remaining and another model also fails: do not infer that switching models bypasses the account limit.

Do not purchase credits just to test a capacity error. Credits address eligible usage limits; they do not create serving capacity for one overloaded model.

Retry Once, Then Use a Supported Fallback

Wait a minute or two and retry the preserved prompt once. A successful retry confirms that the interruption was transient. Verify any partially completed work before continuing because the prior turn may have stopped before its promised checks.

If the same error returns, open the model picker and choose another model that your current Codex client lists as supported. In the CLI, start a new invocation with the documented -m option and a model shown by the current model picker or Codex models page:

codex -m <supported-model

Do not copy a model identifier from an old post or issue. Supported models and defaults change. If another supported model works, continue the bounded task there and record which original model failed, which fallback worked, and the approximate time.

One commenter on issue 37790 reported that turning off a fast model mode helped, while other commenters reported that older supported models worked when the newest model family did not. Those are useful reversible tests, not universal fixes. Try them only when the affected mode is enabled and the current client exposes a supported alternative.

Model switching can change speed, reasoning behavior, context handling, or tool choices. Give the fallback a short handoff instead of assuming it has reconstructed the failed turn:

Continue from the current working tree. First read git status --short and the preserved instruction. Do not repeat completed edits. State the next safe step before changing files.

Know When to Wait Instead

Stop retrying and wait when:

• OpenAI Status shows a matching active incident;

• every supported model available to your account returns the same server-side error;

• the capacity message returns across a fresh, short task and an existing task;

• the client cannot load the model picker or usage page; or

• another model starts but repeatedly fails before any response.

Repeated reinstallations, logout cycles, VPN changes, DNS changes, config deletion, and repository resets do not repair provider capacity. They can remove useful state or create a second problem.

If no matching incident appears and the problem lasts, collect a small reproducible report:

1. the exact capacity message;

2. Codex app or CLI version;

3. operating system and region or country, without a precise address;

4. subscription tier;

5. selected model and reasoning mode;

6. whether the usage page showed remaining allowance;

7. whether one other supported model worked;

8. first and last observed time in UTC; and

9. the status-page result at that time.

Do not post request IDs, prompts, repository names, file paths, tokens, auth.json, or screenshots containing private code.

Verify Recovery Before Resuming Long Work

A safe recovery has observable results:

• one short prompt completes on the selected or fallback model;

• the capacity message does not return on a second harmless prompt;

• the working tree still contains the expected changes;

• the task does not duplicate earlier edits; and

• the usage page still matches your expected allowance.

If the original model starts working again later, you may switch back, but first finish or checkpoint the current bounded step. Changing models in the middle of several concurrent edits makes it harder to distinguish capacity recovery from task-state confusion.

Monitor the Upstream Signal With Aident Loadout

You can monitor current public issue state without pasting a GitHub credential into a prompt. Start with:

Follow https://aident.ai/SETUP.md

Then ask your agent:

Check Aident Loadout authentication and Vault status. Discover the current read-only GitHub issue-search Action, inspect its schema, and preflight lookups for openai/codex issues 37790, 19583, and 30073. If the lookups are valid and free, execute them and return only issue number, state, updated time, labels, comment count, and canonical URL. Do not comment, react, edit, close, or create anything.

The Aident Loadout first-task guide explains the account, Vault, discovery, schema, and preflight sequence. The measurable result here is a current issue-state summary with zero GitHub writes.

Set up Aident Loadout and monitor Codex capacity.

Sources

• OpenAI Help: Using Codex with your ChatGPT plan

• OpenAI Codex models

• OpenAI Status: Codex Selected Model is at Capacity incident

• OpenAI Status: Codex 5.6-sol server-overload incident

• OpenAI Codex issue 37790: frequent selected-model capacity errors

• OpenAI Codex issue 19583: capacity is distinct from usage exhaustion

• OpenAI Codex issue 30073: intermittent capacity error in an active session

Refresh this guide when issue 37790 changes state, OpenAI changes the capacity message or fallback behavior, or a current Codex model or usage document changes the decision tree.