How to save tokens in ChatGPT: 13 ways to cut Codex credit usage

Short version: ChatGPT and Codex meter tokens, and turn them into credits. Model choice, context, reasoning effort, tool use, retrieval, and caching all move that number — which is why, as OpenAI puts it, prompt length alone is not a reliable estimate of what a message will cost you.

The good news is that the biggest levers are settings, not skills. Below are thirteen of them, in rough order of payoff.

The short list

What a credit actually costs

Credits are how OpenAI turns token usage into one number. The rate card, per million tokens:

Three things fall straight out of that table.

Sol costs twenty times what Luna costs on input, and sixteen times on output. Same tokens, same conversation. OpenAI’s own advice for people near their limit is to switch to a smaller model to make the allowance last longer.

Output costs five to six times input. A model that thinks longer and writes more is expensive on the expensive side of the ledger.

Cached input costs a tenth of fresh input. Every model. That is the largest free discount on the list, and the easiest one to lose.

For reference, OpenAI puts a typical GPT-5.6 message at 5–30 credits.

1. Pick the smallest model that clears the bar

The three GPT-5.6 models are built for different work, and the price gap is much larger than the capability gap on routine tasks:

• Sol — ambiguous, difficult, high-value work: complex code changes, deep research, polished documents.
• Terra — the everyday workhorse. Strong reasoning and tool use without Sol’s full depth. The natural home for most work.
• Luna — clear, repeatable tasks with a known-good shape: extraction, classification, transformation, structured summaries, focused coding.

Most people leave Sol on for everything and pay 20× for the privilege on tasks Luna would have finished. Default to Terra, drop to Luna for mechanical work, and reach for Sol deliberately.

One deadline worth noting: GPT-5.4 and GPT-5.4 mini retire from Codex on August 31, 2026. If you sign in with ChatGPT, replace gpt-5.4 with gpt-5.6-terra and gpt-5.4-mini with gpt-5.6-luna in saved configurations, custom agents, and scheduled tasks.

2. Use the lowest reasoning effort that works

Reasoning effort is the second dial, and it moves output tokens — the expensive kind. OpenAI’s guidance is explicit: use the lowest effort that produces the result you need, and raise it for tasks that need more planning or checking.

Above that sit Max, which gives one model more time on a single task, and Ultra, which fans work out across subagents. Both are expensive by design. OpenAI’s own summary: most tasks do not need Max or Ultra.

There is no exact mapping from GPT-5.5 efforts to GPT-5.6, so re-run a familiar task one notch lower and see whether the result still holds. Usually it does.

3. Turn fast mode off

Fast mode makes a supported model 1.5× faster and bills for it:

• GPT-5.6 and GPT-5.5 — 2.5× the standard credit rate.
• GPT-5.4 — 2× the standard rate.

/fast status tells you where you stand; /fast off fixes it. If you turned it on during one urgent afternoon and never turned it back off, this is likely the largest single correction available to you.

Image generation belongs in the same bucket: it draws on the same limits and burns them 3–5× faster on average than a comparable turn without it.

4. Start fresh instead of compacting

Codex has three ways out of a bloated transcript, and they are not equal:

• /new — a fresh chat inside the same CLI session. Carries nothing. Free.
• /clear — clears the terminal and the chat context together.
• /compact — replaces earlier turns with a summary. Useful, but it must read the transcript to summarize it, so on a large context it is a large request.

Compact when the thread has to continue. Start over when the task changes. The default human behavior — one enormous conversation per day — is the expensive one, because every turn in it re-sends everything before it.

5. Protect your cached input

Cached input costs one tenth of fresh input. Caching works on a stable prefix: the conversation from the start up to the point where something changed. Rewrite or reorder earlier context and everything after it re-bills at full price.

In practice this means: append rather than edit, avoid re-uploading a file you have already put in the thread, and keep dynamic content — timestamps, random IDs, shifting instructions — out of the front of your prompts and configuration.

6. Keep AGENTS.md short

AGENTS.md is concatenated from your repository root downwards and prepended to your requests, so every line is re-sent constantly. Files closer to the working directory override earlier guidance because they land later in the combined prompt.

Two rules: keep it tight, and push specifics down. Nested AGENTS.md files in the directories they describe cost nothing while you work elsewhere. Watch for truncation, too — if Codex reports instructions truncated, that is a signal to split large files across nested directories rather than to raise project_doc_max_bytes.

7. Point at files, don’t paste them

Pasting a file into the chat puts a permanent copy in the transcript, re-sent on every subsequent turn. Codex has cheaper ways to say the same thing:

• /mention src/lib/api.ts — attach a file by path.
• /ide — pull in open files and the current selection.
• Start Codex from the right directory. The working tree provides the file context; launching from the folder that matters keeps that context focused.

The same idea covers pasted logs. A hundred-line excerpt is context you pay for every turn afterwards; a path is not.

8. Prune MCP servers

Every connected MCP server adds tool definitions and instructions to the model’s view of the world, whether or not you ever call one. Disconnect the servers you are not using in this project, and keep the list per-project rather than global.

9. Push verbose work into subagents

Test runs, dependency audits, log analysis — anything whose output is long and whose conclusion is short belongs in a subagent. The noisy part lives in the subagent’s context; your thread receives the answer. This is the same reason Ultra exists, but you do not need Ultra pricing to get the isolation.

10. Account for what runs without you

On ChatGPT plans, local messages and cloud chats share one five-hour window, with weekly limits on top. Several things draw on it that are easy to forget:

