Where your Codex usage actually goes (and how to make the window last longer)

If you use Codex every day, you know the moment. The plan is clear, half the feature is written, the tests are almost green, and the usage window closes. You didn't do anything unusual. You just did a normal afternoon of AI coding.

The frustrating part is that most of us don't really know which part of the work used the allowance. So let's break that down, look at how to check where you stand, and then talk about a workflow change that made the biggest difference for us.

Quick disclosure before we start: I work on XCR, the plugin I mention later in this post. The habits in the first half work with or without it.

How the Codex usage limit works, briefly

Codex comes with ChatGPT plans, and each plan has usage limits. OpenAI's Codex help article lists what drives usage: the model, where the task runs, task complexity, context size, reasoning effort, speed and tools. A long-running agentic task can use a lot more than a short request.

Two details trip people up:

• Usage is tracked in two windows: a five-hour window and a weekly window.
• On plans with shared allowances, Codex draws from the same pool as other agent features in ChatGPT.

The exact numbers change by plan and over time, so check the current ChatGPT plans page for yours rather than trusting a screenshot from a forum thread.

What actually burns through it

When you look at a session after the fact, the expensive parts are pretty predictable.

1. Implementation loops. Write code, run tests, read the failure, patch, run again. Every round re-reads the context. A feature with three or four rounds of test fixes is where most of the window goes.

2. Long threads. Everything Codex has read and written in the thread rides along with each new turn. A thread that started as "add an endpoint" and wandered into "also refactor auth" is carrying a lot of baggage.

3. Repository exploration. Opening file after file to understand a codebase before writing the first line. Useful, but heavy.

4. Heavy reasoning on routine work. The strongest models with high reasoning effort use the allowance fastest. Using them to rename a prop is overkill.

Compare that to planning a change or reviewing a diff. Those are light. Codex reads your request, thinks about the approach, or reads a diff and comments on it. It's the build (multi-file edits plus the test-fix loop) that's heavy.

Keep that split in mind, because the rest of this post depends on it.

Check where you stand before a big session

Don't guess. Before starting something large:

• Open Settings or the usage dashboard in ChatGPT or the Codex app to see which allowance you've used and when it resets.
• In an active Codex CLI session, run:

/status

And one myth to kill: starting a new chat does not reset your limits. A fresh thread makes each turn lighter because old context stops riding along, but the windows reset on their own schedule.

Habits that stretch the window

Before any tooling, these habits do help:

• One task per thread. Switch threads when you switch topics.
• Front-load the requirement. Goal, constraints and how to verify it, all in the first message. Drip-fed requirements mean rework.
• Name the files. "Look at orders/service.ts and orders/export.test.ts" is far cheaper than "find where orders are handled."
• Keep AGENTS.md lean. Codex reads it on every task, so every extra paragraph costs you on every task.
• Match model and effort to the task. Lighter settings for routine edits; save the heavy settings for design questions and nasty bugs.

These all help. But they're still optimizing the heavy part, not moving it.

Split the work: Codex plans and reviews, something else builds

Here's the idea that changed the math for us. If planning and review are cheap and the build is expensive, then the build is what you want off your Codex window. Codex is great at understanding what you want, choosing an approach and catching problems in a diff. That's the part that needs Codex.

My team built a plugin for exactly this split. It's called XCR, and it works with Codex, Claude Code, Cursor and Grok Build.

The flow looks like this:

1. Codex hands the task over. Anything bigger than a small edit (multi-file changes, features, tests, refactors) gets passed to XCR. Quick questions and one-line fixes stay in Codex, same as before.
2. XCR builds it. It hands the heavy steps off to other models, writes the change on a copy of your project, runs your project's own checks (type check, lint, tests) and repairs failures within the task's budget.
3. Codex reviews. It gets a short report back: requirements done, files changed, check results. Then it checks the change against what you asked for.

So your Codex quota goes to the thinking and the reviewing, and the heavy build doesn't run on your Codex window. That's how the quota lasts longer.

On privacy, here's the short version: checks run on your machine. Code is sent to the model only for the task, and XCR doesn't store it.

Setting it up (short version)

1. Open the install page on xcr.ai and sign in with the link that gets emailed to you. No password, no card needed.
2. In the console, open Install on a computer and pick the Codex tab.
3. Read "What XCR will change on your computer", tick the box, click Copy install instruction, paste it into Codex and allow the command.
4. Restart Codex.

Under the hood, XCR registers itself as an MCP server in ~/.codex/config.toml and adds one short rule to ~/.codex/AGENTS.md so Codex knows when to hand work over. Your original files are backed up first.

Then just work normally. Try something like:

Add CSV export to the orders page, with filters by date and status.

When the checks pass, the change lands in your working tree without a commit, so you review it in your usual diff.

A few things that matter if you're cautious (you should be):

• Undo: ask Codex to undo the XCR change.
• Spending caps: set a daily cap per computer, and every task has its own spending cap.
• Pause: pause with one click in the console.
• Uninstall: tell Codex "Uninstall XCR from this computer" and it removes exactly what XCR added and restores your files.

Wrapping up

The Codex usage limit stings most when you don't know where the usage went. Most of it goes to the build-and-fix loop, not to the thinking. Tighten your habits, check /status before big sessions, and think about moving the heavy builds somewhere other than your Codex window.

AI coding quota always running short? Hand the heavy work to XCR and make your quota last longer.

• Original article: Codex usage limit: make your Codex quota last longer
• Setup walkthrough: XCR quick start

Disclosure, again: I work on XCR, so weigh my take accordingly.