More Than Plus

Two numbers became one phrase.

Over the weekend of September 26, ChatGPT subscribers noticed that the Pro plans had been quietly renamed. The $100 tier, sold as "5x the usage of Plus," is now Pro Standard. The $200 tier, sold as "20x the usage of Plus," is now Pro More. Both now say the same thing about what you get: "More usage than Plus." Source: PANews

The same week, a code change titled "Add Pro Max plan and update Pro display name" surfaced a third tier: Pro Max at $500 a month, described as "the fastest work experience with Codex." Source: KuCoin OpenAI hasn't announced Pro Max, and DevDay is tomorrow, September 29. Treat the $500 tier as reported, not confirmed.

The prices didn't change. What changed is that the only unit a subscriber had for comparing plans is gone. This post covers why that matters more than a rename, what the timing tells you, and how to rebuild the number yourself from your own Codex logs, in about 40 lines of Python.

Costs in this post are illustrative, modeled from OpenAI's public API list prices and assumed usage profiles, not measured production traces. Not derived from proprietary customer data. Sources cited throughout.

Why a multiplier was worth something.

"20x the usage of Plus" was never a precise promise. Plus limits have always moved, differ by model, and are described in messages or time windows rather than tokens. But it was a ratio, and a ratio does two jobs a phrase can't:

1. It compares tiers. At 5x for $100 and 20x for $200, the $200 plan was twice the price for four times the usage. That's why 36Kr reported that the 20x plan was the most heavily used Pro tier: per unit of compute, it was the cheapest thing OpenAI sold.
2. It pins the plan to something. If Plus limits went down, 20x went down with them, and you could at least see the ratio. "More than Plus" is satisfied by 1.1x.

Neither job survives the new wording. Pro Standard and Pro More now carry the same claim at different prices. What separates them is whatever OpenAI decides it is this month.

What the timing tells you.

On September 11, OpenAI stopped selling the $200 plan to new subscribers. Existing Pro 20X users kept their access. The reason, from Tibo, OpenAI's head of core products, as reported by 36Kr: the Astra model "has excellent performance, triggering unprecedented demand, and there is not enough computing power available now." Source: 36Kr Two days earlier he had written: "the demand for Astra is unprecedented, we are pulling every lever we can."

Put the pieces in order:

This reads as a vendor that's short of flagship compute and needs room to change how much of it a flat fee buys. A fixed multiplier is a commitment. A phrase isn't. We've written before about how much of today's AI pricing is subsidized. Flat-rate plans with heavy users are the most subsidized part of it, and they're the part being made vague first.

None of this is unusual. Anthropic's Claude plans adjusted weekly limits earlier this year, and every coding tool has moved toward metering. The pattern is the same everywhere: the flagship model is the scarce resource, and the plan terms are where the scarcity shows up first.

What a flat plan is actually worth.

The useful question isn't "is 'More' more than 20x?" You can't answer it. The useful question is: what would the work I do on this plan cost me on the API? That number has a unit, OpenAI publishes the prices, and it doesn't change when a pricing page does.

A typical Codex agent request re-reads a large context and writes a little. Assume 60,000 input tokens per request, 90% of them cache hits, and 1,200 output tokens including reasoning. At GPT-6 list prices:

Price per million tokens. Astra bills over-272K prompts at 2x input; these requests stay under it.

Three things stand out.

• For a heavy user, the flat plan is a large discount on flagship tokens. 5,000 Astra requests a month is $870 on the API against $200 for Pro More. That gap is the subsidy, and it's what the multiplier used to put a floor under.
• Routing closes most of the gap. The same 5,000 requests, split 20% Astra, 50% Sol, and 30% Luna, cost $264 on the API. That's 70% less than all-Astra, and within reach of the flat plan.
• The power user is the one the change is aimed at. At 20,000 requests, the all-Astra equivalent is $3,480. No flat plan at $200 carries that for long. A $500 tier "for the fastest Codex experience" is where that user is being moved.

Tutorial: rebuild the multiplier from your own logs.

Codex CLI writes a rollout file for every session under ~/.codex/sessions/YYYY/MM/DD/. Each model call adds a token_count event with that request's usage. Summing them gives you tokens by model by week, which you can price at API rates. That's your own multiplier: a number you can track after the plan terms change.

The field names below match Codex CLI rollouts as of September 2026. Check a line of your own file before trusting the totals.

Step 1: collect usage.

import json, glob, os
from collections import defaultdict
from datetime import datetime

PRICES = {  # USD per 1M tokens: input, cached input, output
    "gpt-6-astra": (10.00, 1.00, 50.00),
    "gpt-6-sol":   (2.00, 0.20, 10.00),
    "gpt-6-luna":  (0.10, 0.01, 0.50),
}

def week_of(ts: str) -> str:
    d = datetime.fromisoformat(ts.replace("Z", "+00:00"))
    y, w, _ = d.isocalendar()
    return f"{y}-W{w:02d}"

usage = defaultdict(lambda: [0, 0, 0, 0])   # (week, model) -> in, cached, out, calls
root = os.path.expanduser("~/.codex/sessions")
for path in glob.glob(f"{root}/**/rollout-*.jsonl", recursive=True):
    model = "unknown"
    for line in open(path, encoding="utf-8", errors="replace"):
        try:
            e = json.loads(line)
        except ValueError:
            continue
        p = e.get("payload") or {}
        if e.get("type") == "turn_context" and p.get("model"):
            model = p["model"]
        if p.get("type") == "token_count" and (p.get("info") or {}).get("last_token_usage"):
            u = p["info"]["last_token_usage"]
            row = usage[(week_of(e["timestamp"]), model)]
            row[0] += u.get("input_tokens", 0)          # includes cached, as OpenAI counts it
            row[1] += u.get("cached_input_tokens", 0)
            row[2] += u.get("output_tokens", 0)         # includes reasoning
            row[3] += 1