• Cloud chats, which run on Sol and may use more of your allowance than the equivalent local message.
• Automations on their schedule.
• Code review and auto review on your pull requests.
• Image generation, at 3–5× the burn rate.
• Voice. It has its own minute-based allowance, but tasks started through Voice spend your ordinary Codex budget. On credit-billed workspaces, desktop Voice runs about 6 credits per minute.
• ChatGPT for Excel, on Plus and Pro.

If your allowance is vanishing faster than your typing explains, start here.

11. Read the meters

Two commands, both worth a weekly habit:

• /status — active model, approval policy, writable roots, current token usage, and remaining context capacity.
• /usage — account token activity, plus any earned rate-limit reset you can redeem. Jump straight to a view with /usage daily, /usage weekly, or /usage cumulative.

The web dashboard at chatgpt.com/codex/settings/usage shows your current limits. Checking it every week or two is enough to catch a bad habit before it costs you a whole window.

You can also put context and rate-limit fields into the CLI footer with /statusline, which is the cheapest possible form of monitoring: you see the context filling before it becomes a problem.

12. In the ChatGPT app: one task, one chat

The chat product hides the token counter, but the mechanics are identical.

Start a new chat when the task changes. A thread that has run all day re-sends its whole history with every message. A new chat starts at zero.

Use Projects for anything you reference repeatedly. Files, instructions and sources shared across a project’s chats stay available without being pasted into each one — and each chat keeps its own thread rather than mixing every message into a single context.

Keep memories deliberate. Memories carry context forward across chats, which is useful and is also context you did not explicitly ask to pay for. /memories controls it per chat; Settings → Personalization controls it globally.

Ask completely the first time. Plan the request, include the whole relevant snippet in one message, and batch related questions. Five follow-ups cost five full contexts; one good message costs one.

If you want the full map of the windows and caps themselves, we wrote it up separately: Codex usage limits, explained.

13. The lever you should not pull by hand

Everything above is manual discipline. It works — and it never ends. You will re-decide the model, the effort, and the compaction point several times a day for as long as you use these tools.

The mechanical part can be automated. Most of what a coding agent sends is context the model did not need for this request: a file it already read verbatim, a diff superseded three turns ago, boilerplate repeated in full every time. Which parts those are is a decision better made per request, by a machine, than by you at 4pm.

That is what Halv does. It runs on your machine in front of every request — same model, same Codex CLI, same ChatGPT plan — and rewrites the context before it leaves: duplicated files and stale history removed, error signals and anything that changes the answer kept, and a clean pass-through whenever a request cannot be compressed safely. A live meter shows exactly how many tokens each session avoided sending. It works with Codex, and with Claude Code, Kimi and GLM on their own subscriptions.

Roughly half the usage, for the same work. The five-hour window stays five hours; you just fit about twice as much into it.

Try it free — no card required.

The 60-second version

If you change only five things today:

1. /fast status — and turn it off if it is on.
2. Set Terra as your default model; use Luna for mechanical work.
3. Drop reasoning effort one notch and see if you notice.
4. /new when the task changes, instead of growing one thread.
5. Trim AGENTS.md and push the specifics into nested files.

FAQ

How do I reduce token usage in ChatGPT and Codex? Cheapest model that clears the bar, lowest reasoning effort that works, fast mode off, a new chat per task, a short AGENTS.md, files referenced rather than pasted, and unused MCP servers disabled. Model choice alone is a 20× spread. To do the same thing automatically, Halv compresses every request on your machine before it reaches the model — roughly half the usage on the ChatGPT plan you already pay for.

Which GPT-5.6 model uses the fewest credits? Luna — 5 credits per million input tokens and 30 per million output, against Sol’s 100 and 500.

Does fast mode use more credits? Yes. GPT-5.6 and GPT-5.5 bill at 2.5× the standard rate in fast mode; GPT-5.4 at 2×. Check with /fast status.

Does /compact or /new save more in Codex? /new. It carries nothing forward. /compact must read the transcript it summarizes, so on a large context it is itself a large request.

How do I check my Codex token usage? /status for the session, /usage (or /usage daily|weekly|cumulative) for the account, and the usage dashboard on the web for your current limits.

Do cached input tokens cost less in ChatGPT? A tenth of fresh input, on every current model. Keep the prefix of your conversation stable to keep it cached.

Does higher reasoning effort cost more in Codex? Yes — more tokens and more time. Use the lowest effort that gets the result; most tasks need neither Max nor Ultra.

Do cloud tasks count against the same limit as local Codex runs? Yes. Local messages and cloud chats share a five-hour window, with weekly limits on top. Automations, code review, image generation and Voice-started tasks draw on the same budget.

Can I cut ChatGPT and Codex token usage automatically instead of by hand? Yes. Halv runs on your machine in front of every request and rewrites the context before it leaves — duplicated file reads and stale history removed, error signals and anything that changes the answer kept, and an untouched pass-through when a request cannot be compressed safely. Same model, same Codex CLI, same ChatGPT plan, roughly half the usage. It also works with Claude Code, Kimi and GLM.

Sources

Every rate and setting above comes from OpenAI’s own documentation, checked August 2026:

• Codex pricing: rate limits, credits, and models — the credit rate card, shared windows, image and Voice burn rates
• Speed — fast mode multipliers and /fast
• Models — Sol, Terra and Luna guidance, reasoning effort, Max and Ultra, the GPT-5.4 retirement date
• Slash commands in Codex CLI — /status, /usage, /compact, /new, /mention, /statusline
• Custom instructions with AGENTS.md
• Memories and Projects and chats

Related reading: Codex usage limits, explained and, if you also run Claude Code, how to save tokens in Claude.