Tokens, Credits, and How to Check Them
Standard Chat still processes tokens and remains subject to the message and reasoning limits of your plan. OpenAI's current documentation lists Work and Codex — not standard Chat — as drawing from the shared agentic credit pool.[1]
Availability note: ChatGPT Work is gradually rolling out to eligible accounts.[1] If Work does not appear in your account yet, use Chat for planning and Codex for technical file execution where available.
| Environment | What You Experience |
|---|---|
| Standard ChatGPT Chat | Plan-specific model, message, and reasoning allowances |
| Work and Codex | Shared agentic usage structure; additional use may consume credits |
| OpenAI API | Separate API account billing based on model token rates in USD — not ChatGPT subscription credits |
How to check your usage
Open Codex Settings → Usage on ChatGPT web or in the Codex app.[2] Depending on your plan and workspace role, the dashboard may show recent usage, remaining credits, purchase options, and auto top-up controls. If you cannot add credits yourself, ask your workspace owner or admin.
Your plan's included usage is consumed first. Purchased credits are used after included limits are reached for supported features.[2]
Standard Chat usually presents plan or model limits rather than a detailed per-conversation token ledger.
Why output tokens cost more
On the current Codex rate card, output tokens cost approximately six times as many credits per token as ordinary input tokens.[3] For standard GPT-5.5, the rates are 125 credits per million input tokens and 750 credits per million output tokens.[3] However, in long agentic tasks, input tokens often dominate total cost because the same context is reprocessed across turns.[8]
Standard GPT-5.5 costs 125 credits per million input tokens, compared with 18.75 for GPT-5.4-Mini.[3] A typical Codex task using GPT-5.5 may consume between 5–45 credits depending on context size and iteration.[3] Use the smallest model capable of the task. The current rate card also includes the newer GPT-5.6 Sol, Terra, and Luna tiers; check the live rate card before choosing a model because availability and pricing can change.[3]
Need the full Projects, files, Memory, Work, and Tasks system?
This page focuses on token economics and routing. The companion guide shows how to organize the complete ChatGPT workflow around durable project context and human review.
Read the ChatGPT Workflow Guide →Chat vs Work vs Codex: Which Mode Should You Use?
The five-second routing test
Ask three questions. The first match wins.
The Context Lifecycle: Explore → Freeze → Execute → Verify → Learn
This is the central framework of this guide. It explains how context should transform between stages of any AI-assisted task — not just how to write a shorter prompt.
Explore — use Chat
Clarify the problem. Compare approaches. Surface assumptions. Define success. The output is a better-defined problem, not the finished work.
Freeze — create a durable task artifact
Convert the conversation into a structured file: TASK.md, PLAN.md, an audit manifest, or a decision record. This freezes the agreed target before execution begins. It survives a new thread, a different model, a two-day pause, or independent review.
Execute — use Work or Codex
Load the frozen artifact, not the full exploratory conversation. In the ChatGPT desktop app, Work can use approved local files and desktop applications with your permission.[1] Work on web and mobile operates in the cloud and cannot directly open arbitrary folders on your computer.[1] Codex remains a separate view for technical work with local folders, repositories, terminals, and developer tools.[1]
Verify — use a clean evidence pass
Verification starts from the specification, acceptance criteria, resulting files, and test suite. It does not rely on the implementation agent's memory of what it intended to do.
Learn — update durable instructions
When a failure pattern repeats, add a rule to your governance file, update the validator, or improve the task template. OpenAI's Codex guidance recommends keeping durable instructions in AGENTS.md and updating them after observed recurring mistakes.[5]
Context Debt and the Three Kinds of Context
Context debt is the future cost created when temporary explanations, corrections, exceptions, and unresolved decisions accumulate without being consolidated into the source of truth.
- Correcting the same rule five times in one chat
- Leaving both old and new URLs in the project
- Continuing after the agent adopts the wrong interpretation
- Adding "also don't change…" after every failed attempt
- Keeping rejected plans inside the execution conversation
Every later request must process the original instruction, the mistake, each correction, each exception, and the final decision. That increases both usage and the chance of choosing the wrong version.
When the third correction arrives, stop patching the conversation. Rewrite the task or update the source-of-truth file.
The three kinds of context
Durable Context
Brand rules, coding standards, canonical links, folder structure
Task Context
Current outcome, affected files, constraints, acceptance tests
Conversation Context
Questions, rejected ideas, exploratory reasoning, temporary clarifications
Do not use the conversation as the project database.
Projects in ChatGPT can provide cross-chat continuity, and project-only memory can isolate one project from unrelated conversations.[4] But OpenAI's documentation describes Projects as a context boundary — not a guarantee that every historical detail will always be retrieved correctly. Critical state belongs in explicit project files.
Same Chat, Fresh Chat, Project, or Branch?
Do not create a new chat for every phase. Create a new chat when the context changes more than the task benefits from continuity.
| Need | Correct Action |
|---|---|
| Continue the same agreed task | Stay in the thread |
| Continue with cleaner context | Create a handoff packet + fresh thread |
| Explore an alternative without disturbing the original | Branch the conversation |
| Isolate project rules from personal memory | Use project-only memory |
A branch preserves optionality. A handoff preserves continuity. They solve different problems.
Behavioral triggers — start a new thread when the model:
- Reopens a settled decision
- Reads the same files repeatedly
- Reintroduces a previously fixed error
- Cannot state the current acceptance criteria accurately
Context health check
Before continuing, state:
1. The current outcome
2. The locked decisions
3. The files in scope
4. The do-not-touch constraints
5. The remaining acceptance tests
Do not continue the work yet.Memory guidance
| Use Saved Memory For | Use Project-Only Memory For | Do Not Rely on Memory For |
|---|---|---|
| Stable preferences, response style | A specific website, one client, a confidential area | Exact prices, URLs, release numbers, acceptance tests, legal rules |
Memory personalizes. Files govern.
Handoff generator
A general summary describes what was discussed. A handoff packet states what the next agent needs to act correctly.
Codex Efficiency: Search Radius, Reasoning, and Checkpoints
The NotebookLM Guide Search Radius framework
Imprecise file directions cause Codex to search widely, inflating context before work begins.
| Radius | Instruction | When |
|---|---|---|
0 — Exact target | Edit /assets/nav.js only. | Known single-file fix |
1 — Bounded family | Inspect /assets/ and HTML nav markup. | Known file category |
2 — Repository discovery | Search for all instances of the pattern. | Unknown location, known pattern |
3 — Open exploration | Search the entire repository. | Unknown location and pattern |
Spend intelligence on ambiguity, not on file count. A change across 100 files may be mechanically simple. A one-line bug may require deep reasoning.
Reasoning and model routing
| Task | Reasoning Level |
|---|---|
| Rename a label in known files | Low |
| Repair a reproducible CSS bug | Medium |
| Diagnose an unknown cross-page regression | Medium–High |
| Design a new architecture | High |
| Run a long, ambiguous migration | High–Extra High |
Checkpoints
A checkpoint is a known-good version. After every successful issue family, run the tests, inspect representative outputs, save the state, record what changed, and begin the next issue from that state. When a repair fails, revert to the checkpoint.
Retry from a clean state, not from accumulated damage.
Correction-to-rule feedback loop
Mistake → Root cause → Preventive rule → Automated check → Update source of truthThe best instruction is not the one you write before the first run. It is the rule extracted from a real failure and then enforced automatically.
Verification Independence
| Level | Method | Strength |
|---|---|---|
1 — Self-check | Same agent runs tests after changes | Fast; vulnerable to its own assumptions |
2 — Fresh context | New thread receives spec + files + tests, not the repair conversation | Independent judgment |
3 — Deterministic + human | Validators + tests + link checks + screenshots + human inspection | Highest reliability |
The verifier should inherit the requirements, not the implementer's excuses.
What Happened When We Asked AI to Repair a 288-File Website
The original request
We uploaded a 288-file website ZIP to ChatGPT Work and asked it to fix all CRO, SEO, navigation, Stripe, and mobile issues in one run.
Why it failed
Five governing documents contained contradictions — old component names alongside new ones, conflicting CTA text, multiple Stripe URLs for the same product. The model followed one document and violated another.
The repeated pattern
Fix navigation → break layout. Fix layout → reintroduce old selectors. Fix selectors → duplicate CTAs. Each repair created the next problem because context debt accumulated faster than it was resolved.
What actually worked
Decomposing into the Context Lifecycle: a single source-of-truth file (Explore + Freeze), one issue family per Codex run (Execute), independent validators (Verify), and converting every repeated mistake into a governance rule (Learn).
Measured results
Observed usage data from a measured release cycle will be published here after the next deployment. We will not publish estimated savings percentages — only measured credits, runs, and rework rates.
Copy-Ready Prompt Templates
Chat preflight — turn a request into a task packet
Codex repair — execute a frozen task
Independent verification
Cost Per Verified Outcome and the Maturity Model
Agentic Efficiency =
Verified outcomes completed ÷ Agentic usage consumed
First-Pass Success Rate =
Repairs passing all checks on first attempt ÷ Total repaired issues
Rework Rate =
Issues reopened after completion ÷ Issues marked completed
Context Debt Ratio =
Superseded or contradictory instructions ÷ Active authoritative instructionsThe AI Usage Maturity Model
Prompting
You write better requests. One prompt at a time.
Routing
You choose Chat, Work, or Codex correctly.
Task Specification
You define outcome, constraints, and done conditions before execution.
Externalized State
Plans, decisions, and instructions live outside the conversation.
Verified Execution
Every outcome has deterministic evidence. Verification is independent.
Learning System
Failures update governance, validators, and templates automatically.
Prompt engineering improves one request. Workflow engineering improves every future request.
The Decision Card
Keep this accessible during every session.
- Do I need an answer or a file change?
Answer → Chat. Artifact → Work. Code → Codex. - Is the outcome testable?
If not, define acceptance criteria in Chat first. - Is this one root-cause family?
If not, create separate task packets. - What is the canonical source of truth?
Name it. Define precedence. - What must not change?
State exclusions explicitly. - Can one shared change solve it?
Check before allowing per-instance edits. - What is the search radius?
Name exact files. Expand only with evidence. - What evidence will prove success?
Commands, tests, diffs, files, inspections. - Am I measuring or guessing?
Label estimates. Record observed usage.
Frequently Asked Questions
Yes. Chat processes tokens internally. However, OpenAI's current documentation lists Work and Codex—not standard Chat—as drawing from the shared agentic credit pool. Standard Chat operates under plan-specific message and reasoning limits.
Standard Chat generally does not draw from the agentic credit pool. Work and Codex share that pool. Using Chat for planning and interpretation preserves this more constrained capacity.
Yes. OpenAI states that Codex, ChatGPT Work, ChatGPT for Excel, and Workspace Agents draw from the same agentic usage and credit pool when those features are available on your plan.
Use Chat when you need an answer, comparison, decision, or help defining a task—anything that does not require changing files or producing a finished multi-source deliverable.
Use Codex when the task requires changing files, running terminal commands, executing tests, inspecting diffs, or creating deployment packages.
Not automatically. A new chat resets context and eliminates accumulated stale information, but you may need to re-establish context if the task depends on prior work. Start a new chat when the context changes more than the task benefits from continuity.
Longer conversations generally require more context to be carried forward. ChatGPT and Codex may also compact or summarize earlier state near the context limit, so the exact context processed is not necessarily the full verbatim transcript on every turn.
Agentic tasks can consume orders of magnitude more tokens than simple conversations, with input tokens driving the overall cost. Model choice matters: standard GPT-5.5 costs 125 credits per million input tokens versus GPT-5.4-Mini at 18.75.
Open Codex Settings, then the Usage dashboard on ChatGPT web or in the Codex app. Depending on your plan and workspace role, the dashboard may show recent usage, remaining credits, purchase options, and auto top-up controls.
Context debt is the future cost created when temporary explanations, corrections, exceptions, and unresolved decisions accumulate without being consolidated into the source of truth. It compounds with every exchange and increases both usage and error rates.
No. A short, ambiguous prompt can cause the model to explore multiple wrong approaches, consuming far more tokens than a longer, precise instruction. Clarity is more cost-efficient than brevity.
The Context Lifecycle is a five-stage framework: Explore (clarify in Chat), Freeze (write durable task artifacts), Execute (use Work or Codex with the frozen spec), Verify (test against the spec independently), and Learn (update governance from observed failures).
Track Agentic Efficiency = Verified Outcomes divided by Usage Consumed. Also track First-Pass Success Rate and Rework Rate. Only quantify savings after three or more cycles of measured data.
ChatGPT Work is gradually rolling out to eligible accounts. Availability depends on your plan, workspace settings, role, and rollout status. If Work does not appear yet, use Chat for planning and Codex for technical file execution where available.
Get every workflow system for $49.99
Sovereign OS includes the complete Research, Studio, Content, Multi-AI, Academic, and Licensure workflow library. It costs less than three focused collections and includes permanent access.
Build a reliable multi-AI operating system
Get task-routing prompts, orchestration frameworks, handoff patterns, and verification checkpoints for working across multiple AI tools.
Sources and Methodology
- [1] OpenAI Help Center. "ChatGPT Work and Codex." help.openai.com
- [2] OpenAI Help Center. "Using Credits for Flexible Usage in ChatGPT." help.openai.com
- [3] OpenAI Help Center. "Codex Rate Card." help.openai.com
- [4] OpenAI Help Center. "Projects in ChatGPT." help.openai.com
- [5] OpenAI Developers. "Best Practices — Codex." developers.openai.com
- [6] OpenAI Developers. "Using Goals in Codex." developers.openai.com
- [7] OpenAI Developers. "Compaction." developers.openai.com
- [8] Bai, L. et al. (2026). "How Do AI Agents Spend Your Money? Analyzing and Predicting Token Consumption in Agentic Coding Tasks." arXiv:2604.22750. arxiv.org
- [9] r/ChatGPT. "Long ChatGPT chats go bad…" reddit.com
- [10] r/codex. "Best Practices and workflows." reddit.com
Methodology
All product claims are based on official OpenAI documentation as of July 23, 2026. Behavioral claims about token consumption variability cite preprint research (Bai et al., 2026, arXiv — not peer-reviewed). Practitioner patterns cite Reddit and practitioner publications. Cost comparisons use relative terms. Savings claims describe what the workflow is designed to reduce — not observed measurements, unless explicitly labeled as measured data from a specific project cycle. Product boundaries, credit systems, and pricing may change. Verify current details at help.openai.com.
Start with one repeatable AI research workflow
Get practical workflows, copy-ready prompts, and a review checklist before you build a larger multi-AI system.
Get the free Starter Kit →Privacy and responsible AI use
Know what to upload, what to de-identify, and when sensitive work requires an approved organizational environment.