GuidesHosting choices

Codex "Selected model is at capacity": what it means, what to do

Codex's capacity error is not your usage limit: where it comes from, what the reports show, what to try, and how to retry it in an unattended codex exec job.

November 14, 2026The Everpod team
The short answer

“Selected model is at capacity. Please try a different model.” means OpenAI’s servers refused the request because they had no room to run that model for you at that moment. It is not your usage limit, which has its own message (“You’ve hit your usage limit”), and nothing on your machine causes it. Wait a few minutes and send again, or switch model; neither is guaranteed, since this autumn many reports show it lasting for hours on some accounts and following them across models. In an unattended codex exec job, unless the server says how long to wait, the turn fails and the command exits with status 1, so the job needs its own retry.

Where the message comes from

In Codex’s source the message is a single error, raised when OpenAI’s API answers with HTTP 503 and the error code server_is_overloaded. Running out of your plan’s allowance is a different answer from the server (HTTP 429, usage_limit_reached) and prints a different line:

Selected model is at capacity. Please try a different model.   <- capacity
You’ve hit your usage limit. Try again at <time>.             <- your plan's limit
Copied

Two neighbours belong to the same family: “Policy-restricted capacity is unavailable. Please try again later.”, which Codex treats exactly like the capacity error, and “We’re currently experiencing high demand, which may cause temporary errors.”, which is what an HTTP 500 from the server turns into. All three are in Codex’s error definitions, and the mapping from the server’s answer is in its API bridge (as of mid-November 2026, release 0.169.0).

OpenAI’s own reading of it, from a Codex maintainer during an earlier wave in May 2026: “If you receive this message, it does not mean that you are being rate limited or are out of usage. It means that we are running low on capacity to serve this model in your region.” That thread was closed as mitigated in June.

What the reports since September show

The message came back in late summer 2026 and has been one of the most reported errors on Codex’s tracker since. The open threads agree on a few things, as observations from users rather than anything OpenAI has explained:

None of the current GitHub threads has a maintainer reply, and the latest release notes (0.169.0, November 13) do not mention it. OpenAI’s status page lists the Codex CLI as its own component, but in mid-November it showed no Codex incident while reports kept arriving, so a green page does not rule this out.

What to do when it stops you

At the keyboard, the useful moves are short. Send the message again in the same session after a few minutes. If it keeps failing, switch model with /model, which is what the message asks for and sometimes works. If it lasts for hours on your account alone, that is the account-by-account pattern above, and only OpenAI can see why; your plan’s allowance, which the Codex plans guide sets out, is not what is being refused. Before deciding it is your limit after all, read the wording again: a limit says “usage limit” and usually gives a time to try again.

If you report it, the open threads are the place (issue 43337 for the account-specific pattern), with your Codex version, your plan, the model and whether codex exec fails too.

What an unattended codex exec run does

Codex can wait and retry this error by itself, but only when the server’s answer says how long to wait; unlike a timeout or a dropped stream, it has no backoff of its own for it. When no wait comes back, the turn fails. In codex exec that means the message on standard error, an error event if you run with --json:

{"type":"error","message":"Selected model is at capacity. Please try a different model."}
Copied

and a process exit status of 1, the same status any other failed run gets. A cron job or systemd timer that only checks the status sees a failure; one that checks nothing sees a run that did no work, so the job is worth wrapping.

A wrapper can tell this error from the rest by the text, wait, and try again, then fall back to another model. The flags are from Codex’s command reference: -m overrides the configured model for one run, and --json prints the events to standard output.

#!/bin/sh
# Retry a codex exec job on capacity errors, then try a fallback model.
PROMPT="$1"
for model in "" "" "" "gpt-6-luna"; do
  out=$(codex exec --json ${model:+-m "$model"} "$PROMPT")
  [ $? -eq 0 ] && exit 0
  printf '%s' "$out" | grep -q 'at capacity' || exit 1   # a different failure
  sleep 300
done
exit 1
Copied

The empty entries run the configured model; replace the fallback with a model your plan offers. This is a pattern, not a cure: the reports say a fallback often meets the same message, and a job that edits files repeats its edits from the start when it is run again. For a long job that got partway, codex exec resume --last with a short prompt such as “continue” carries on the same session instead, run from the same directory (add --all to pick the newest session from any directory); how resuming works on a server is in the guide to resuming Codex and Claude Code sessions. Whatever the wrapper does, have the final failure tell you, by mail or a notification, rather than end in a log nobody reads. The rest of running Codex on a VPS, from sign-in to the sandbox, is in Codex CLI on a Linux server.

Claude Code’s version of this

Claude Code shows a different maker’s message for the same situation: “API Error: Repeated 529 Overloaded errors”, or a prompt such as “Opus is experiencing high load, please use /model to switch to Sonnet”. Anthropic’s error reference says a 529 “is not your usage limit and doesn’t count against your quota”, that capacity is tracked per model, and that Claude Code has already retried with backoff before it shows the message. For a scheduled claude -p job, running Claude Code headless on a schedule covers the limits and timeouts.

Run Codex on an always-on developer pod.

A developer pod is a permanent cloud computer (VPS), set up and secured for you, with your pick of Claude Code, Codex, OpenCode, Pi, Hermes and OpenClaw installed. Run more agents at once than your laptop can hold, and keep them working when it’s closed. From $24 a month, built in about ten minutes.