Claude Max、ChatGPT Pro 與 Copilot Max：三種 $100 訂閲方案採用不同用量計算方式

• Book: LLM Observability Pocket Guide
• Also by me: Thinking in Go (2-book series) — Complete Guide to Go Programming + Hexagonal Architecture in Go
• My project: Hermes IDE | GitHub — an IDE for developers who ship with Claude Code and other AI coding tools
• Me: xgabriel.com | GitHub

Anthropic, OpenAI and GitHub each sell a coding-agent plan at $100 a month. Claude Max 5x gives you "five times the Pro plan's per-session usage allowance." ChatGPT Pro starts at $100, and OpenAI's Codex pricing page says Pro plans "currently have no five-hour limit." GitHub Copilot Max gives you 20,000 AI credits, and one credit is $0.01.

Only the last is a number you can do arithmetic with. Anthropic's help pages don't say how much a Pro session holds, so "five times" multiplies a figure you never see. OpenAI's pricing page prints no multiplier for the $100 tier at all.

Each one meters agent work in its own unit. GitHub replaced premium requests with token-based AI credits on June 1, 2026. OpenAI prices Codex models in credits per million tokens. Anthropic's limits reset on a rolling five-hour window, with a weekly limit on top.

Side by side, as of October 13, 2026, from Anthropic's Max page, OpenAI's Codex pricing, and GitHub's plans and billing docs:

Same price, three different ways of counting what you used.

Claude Max 5x: five times a number nobody prints

Anthropic's Claude Code help page says both Pro and Max "have a five-hour session limit and a weekly limit," that Max adds "a separate weekly limit for Fable," and that these limits "are shared across Claude and Claude Code." Your chats in the Claude app and your agent's turns drain the same pool. The page gives no prompt counts and no token counts.

The Max pricing page lists Fable at "50% of weekly limits" on both Max tiers. On Anthropic's API price list, Fable 5.1 costs $10 per million input tokens and $50 per million output, against $4 and $20 for Opus 5.5.

Four places the limit bites a heavy user:

1. Parallel agents. Anthropic's agent view docs say it plainly: "running ten agents in parallel uses quota roughly ten times as fast as running one."
2. Switching models doesn't help. The session and weekly windows are "shared across all models, so the developer can't restore access by switching models with /model," per the costs docs. Only the model-specific Opus or Sonnet limits can be worked around that way.
3. The bundled API credit doesn't cover Claude Code. Max 5x includes $100 a month in API credits, but the help page says they "can't be used in Claude Code or the Claude apps, including for extra usage."
4. Overflow gets more expensive per turn. Past the limit you can turn on usage credits "to keep working at standard API rates" (pricing page). The costs docs add that the prompt-cache lifetime "is an hour on a subscription and drops to five minutes once you're drawing on usage credits." A ten-minute break then means your next message reprocesses the whole context. The same page says you can keep the one-hour lifetime on usage credits by choosing the TTL yourself.

If the weekly limit is what stops you, the next step is Max 20x at $200, "20 times the Pro plan's per-session usage allowance."

ChatGPT Pro $100: no five-hour window, for now

When OpenAI launched the $100 tier in April, Engadget reported it as "offering five times more Codex than the $20 option." Today's Codex pricing page lists "Plans at $100, $200, or $500 USD per month" and gives no multiple for any of them.

What the page does say is better news for long sessions: "Pro plans currently have no five-hour limit." Two qualifiers sit next to it. "Weekly limits may also apply," with no figure. And "Cloud tasks may use more of your allowance than local messages."

Model choice moves the count a lot. For Plus, the same page estimates 5 to 45 local messages per five hours on GPT-6 Astra, and 350 to 3,000 on GPT-6 Luna. In credits per million tokens, GPT-6 Astra costs 250 input and 1,250 output, GPT-6.1 Sol 50 and 250, a fifth as much. Fast mode uses 2.5x your included usage, and Ultrafast (Pro $500 only, among personal plans) uses 8x.

Past the limit, Plus and Pro "can purchase additional credits," but "Credit purchase prices and applicable discounts depend on your plan or agreement." With no public dollar price per credit, you can't turn a Codex session into dollars.

Copilot Max: the one meter in dollars

GitHub's individual plans page gives Copilot Max 10,000 base credits and a 10,000-credit flex allotment, 20,000 a month. The plans page lists that as $100 of base credits plus a $100 flex allotment and warns that "Flex allotments may change over time." The billing docs say flex "is designed to adapt as the economics of AI evolve." Plan around the base half.