Only token counts and timestamps are read. No prompt or response text leaves the file.

Step 2: price it.

def price(model: str, inp: int, cached: int, out: int, as_model: str | None = None) -> float:
    key = as_model or next((k for k in PRICES if model.startswith(k)), None)
    if key is None:
        return float("nan")                      # unknown model: don't guess
    pi, pc, po = PRICES[key]
    return ((inp - cached) * pi + cached * pc + out * po) / 1e6

weeks = defaultdict(lambda: {"actual": 0.0, "all_astra": 0.0, "calls": 0})
for (week, model), (inp, cached, out, calls) in usage.items():
    weeks[week]["actual"] += price(model, inp, cached, out)
    weeks[week]["all_astra"] += price(model, inp, cached, out, as_model="gpt-6-astra")
    weeks[week]["calls"] += calls

PLAN = 200.0   # what you pay per month
for week in sorted(weeks):
    w = weeks[week]
    monthly = w["actual"] * 52 / 12
    print(f"{week}  {w['calls']:>6} calls  API-equivalent ${w['actual']:>8.2f}/wk"
          f"  (${monthly:>8.2f}/mo, {monthly / PLAN:4.1f}x the plan)"
          f"  all-Astra ${w['all_astra']:>8.2f}/wk")

The last column is the number that used to be printed on the pricing page, measured from your side. If it's 4.4x this week and 2.1x in November on the same kind of work, the plan changed, whatever the page says.

Step 3: decide.

• API-equivalent below the plan price: you're paying for headroom you don't use. Drop a tier, or move the work to the API.
• Well above the plan price, and stable: the flat plan is a good deal. Keep it, and keep the weekly log so you notice when it stops being one.
• Well above, and mostly Astra: you're exactly the user the plan changes are aimed at. The work that doesn't need Astra is what will run out your limit first.

Stretching whichever limit you have.

On any plan with a usage limit, the flagship is the expensive way to spend it. OpenAI has said as much with its own products: when it shipped GPT-5-Codex-Mini last November, the pitch was that it "allows roughly 4x more usage than GPT-5-Codex," and Codex suggested switching to it at 90% of a user's limit. A smaller model spends less of your allowance per request. The same logic applies to the API bill.

So the lever is the same on a flat plan and on the API: don't send Astra the work Sol or Luna can do. In our illustrative profile, a 20 / 50 / 30 split cut the API-equivalent by 70%. On a flat plan, the same split is how you avoid hitting the limit on Thursday.

The hard part is making that split per task, while the agent is running, rather than once per session. Picking a cheaper model for the whole session is wrong in both directions: the trivial renames still run on something too expensive, and the one hard refactor runs on something that can't do it.

Where Nadir fits.

Nadir's Codex hook asks one question each time the agent is about to hand off a piece of work: which tier does this need? It sends the prompt to POST /v1/bucket, which classifies it as simple, medium, or complex without spending provider tokens, and passes the suggestion back to the agent. The agent keeps its own OpenAI credentials and decides. Nadir never sees your subscription and doesn't need to.

If you'd rather run on the API, the OpenAI compatible gateway routes each request to the cheapest model that clears your quality bar and reports the model and cost on every response. Either way, you get the number the pricing page stopped printing: what your work actually costs, by model.

Start with a free key, run the script above on last month's rollouts, and see how much of your Astra usage was tier-simple.

Conclusion.

"5x" and "20x" were imprecise, but they were numbers, and numbers can be checked. "More usage than Plus" can't. The change arrived two weeks after OpenAI ran out of Astra capacity and a day before DevDay, next to a reported $500 tier for the heaviest Codex users. Read together, the direction is clear: the flat-plan discount on flagship tokens is being made adjustable. You can't stop that, but you can measure it. Log your tokens, price them at API rates every week, and keep the flagship for the work that needs it. That keeps the multiplier on your side of the table.

Costs in this post are illustrative, modeled for this post from OpenAI's public API list prices and an assumed request profile, and are not derived from customer data. Sources: [PANews, "OpenAI may restructure ChatGPT subscription tiers," September 27, 2026](https://panews.io/articles/01a0e325-1c58-72a6-a1e6-e985664f7b69). [KuCoin News, "OpenAI Adjusts ChatGPT Pro Tiers, Adds $500 Pro Max Option," September 28, 2026](https://www.kucoin.com/news/flash/openai-adjusts-chatgpt-pro-tiers-adds-500-pro-max-option). [Phemex News, "OpenAI Renames ChatGPT Pro Tiers"](https://phemex.com/news/article/openai-quietly-renames-chatgpt-pro-tiers-amid-subscription-restructure-speculation-98002). [36Kr, "OpenAI Announces ChatGPT Pro 20X Is No Longer Available for New Subscriptions," September 11, 2026](https://eu.36kr.com/en/p/3978220011928576). [OpenAI Help Center, About ChatGPT Pro tiers](https://help.openai.com/en/articles/9793128-about-chatgpt-pro-tiers). [OpenAI DevDay 2026](https://devday.openai.com/). GPT-6 API prices from OpenAI's model pages, as listed in [our GPT-6 pricing post](/blog/gpt-6-sol-luna-pricing-terra-retired-routing).