OpenAI's GPT-5.6 Codex Rate Card Makes Agent Budgets a Routing Problem

Rohit Ramachandran

Jul 14, 2026Updated Jul 14, 2026

• ai
• openai
• gpt-5-6
• codex
• agents
• pricing

OpenAI's GPT-5.6 Codex Rate Card Makes Agent Budgets a Routing Problem

OpenAI has now shown teams what GPT-5.6 costs inside Codex. The surprise is not that Sol costs more than Terra, or that Luna is the cheap tier. We knew the API ladder already.

The consequential line is lower on the page: Codex, ChatGPT Work, ChatGPT for Excel, and Workspace Agents can draw from the same agentic usage and credit pool.

That turns a model-setting decision into an organization-wide allocation decision. A developer choosing Sol for a long refactor, a finance analyst running an Excel agent, and an operations team leaving a Workspace Agent on a recurring job may be spending from the same finite budget. They are not merely selecting different OpenAI products. They are competing for shared agent capacity.

Our GPT-5.6 general-availability analysis argued that Sol, Terra, and Luna should be treated as a routing system. The new official Codex rate card makes that argument operational. It gives every tier a token-based credit price and exposes the accounting layer beneath OpenAI's agent products.

The obvious response is to tell people to use Luna more often. That is too shallow. The useful response is to redesign defaults, evals, observability, and budget ownership around one equation: which model produces an accepted result with the least pooled capacity?

What OpenAI published—and what it did not

OpenAI moved most Codex customers from approximate per-message pricing to token-based credits in April 2026. The July update is important because the rate card now names the GPT-5.6 family and its exact credit rates.

The rates preserve a clean 5:2.5:1 ratio from Sol to Terra to Luna. They also mirror the family's published API list-price ratios: $5/$30 for Sol, $2.50/$15 for Terra, and $1/$6 for Luna per million input/output tokens.

Numerically, the Codex card equals 25 credits for every $1 of API list price. That is useful for comparison, but it is not permission to call a credit four cents on every plan. Credits are a product accounting unit. Included allowances, top-ups, enterprise contracts, expiration, and plan rules determine what a credit means to a particular buyer.

OpenAI also says GPT-5.6 Codex usage averages roughly 5–40 credits per message. Treat that as an average estimate, not a fixed quote. The same prompt can consume different amounts because repository context, conversation history, reasoning, tool output, caching, retries, and generated output all affect the meter.

Two boundaries are easy to miss. GitHub Code Review currently uses GPT-5.3-Codex, so its reviews should not be costed with the GPT-5.6 rows. And a small subset of Enterprise customers remains on OpenAI's legacy per-message card; workspace migration status wins over any generic calculator.

One equation explains most of the bill

For a Codex task, the published calculation is straightforward:

credits =
  (fresh input tokens × input rate
  + cached input tokens × cached-input rate
  + output tokens × output rate) / 1,000,000

The useful part is not memorizing the formula. It is seeing the ratios hiding inside it.

That six-to-one output premium deserves more attention than it will get. A thousand output tokens cost the same credits as 6,000 fresh input tokens or 60,000 cached input tokens. Teams often obsess over shaving a system prompt while letting agents narrate every step, generate giant reports, retry entire patches, or launch parallel workers that each produce overlapping prose.

The rate card says those priorities are backwards. Context hygiene matters, but unbounded generation is the fastest ordinary way to turn autonomy into burn.

Here are three illustrative tasks using the published formula. These are not OpenAI estimates; they are transparent RohitAI scenarios so you can substitute your own token traces.

The model ratio is linear, but outcome quality is not. Luna at one-fifth the Sol rate is a bargain only if it completes the task without enough retries or human cleanup to erase the saving. That is why a useful eval reports credits per accepted output, not credits per attempt.

One wallet now sits beneath four products

The shared pool changes who needs to care about agent cost.

OpenAI's agent surfaces can consume one allowance; routing and budget policy decide which work receives premium model capacity.

On Plus and Pro, OpenAI says supported agentic features can draw from the same allowance, and eligible users can enable automatic top-ups on a shared credit balance. On Business, users start with per-seat included limits, then can draw from workspace credits after they exhaust those limits. Enterprise and Edu flexible-pricing workspaces use a contract-level shared pool, with admins able to set controls by group. Exact availability and contract terms vary, so the plan-specific credit documentation still matters.

But the product direction is clear: OpenAI is unifying agent consumption before most companies have unified agent budgeting.

That creates a cross-surface externality. Imagine a 100-person company:

• Engineering runs Codex on migrations and PR work.
• Finance uses ChatGPT for Excel during quarter-end.
• Sales operations schedules Workspace Agents to refresh account plans.
• Strategy uses ChatGPT Work for long research and presentation tasks.

Each team may be acting rationally against its own goals. Collectively, they can still drain the pool at the wrong moment. A quarter-end Excel spike could reduce headroom for a release-critical coding push. A recurring agent that quietly expands its output could consume capacity nobody assigned to it. Auto top-up can prevent interruption, but it can also turn missing attribution into a larger invoice.

