Lesson 19 of 38 · Core - 00:30-00:45
Accounts, pricing, usage, and token reality
Master the real economics of agentic tools: which plans unlock Codex and Claude Code, exactly how usage is metered in 2026, how tokens convert to cost, and the concrete habits that make a $20 plan outlast a careless $200 one.
Agentic tools feel free until you hit a wall mid-task - usually at the worst moment, halfway through a refactor or a report. Both OpenAI's Codex and Anthropic's Claude Code gate access behind paid subscriptions and meter consumption, but they meter it differently, and in 2026 the metering model itself changed. Understanding the economics is not an accounting chore; it is a workflow skill. The operators who get the most out of these tools are not the ones on the biggest plans - they are the ones who understand where tokens actually go and design their sessions to spend them where they create value. This lesson gives you the current numbers, the why behind the pricing design, and a repeatable habit set for stretching any plan.
The economics of agentic tools, at a glance
Plans, token metering, and the habits that keep cost down.
The economics of agentic tools
A branded walkthrough: how Codex and Claude Code are metered by tokens in 2026, how plan tiers and headroom work, and the habits that keep spend down.
What to understand
- Access is gated, and the gates differ. Codex is included with paid ChatGPT plans (Plus, Pro, Business, Edu, Enterprise) and some Enterprise workspaces require an admin to switch it on. Claude Code is included with Claude Pro, Max, Team, and Enterprise, or used via a Claude Console (API) account billed per token. There is no free path to either coding agent - budget for it like a tool licence, not a trial.
- The metering model changed in 2026 - this is the single most important update. On 2 April 2026 OpenAI moved Codex from simple per-message limits to API-token-aligned usage for Plus, Pro, Business and new Enterprise plans. That means your consumption is now measured the way the API measures it - by tokens in and out - even on a subscription. Old advice built around 'messages per day' is stale; think in tokens.
- Anthropic meters on rolling windows plus weekly caps. Claude Code usage is measured in rolling 5-hour windows, and Max plans add two weekly limits - one across all models and a separate one for Sonnet - that reset seven days after a session starts. The practical effect: a single marathon session can exhaust a window, but pacing work across windows keeps you productive all week.
- Tiers are sold on headroom, not raw counts. Plus and Claude Pro are the $20 baseline (1x). The $100 tiers (ChatGPT Pro 5x, Claude Max 5x) and $200 tiers (ChatGPT Pro 20x, Claude Max 20x) multiply that headroom roughly 5x and 20x. You are buying a usage multiplier and priority, not a fixed token wallet - which is why matching the tier to your real usage shape matters more than chasing the biggest number.
- Tokens are the atomic unit of cost. A token is a chunk of text (roughly 3-4 characters of English); the agent spends tokens on everything it reads (your prompt, files, prior turns, tool output) and everything it writes. A dense page of text is several hundred tokens. The cost you feel is dominated by context size, not by how clever your question is.
- Agentic loops are structurally token-hungry. Each read-propose-act-observe cycle re-feeds the working context, so a long, unfocused session quietly multiplies consumption - every new turn re-pays for the accumulated history. This is why a 90-minute wandering session can cost more than ten tight 5-minute ones that do the same work.
- The levers that actually move cost (in order of impact): keep the context small (only load the files the task needs); clear context between unrelated tasks (Claude Code's /clear, a fresh Codex task); prefer one well-specified prompt over several vague retries; and on Console/API, set admin spend limits so a runaway loop can't run up a bill. A 'Claude Code' workspace is auto-created on the API path specifically for centralised cost tracking.
- Match the model to the job to control cost and quality together. Frontier models (Claude Opus, GPT-5.x) are worth it for hard reasoning and complex refactors; lighter/faster models (GPT-5.x-mini, Claude Sonnet/Haiku) are far cheaper per token and fine for routine edits, summaries, and boilerplate. Defaulting everything to the top model is the most common silent overspend.
Deeper dive
Why subscriptions meter usage at all (the why behind the wall)
Frontier-model inference is genuinely expensive to run - GPUs, memory, and energy scale with every token processed. A flat $20/month cannot cover unlimited frontier-model agent loops, which can each consume hundreds of thousands of tokens. Metering is how providers offer a predictable consumer price without losing money on power users. Understanding this reframes 'hitting a limit' from a punishment into a signal: you've consumed real compute, and the limit is protecting the economics that keep the $20 tier viable. The operator response is to spend that allowance deliberately.
Subscription vs API: two mental models
A subscription (Plus/Pro/Max) is an all-you-can-eat-within-limits buffet: fixed price, capped throughput, no per-task bill to track - best when your usage is steady and personal. The API/Console path is metered electricity: you pay for exactly what you use, you can set hard spend caps, and you get per-task cost attribution - best when a team shares the bill or you need cost accountability. Many professionals run both: a subscription for daily interactive work, an API key for automated/scheduled jobs where per-run cost matters.
The token-budget habit, made concrete
Before a session, name the smallest set of inputs the task truly needs and load only those. During the session, watch for the moment the task changes - that's your /clear point; carrying a finished task's context into the next one is pure waste. After the session, note what it cost in time-to-result; the cheapest sessions are almost always the most sharply scoped ones. This habit is worth more than two tiers of plan upgrade.
How to read the benchmark table (and what it changes about model choice)
Below the pricing comparison you'll find a second table: frontier model benchmarks. A benchmark is a standard test suite used to compare models, and each column measures something different. The Intelligence Index is a blended score of general capability across many tasks - useful for ranking, useless for telling you whether a model can fix your specific bug. SWE-bench is a coding suite built from real software bugs; note that its Verified and Pro variants are different (harder) test sets, so an 88% on Verified cannot be compared against a 58% on Pro - the table's conflict note says exactly this. GPQA Diamond is graduate-level science reasoning, a proxy for how well a model handles genuinely hard thinking. Max context is how much material the model can hold at once - relevant when your task involves long documents or large codebases. The routing payoff: the gap between a frontier model and a light one is large on hard reasoning and small on routine edits, which is why the match-the-model-to-the-job habit above saves money without costing quality. Use the benchmark table as your reference for which model leads where - and re-check the live leaderboard before relying on any single number, because these shift week to week.
Plans & pricing compared
Monthly individual-plan pricing in USD. On 2 April 2026 OpenAI moved Codex from per-message limits to API-token-aligned usage for Plus, Pro, Business, and new Enterprise plans. Anthropic meters Claude Code on rolling 5-hour windows plus weekly caps. Limits below are approximate and change frequently, verify before relying on them.
| Plan | Price/mo | Coding agent | Usage headroom | Best-fit use |
|---|---|---|---|---|
| ChatGPT Plus | $20 | Codex included | Baseline Codex limits (1x) | Individuals trying Codex; light, scoped tasks |
| ChatGPT Pro (5x) | $100 | Codex included | ~5x Plus Codex limits | Daily Codex users; multi-task days |
| ChatGPT Pro (20x) | $200 | Codex included | ~20x Plus Codex limits | Heavy Codex / parallel cloud tasks |
| Claude Pro | $20 | Claude Code included | ~1x baseline; rolling 5h window | Individuals starting with Claude Code |
| Claude Max 5x | $100 | Claude Code included | ~5x Pro (~88k tokens / 5h window) | Daily Claude Code; longer sessions |
| Claude Max 20x | $200 | Claude Code included | ~20x Pro (~220k tokens / 5h window) | Power users; large repos, long runs |
| Console / API | Pay-as-you-go | Claude Code via API key | Billed per token; admin spend limits | Teams sharing a bill; cost tracking |
Sources (as of June 2026): OpenAI, Codex pricing · OpenAI Help. Using Codex with your ChatGPT plan · OpenAI Help. Codex rate card · Anthropic. Claude plans & pricing · Anthropic Help. What is the Max plan?
Frontier model benchmarks compared
Headline benchmarks for the leading frontier models as of June 2026. Model point-versions are released rapidly, so numbers and even version names shift week to week, always check the live leaderboard and the model's own release notes.
| Model | Intelligence Index | SWE-bench Verified (coding) | GPQA Diamond (reasoning) | Max context |
|---|---|---|---|---|
| Claude Opus 4.8 | 61.4 (1st) | 88.6% | Leads graduate-level science reasoning | ~200K in / 128K out |
| GPT-5.5 | 60.2 (2nd) | 58.6% (SWE-bench Pro) | Strong long-context reasoning | Up to ~1M context |
| Gemini 3.1 Pro | 57 (3rd) | 54.2% (SWE-bench Pro) | 94.3% GPQA Diamond (top) | 1M multimodal (text/img/audio/video) |
| Grok 4.3 | 53 (4th) | , | , | Large context |
Sources (as of June 2026): Artificial Analysis. Intelligence Index · LM Council. AI Model Benchmarks (Jun 2026) · DataCamp. Claude Opus 4.7 vs GPT-5.5
Where token cost actually hides
Each row is a real source of spend. Read left to right: what it is, why it quietly burns tokens, and the one lever that fixes it. Rows are ordered by impact, top = biggest.
Step by step
Confirm your Codex eligibility and metering model
Two sources, two facts. First, on developers.openai.com/codex/cloud (the page shown here), confirm the access gate: Codex web is included with paid ChatGPT plans - Plus, Pro, Business, Edu, Enterprise - and Enterprise workspaces may need an admin to switch it on. Second, open the Codex rate card and plan article on help.openai.com and confirm the metering model: since 2 April 2026 usage is metered as API-token-aligned consumption, not per-message. Check which plan your account is on and note your tier's multiplier (Plus 1x, Pro 5x at $100, Pro 20x at $200).
HintIf you're on Free, you cannot use Codex - plan the upgrade before you start, not mid-task.
On this screen
- 1What to notice. The plan list is an access gate - without an eligible plan the cloud task UI won't be usable.
- 2Enterprise needs an admin. The note that Enterprise workspaces may require admin setup is the second access gate - eligibility is plan + (sometimes) an admin switch, not plan alone.
Map the Claude plan ladder and windows
Open claude.com/pricing and the 'What is the Max plan?' help article. Write the four Claude Code rungs (Pro $20, Max 5x $100, Max 20x $200, plus Console/API pay-per-token) and note Claude's metering: rolling 5-hour windows, plus two weekly caps on Max (all-models and Sonnet-only) that reset 7 days after a session starts.
HintClaude sells usage headroom (5x/20x multipliers), not a fixed token count - ranges, not guarantees. Start on Pro and learn your real usage shape before paying for Max headroom you may not need.
Internalise the token unit with a real estimate
Take a real file or document you'd hand an agent. Estimate its tokens (≈ characters ÷ 4, or ≈ words × 1.3). A 2,000-word brief is ~2,600 tokens just to load - before any reply. Now imagine re-feeding that across ten agent turns. Write down the two most token-heavy things in your typical task (usually large files and long sessions).
HintContext is re-paid every turn - a big file loaded once is cheap; the same file carried through a 20-turn session is not.
Design a low-burn session
Rewrite one routed task from Lesson 2 using the production prompt pattern from this lesson: a tight role, an explicit file allow-list, 'read-only first / show the diff', and a brief-output instruction. Decide your /clear point before you start. Done when your rewritten prompt contains all four elements - role, file allow-list, read-only-first/show-the-diff, brief-output - plus a named /clear point.
HintOne precise, scoped prompt routinely costs a fraction of three vague ones plus the corrections they trigger.
Set a guardrail and a limit-handling rule
On Console/API or Enterprise, set an admin spend limit now. On a subscription, pre-decide your rule for hitting a window/weekly limit - pause, switch to a lighter model, or wait for reset - so you don't panic-upgrade mid-task. Pick the cheapest model that can do each class of task by default.
HintA pre-decided 'what I do at the limit' rule is worth more than the next plan tier.
Document your access path (plan + tool + metering model), rewrite one real task using the production low-burn prompt pattern with a file allow-list and a /clear point, and set either a spend limit (API) or a written limit-handling rule (subscription).
A one-page 'access and usage plan': your plan and what it unlocks, the 2026 metering model you're on, your model-selection defaults, your token-saving habits, and your limit-handling rule.
Production prompt examples
ROLE: You are a senior engineer working in a strict, cost-aware mode. CONTEXT: I am on a metered plan. Only the following files are in scope: src/lib/pricing.ts and its test file. Do NOT read or load any other files unless you first tell me which file and why, and I approve. TASK: Add a `formatCurrency(amountCents, currency)` helper to pricing.ts and a matching test. Match the existing code style in the file. CONSTRAINTS: - Work read-only first: show me your plan and the exact diff before writing anything. - Do not run shell commands, install packages, push, or touch git. - Keep your own reasoning brief - do not restate the whole file back to me. - If the task is ambiguous, ask one tight question rather than guessing. OUTPUT FORMAT: 1. One-line plan. 2. The proposed unified diff only. 3. A one-line note on anything you assumed.
- ROLE + 'cost-aware mode' primes the model to minimise its own verbosity (output tokens cost too).
- The explicit file allow-list is the single biggest token saver - it stops the agent from auto-loading the repo into context.
- 'Work read-only first / show the diff before writing' is the safety + cost gate: you approve before any token-heavy action.
- 'Keep your own reasoning brief / don't restate the file' directly caps output tokens, the part beginners forget is billed.
- 'Ask one tight question rather than guessing' prevents the expensive vague-retry loop that quietly doubles cost.
Common mistakes to avoid
- Assuming Codex or Claude Code is free - both sit behind paid plans, and Enterprise Codex may also need admin enablement.
- Using stale 'messages per day' mental models after the 2 April 2026 shift to token-aligned Codex metering.
- Loading an entire repo or long history into context for a question that only needed one file.
- Running one endless session across many unrelated tasks instead of /clear-ing between them - re-paying for accumulated context every turn.
- Defaulting every task to the top frontier model when a cheaper/faster model would do - the most common silent overspend.
- Upgrading to the 20x tier or buying credits before understanding your actual usage shape on a lower tier.
Source conflicts to review
- OpenAI's 2x temporary Codex boost was advertised 'through 31 May 2026', as of June 2026 assume it has ended; confirm current multipliers on the rate card.
- Third-party blogs disagree on exact token-per-window figures for Claude Max (e.g. ~88k vs other numbers); Anthropic publishes ranges, not fixed counts. Cite the official Max help article over blogs.
- Sources cite different Opus point-versions (4.6 / 4.7 / 4.8) and GPT versions (5.4 / 5.5) for the same comparisons due to fast release cadence, normalise to the latest version and date every figure.
- Coding scores are quoted on different suites (SWE-bench Verified vs SWE-bench Pro); do not compare a Verified score against a Pro score directly.
Key terms
- Token
- The unit of text an agent processes (~3-4 chars of English); reading and writing both consume tokens.
- Token-aligned metering
- OpenAI's 2026 model where subscription Codex usage is measured by API-style token consumption, not message count.
- Rolling window
- Anthropic's 5-hour usage window for Claude Code; consumption is measured within the window and resets as it rolls.
- Usage multiplier
- How tiers are sold - Pro/Plus = 1x, $100 tiers ≈ 5x, $200 tiers ≈ 20x the baseline headroom.
- Context
- Everything currently loaded into the agent's working memory for the session - all of it is re-paid in tokens each turn.
- /clear
- Claude Code's command to wipe the session context and start fresh - the main lever against re-paying for accumulated history. Full session controls are covered in Lesson 4.
- Frontier model
- A vendor's current most-capable (and most expensive per token) model - e.g. Claude Opus, GPT-5.x. The opposite end is light/fast models like Sonnet, Haiku, or mini variants.
- Benchmark
- A standard test suite used to compare models - coding (SWE-bench), reasoning (GPQA), or blended indices (Intelligence Index). Scores from different suites are not directly comparable.
- Spend limit
- An admin-set hard cost cap, available on Console/API and Enterprise plans.
Resources
Checkpoint