Credits are spent on tokens at per-model rates. GitHub's models and pricing table lists Claude Opus 5.5 at $4.00 input, $0.20 cache read, $5.00 cache write and $20.00 output per million tokens. That matches Anthropic's own API list price. GPT-6 Astra is $10.00 and $50.00 up to 272K input tokens, $20.00 and $75.00 above that. Code completions and next edit suggestions don't use credits. The pool resets at 00:00 UTC on the first of the month, and unused credits don't carry over.

Because the rates are public, you can estimate a session before you run it:

# Copilot bills tokens at per-model rates; 1 credit = $0.01.
# Opus 5.5 rates from GitHub's models-and-pricing page, USD/1M.
RATES = {
    "input": 4.00,
    "cache_read": 0.20,
    "cache_write": 5.00,
    "output": 20.00,
}

def credits(tokens: dict[str, int]) -> float:
    usd = sum(RATES[k] * n / 1_000_000 for k, n in tokens.items())
    return usd / 0.01

# A made-up long agent session, not a measurement.
session = {
    "input": 500_000,
    "cache_read": 10_000_000,
    "cache_write": 300_000,
    "output": 200_000,
}
print(f"{credits(session):,.0f} credits")

By hand, that invented session is $2.00 of fresh input, $2.00 of cache reads, $1.50 of cache writes and $4.00 of output: $9.50, or 950 credits. Max's 20,000 credits cover about 21 sessions of that shape a month, the base half alone about 10. Swap in your own token counts and your model's rates.

Pro+ and Max also include delegating tasks to Claude and OpenAI Codex agents, in preview per the plans page. If you want both vendors' models on one bill, Copilot is the plan built for it.

Measure your own burn

None of these pages tell you what your week costs. Your own usage screens do. Each agent has a command for it:

# Claude Code, inside a session
/usage    plan usage bars, attribution, 24h / 7d
/status   remaining allocation

# Codex CLI
/status      session config and token usage
/usage       account token usage
/statusline  can pin rate limits to the footer

# Copilot CLI: a soft cap for this session
/limits set max-ai-credits 500
/limits unset

On a Pro or Max plan, Claude Code's /usage shows plan usage bars plus a breakdown by skills, subagents, plugins and MCP servers, and flags any behavior, such as long context or cache misses, behind 10% or more of recent usage. It counts only sessions on that machine. Its session dollar figure is computed locally at list price, and Anthropic notes that for subscribers it "isn't relevant for billing purposes." /status is from Anthropic's help page, the Codex lines from OpenAI's command reference. Copilot CLI's session limit is in public preview, has a 30-credit minimum, and is soft: a response already running finishes past the cap. The monthly total lives on GitHub's usage dashboard.

Before you upgrade or switch, run one normal week and check each agent's usage screen at the end of every day. You'll see which wall you hit first: the five-hour one, the weekly one or the dollar budget.

Each vendor's screen shows its own meter. Running two vendors means reading two of them.

If you run more than one agent, Hermes IDE puts them in one place. I build Hermes, so weigh what I say about it with that in mind. Claude Code, Codex, GitHub Copilot CLI and the rest each run their own interface in a real terminal, on their own CLI sign-in, and Hermes never asks for your tokens. Each agent session shows its spend: the cost the agent reports, or an estimate from its transcript clearly marked as estimated, with token totals. A Cost Dashboard adds daily and per-provider breakdowns. On a flat plan that dollar figure isn't your bill, as Anthropic says of its own, so read it as a relative meter. It shows which session is spending the most.

When one agent hits its usage limit, you can continue the task in another. Hermes doesn't raise any vendor's limit or change how they bill you. It's free, source-available under BSL 1.1, on macOS, Windows and Linux, and 2.3.1 shipped on October 13, 2026. It is not affiliated with Nous Research, Anthropic, OpenAI or GitHub.

Which $100 fits which user

You work mostly in Claude models, one or two agents at a time. Max 5x. Watch Fable's share of the weekly limit and how fast parallel agents drain it. If the weekly limit is what stops you, Max 20x at $200 is the step up.

You keep hitting a five-hour wall. ChatGPT Pro $100's page says it has no five-hour limit right now, while Claude Max keeps one. (Copilot Max states no window at all, only a monthly pool.) Pick your model on purpose: Astra costs five times Sol's credits per token.

You want a hard dollar budget, or Claude and OpenAI models on one bill. Copilot Max. Plan around the 10,000 base credits and treat the flex half as a bonus that can change.

If you've run two of these plans side by side, which one ran out first, and on what kind of work?

If this was useful

Spend per session is one of the first numbers worth putting on any LLM dashboard, and the LLM Observability Pocket Guide covers the tracing and cost tools that give you that number for your own LLM apps. For the coding agents you already pay for, download Hermes IDE and run two of them side by side for a week. If it helps, star it on GitHub so other developers find it.