This is why the shared-pool detail matters more than another benchmark win. It makes AI capacity resemble cloud capacity: centrally purchased, locally consumed, and easy to waste when ownership is fuzzy.

Sol, Terra, and Luna are now service classes

The cleanest way to use the family is not to pick a favorite. Treat each tier as a service class with an explicit promotion rule.

Because every GPT-5.6 tier uses the same input/cache/output weights, there is no special token mix where Sol suddenly becomes relatively cheaper. Quality creates the break-even. Under the simplifying assumption that each attempt uses the same weighted token trace, a Terra preflight followed by Sol escalation beats starting on Sol only while fewer than 50% of tasks escalate. A Luna preflight plus Sol escalation wins below an 80% escalation rate. Real traces differ, but those thresholds give an eval team a concrete hypothesis to test.

There is a second dimension: context. OpenAI's ChatGPT Business model page lists a 272K context window for Sol and 128K for Terra and Luna. A larger window is a capability ceiling, not a consumption target. Filling Sol's listed window with fresh input would consume 34 credits before it generated a token; filling 128K on Terra would consume 8 credits, and on Luna 3.2 credits.

That comparison is illustrative because real tasks rarely fill the window once, cleanly. Agents read files, receive tool results, carry conversation history, and revisit material. The point is that context capacity is also spend capacity. “Give it the whole repository” is not a harmless convenience when the model repeatedly processes irrelevant material.

Caching changes the answer. Across GPT-5.6 tiers, cached input is priced 90% below fresh input. Stable instructions, reusable repository context, and repeated reference material can therefore be much cheaper on subsequent use. OpenAI's own Codex usage guidance recommends tighter prompts, narrower source material, smaller scoped AGENTS.md files, and fewer unnecessary MCP servers because each source adds context.

The design lesson is subtle: do not merely shorten prompts. Separate stable context worth caching from dynamic context worth reading once.

stable: repository rules, architecture map, schemas, recurring rubrics
dynamic: current diff, failing test, live logs, task-specific files
discard: unrelated directories, stale tool output, duplicated narration

That structure improves both cost and agent focus.

One caveat: the Codex card publishes cached-input rates, but it does not publish a separate cache-write charge or guarantee which repeated tokens will qualify as cached. Do not import API caching rules into a ChatGPT-plan forecast. Verify the usage data from the actual Codex workflow.

Output is the autonomy tax

The six-to-one output premium changes how agent workflows should be designed.

An agent can spend output on a useful patch, a decision memo, or a verified artifact. It can also spend output on duplicate plans, verbose progress updates, repeated file rewrites, speculative alternatives, and subagents that rediscover the same facts. The meter does not care which kind you wanted.

This makes three common defaults expensive:

1. Unlimited narration. Asking for every thought and every intermediate detail creates text that may not improve the deliverable.
2. Whole-task retries. Restarting from the original prompt discards useful state and often regenerates material that was already correct.
3. Parallelism without partitioning. Multi-agent work can reduce wall-clock time, but overlapping assignments create duplicate output and a larger synthesis burden.

The earlier GPT-5.6 GA article covered why ultra is best understood as productized parallelism. The rate card adds the missing management rule: every extra workstream needs a reason to exist. Parallel agents should own independent evidence, files, or hypotheses. If their outputs cannot change the final decision, they should not be running.

OpenAI says credit use varies with model, context, reasoning, and tools. A short final answer therefore does not prove a cheap run. The only reliable method is to inspect the usage trace and connect it to the accepted result.

Fast mode needs a footnote, not a guessed multiplier

The Codex rate card warns that Fast mode consumes credits more quickly for supported models. That is worth budgeting for—but the current OpenAI Speed documentation names GPT-5.5 and GPT-5.4 as the supported models, at 2.5× and 2× their standard credit rates respectively. It does not publish a GPT-5.6 Fast-mode multiplier on that page as of July 14.

So do not multiply the GPT-5.6 numbers by an assumed premium and present it as fact. Check the live Speed page and your product settings when OpenAI adds or changes support.

The broader rule still holds. Speed is a paid service level. A persistent fast default does not merely make one developer happier; in a shared pool, it reallocates capacity away from other work. Use it where latency changes the business outcome—interactive debugging, incident response, or a human waiting in the loop—not for unattended jobs that can finish later.

The RohitAI read: defaults have become procurement policy

OpenAI is converging on a single agent economy across coding and knowledge work. That has three consequences that are easy to miss.

The first prediction is that enterprise model pickers will become policy engines. Teams will define routes such as “Luna by default, Terra after one failed rubric, Sol only above a risk or value threshold.” Users may still see model names, but the durable setting will be a budget-aware router.

The second prediction is that shared pools will need reservations. Engineering will want guaranteed capacity before a release. Finance will want a temporary allocation during close. Operations will want recurring agents capped independently. OpenAI already exposes group controls and usage reporting in some plans; customer demand will push those tools toward workload budgets, not only broad workspace limits.

The third prediction is that agent products will become more concise on purpose. Good agents will retain rich internal state but emit smaller, structured handoffs: diffs instead of rewritten files, deltas instead of full reports, evidence indexes instead of copied sources, and checkpoints instead of complete restarts. The rate card rewards that architecture.

A builder eval that matches the new economics

Do not run one benchmark prompt on three models and declare a winner. Replay real work and record the whole path.

For each workflow, capture:

surface
team / cost center
workflow name and task class
model and effort setting
fresh input, cached input, output
credits consumed
wall-clock time
tool calls and retries
human review minutes
accepted / rejected / escalated

Then compare three metrics:

• Credits per accepted task reveals the actual model-routing efficiency.
• Human minutes per accepted task catches cheap models that create expensive cleanup.
• Pool share per business outcome shows whether one workflow is crowding out higher-value work.

Start with 30–50 representative tasks per category. Include routine work, difficult work, failure cases, long-context tasks, output-heavy artifacts, and tasks that use tools. Keep the acceptance rubric fixed. A routing rule is only credible if it survives the ugly tasks, not just the demo set.

What I would change this week

For an individual Codex user, the immediate move is simple: check the usage dashboard, stop treating Sol as the harmless default, and tighten output requirements. Use Terra on ordinary work and test Luna on bounded tasks where verification is cheap.

For a team, add a weekly report that joins usage with workflow outcomes. A list of top consumers is less useful than a list of expensive failed tasks. Look for long sessions with low acceptance, repeated full-context reads, large final outputs, and automation that runs more often than anyone uses its result.

For a workspace admin, define policy before turning on automatic recharge. Decide who owns the pool, who can approve exceptions, which teams need reserved headroom, and what happens when credits run out. OpenAI says Business users can be blocked when included usage and shared credits are exhausted; Enterprise and Edu advanced features can pause unless overages or more credits are enabled. That failure mode belongs in an operating plan, not a surprise banner.

For product builders choosing between ChatGPT-plan agents and the API, keep the ledgers separate. API pricing is direct dollar-per-token consumption. ChatGPT products combine included allowances, credits, plan rules, and shared surfaces. The published rates line up numerically, but governance and failure behavior differ. Choose a surface for its controls and workflow fit, not because a rough conversion makes the cost look identical.

FAQ

What are the GPT-5.6 Codex credit rates?

Per one million tokens, OpenAI lists Sol at 125 input, 12.5 cached-input, and 750 output credits; Terra at 62.5, 6.25, and 375; and Luna at 25, 2.5, and 150.

Do Codex credits have a fixed dollar value?

OpenAI describes credits as a consumption and tracking unit. The GPT-5.6 credit rates numerically map to 25 credits per $1 of published API list price, but included usage, top-up pricing, enterprise contracts, and plan terms vary. Do not treat that observation as a universal cash conversion.

Which OpenAI products share the agentic credit pool?

The rate card names Codex, ChatGPT Work, ChatGPT for Excel, and Workspace Agents when those features are available on the customer's plan. OpenAI's Business rate card also says ChatGPT for PowerPoint joins the Business/Enterprise pool once its token-based pricing takes effect.

Why do output tokens matter so much?

Across Sol, Terra, and Luna, an output token consumes six times the credits of a fresh input token and 60 times the credits of a cached input token. Long artifacts, retries, and duplicated subagent output can therefore dominate a task's usage.

Does Fast mode make GPT-5.6 more expensive in Codex?

OpenAI says Fast mode uses credits at a higher rate for supported models. At publication, its Speed page lists GPT-5.5 and GPT-5.4 multipliers but no GPT-5.6 multiplier. Check the live documentation rather than assuming one.

Which GPT-5.6 model should be the default?

There is no universal answer. My starting policy would be Luna for bounded and reversible tasks, Terra for most daily work, and Sol for high-value uncertainty or escalation. Promote based on a measured acceptance rubric.

How should teams control a shared agent budget?

Attribute usage by surface and workflow, measure credits per accepted task, cap output, route models by value, reserve critical capacity, alert on abnormal burn, and agree on auto top-up or hard-stop policy before usage spikes.

Final take

OpenAI's new rate card makes GPT-5.6 easier to price and harder to manage casually.

The arithmetic is clean: Sol costs five times Luna, Terra sits halfway, cached context gets a deep discount, and output is expensive. The organizational reality is messier: coding, spreadsheets, workspace agents, and long-form work can now meet in one budget.

That is the shift builders should act on. Model selection is no longer a personal taste or a leaderboard debate. It is scheduling for scarce agent capacity.

The teams that win will not always choose the cheapest model. They will know when a more expensive model reduces retries, review, and risk enough to be cheaper per accepted outcome. They will also know when a premium default is merely burning shared headroom.

GPT-5.6 is now an economic system, not only a model family. Treat the router, the output contract, and the credit pool as part of the product architecture.