Controlled Codex Usage Measurements
We changed one thing at a time in controlled Codex runs and read the displayed usage meter before and after. Across two different coding tasks, the 5-hour meter moved least for Luna, then Sol, then Astra, in the same order both times. Runtime and client-reported input tokens did not follow that order. Each number is one run on a meter that reads in whole percentage points, so treat these as observations, not multipliers.
- Luna0pp
- Sol2pp
- Astra4pp
- Luna0pp
- Sol3pp
- Astra6pp
- The meter ordering repeated across two materially different tasks, so it was not unique to the first one.
- Runtime ordering flipped. Sol was fastest on Task 1, Luna on Task 2.
- Input tokens did not explain it. On both tasks Astra reported the fewest client-side input tokens and showed the largest meter movement.
- Exploratory. One run per condition. This is not a universal model ordering or a per-model multiplier.
Four measurements at a glance
Every controlled comparison we have published, with the limit that goes with it. “5-hour movement” is the change in the displayed 5-hour usage percentage across one run, in percentage points (pp).
| Evidence area | Compared | Result | Read it as |
|---|---|---|---|
| Cross-task model choice | Luna, Sol and Astra at Medium reasoning, on two different tasks | 5-hour movement was 0 / 2 / 4pp on Task 1 and 0 / 3 / 6pp on Task 2. The meter ordering repeated. Runtime ordering and client-reported input tokens did not follow it. | One run per model per task. Not a universal ordering or multiplier. |
| Earlier paired Astra vs Sol study | Sol and Astra at Medium on two deterministic tasks, order reversed | Sol 57/57 with 3pp aggregate 5-hour movement. Astra 57/57 with 4pp. | Separate harness. A one-point aggregate gap on a one-point meter. |
| Sol Low vs Medium reasoning | GPT-5.6 Sol, Low vs Medium, same frozen task | 112/112 both. Low finished 16.3% faster (77.1s vs 92.0s). Both moved the 5-hour meter 2pp. | No detectable 5-hour difference at 1pp resolution. Not the same as no difference. |
| Sol Standard vs Fast | GPT-5.6 Sol Medium, Standard vs Fast, same frozen task | 112/112 both. Fast finished 10.2% faster and moved the 5-hour meter 8pp vs Standard's 2pp, with fewer client-reported input tokens. | Standard baseline captured earlier in the same window. 8:2 is not a Fast multiplier. |
Cross-task model choice
We ran GPT-5.6 Luna, GPT-5.6 Sol and GPT-6 Astra at Medium reasoning on two different tasks, once each per task. Within a task, all three models got the same prompt, the same starting files and the same grader.
Task 1: implement four TypeScript modules against a frozen 112-test suite
| Model | Tests passed | Runtime | 5-hour movement | Weekly movement | Client-reported input tokens |
|---|---|---|---|---|---|
| GPT-5.6 Luna | 112 / 112 | 118,196 ms | 0pp | 0pp | 225,174 |
| GPT-5.6 Sol | 112 / 112 | 92,018 ms | 2pp | 0pp | 171,739 |
| GPT-6 Astra | 112 / 112 | 109,675 ms | 4pp | 0pp | 113,184 |
Task 2: add a feature to an existing Next.js app, graded by 24 checks
| Model | Grader checks passed | Runtime | 5-hour movement | Weekly movement | Client-reported input tokens |
|---|---|---|---|---|---|
| GPT-5.6 Luna | 21 / 24 | 144,090 ms | 0pp | 0pp | 294,432 |
| GPT-5.6 Sol | 21 / 24 | 227,172 ms | 3pp | 0pp | 302,213 |
| GPT-6 Astra | 22 / 24 | 193,096 ms | 6pp | 1pp | 237,177 |
Task 2 is graded by a Playwright script that includes heuristic text matching. Treat the 21/24 vs 22/24 gap as a single check on a heuristic grader, not as a difference in model quality. Astra's 1pp weekly movement sits at the meter's resolution floor and is not interpreted.
What repeated across the two tasks, and what did not
| Measure | Task 1 order | Task 2 order | Repeated? |
|---|---|---|---|
| Displayed 5-hour movement, lowest to highest | Luna, Sol, Astra | Luna, Sol, Astra | Yes |
| Runtime, fastest to slowest | Sol, Astra, Luna | Luna, Astra, Sol | No |
| Client-reported input tokens, fewest to most | Astra, Sol, Luna | Astra, Luna, Sol | Astra was fewest both times and still moved the meter most |
Reading. On both tasks, changing the model changed the displayed 5-hour movement while the grader result stayed identical (Task 1) or within one check (Task 2). The Luna, Sol, Astra ordering held on two materially different tasks, which is stronger than a single-task result. It still does not establish a universal ordering, and the sizes differed: 0 / 2 / 4pp on one task, 0 / 3 / 6pp on the other. A 0pp reading means movement below the meter's one-point resolution, not zero usage. We make no claim about how OpenAI calculates quota.
Earlier paired Astra vs Sol study
Before the runs above, we ran Sol and Astra at Medium reasoning on two different deterministic tasks and reversed which model went first on the second task. This study came from a separate, independently built harness, so its numbers sit beside the results above rather than being pooled with them.
| Task | Order | Model | Tests passed | Runtime | 5-hour movement | Weekly movement |
|---|---|---|---|---|---|---|
| Task A | 1st | Sol | 28 / 28 | 78,812 ms | 2pp | 0pp |
| Task A | 2nd | Astra | 28 / 28 | 44,915 ms | 2pp | 0pp |
| Task B | 1st | Astra | 29 / 29 | 26,382 ms | 2pp | 0pp |
| Task B | 2nd | Sol | 29 / 29 | 43,936 ms | 1pp | 1pp |
| Sol, both tasks | 57 / 57 | 122,748 ms | 3pp | 1pp | ||
| Astra, both tasks | 57 / 57 | 71,297 ms | 4pp | 0pp | ||
Both models passed every check. Across the two tasks Sol moved the 5-hour meter 3pp in aggregate and Astra 4pp; Astra never moved it less than Sol on either task. The weekly aggregate ran the other way (Sol 1pp, Astra 0pp). One run per arm and a one-point aggregate gap on a one-point meter is not enough to build a ratio on.
Sol Low vs Medium reasoning
Same model (GPT-5.6 Sol), same frozen Task 1, same starting files and grader. Only the reasoning effort changed. The Medium run is the Task 1 Sol run above, counted once.
| Reasoning | Tests passed | Runtime | 5-hour movement | Weekly movement | Client-reported input tokens |
|---|---|---|---|---|---|
| Low | 112 / 112 | 77,059 ms | 2pp | 1pp | 152,232 |
| Medium | 112 / 112 | 92,018 ms | 2pp | 0pp | 171,739 |
Reading. Both runs passed all 112 tests. Low finished 14,959 ms sooner, about 16.3% faster (77.1s vs 92.0s), and both moved the displayed 5-hour meter 2pp. That is no detectable 5-hour difference at 1pp resolution, which is a statement about the meter as much as about the model: a real gap smaller than one point would look exactly like this. The weekly column is shown for completeness. A 1pp gap on a 1pp meter from one run each cannot be interpreted.
Limits: one run per arm, two separate fresh sessions inside the same 5-hour window, one task, one account. Only Low and Medium were tested.
Sol Standard vs Fast
OpenAI documents Fast mode for GPT-5.6 Sol as 1.5x faster in Codex and as using ChatGPT credits at 2.5x Standard (see our Fast mode guide). Those are OpenAI's figures. What follows is what we observed on the displayed subscription meter, which is a different measurement.
| Serving tier | Tests passed | Runtime | 5-hour movement | Weekly movement | Client-reported input tokens |
|---|---|---|---|---|---|
| Standard | 112 / 112 | 92,018 ms | 2pp | 0pp | 171,739 |
| Fast | 112 / 112 | 82,635 ms | 8pp | 1pp | 155,609 |
Reading. GPT-5.6 Sol at Medium reasoning passed all 112 tests on both tiers. Fast finished 9,383 ms sooner, about 10.2% faster in this comparison, and moved the displayed 5-hour meter 8pp against Standard's 2pp. Fast reported fewer client-side input tokens (155,609 vs 171,739). The larger meter movement was not accompanied by higher client-reported input-token volume or lower deterministic correctness.
The observed 8:2 ratio is not a universal Fast-mode multiplier, and it is not a measurement of OpenAI's documented credit multiplier. Two single readings on a whole-point meter are compatible with a much smaller or much larger underlying ratio. The Standard baseline was captured earlier in the same 5-hour window, not rerun immediately before the Fast run, and Fast was requested for this run only rather than through the persistent Fast setting. One run per arm, one task, one model, one account.
How we measured
Short version, enough to interpret and cite the numbers above.
- All runs used a ChatGPT Plus account, with Codex signed in through ChatGPT.
- Within each comparison: identical frozen starting inputs, a fresh isolated Codex session per run, and the same model settings except the variable under test.
- Within each comparison: one fixed grader. Deterministic test suites for Task 1 and the earlier paired study; a 24-check Playwright grader with heuristic text matching for Task 2.
- Usage is the displayed 5-hour and weekly percentage read from the free Codex Usage tool immediately before and after each run. Movement is after minus before.
- The meter reads in whole percentage points, so each delta carries roughly one point of display uncertainty and 0pp means below the display increment.
- One run per condition. No repetitions, error bars or significance tests.
- The earlier paired Astra vs Sol study used a different, independently built harness, and its numbers are not pooled with the rest.
- Token counts are what the Codex client reported for each run. They are not billing records.
- We do not have OpenAI's quota formula, and nothing here should be used to predict what another task, plan or account will consume.
The frozen 112-test task behind Task 1, Sol Low and Sol Fast:
- Prompt SHA-256
- 704e8782227e1392d08da05f997e3332f0d576833378e78acf7e2cf166a39503
- Starting fixture SHA-256
- 81ab75e98da5f8fd55f9a0ce0badf35205af4114dec20b20b9bff2658d54c8d0
- Client versions
- codex-cli 0.154.0 and codex-usage 0.5.0 for the earlier paired study, Task 1, Sol Low and Sol Fast.
The hashes identify the exact inputs used. They do not let you re-run the experiment, and you cannot reproduce our meter readings: those depend on your plan, your account and how much of your own window is already used.
Download the data
Twelve rows, one per unique run. The Sol Medium baseline shared by three comparisons appears once. Fields cover the grader result, runtime, before and after displayed usage, movement in percentage points, and client-reported token counts. Empty fields were not recorded or are not published. There are no account identifiers, reset timestamps or raw quota payloads.
The JSON file also carries the limitation statements from this page in a notes array, so the caveats travel with the data.
How to cite these measurements
Link to the section a number came from and carry its conditions with it.
Codex Usage. Controlled Codex Usage Measurements. codexusage.dev, 18 September 2026. https://www.codexusage.dev/research
A quotable finding with its conditions attached:
On one ChatGPT Plus run per model on each of two different coding tasks, GPT-5.6 Luna, GPT-5.6 Sol and GPT-6 Astra at Medium reasoning moved the displayed 5-hour usage meter 0, 2 and 4 percentage points on Task 1 and 0, 3 and 6 on Task 2 (Codex Usage, 2026).
Please do not present any figure here as a per-model or per-tier multiplier, as an OpenAI-published rate, or as a measure of model quality. These are engineering measurements from the maintainers of a free local usage tool. They are not peer-reviewed.
- Codex 5-hour limit — what the window is and OpenAI's published message estimates.
- GPT-6 Astra usage limits and GPT-5.6 Luna usage limits — plan allowances and eligibility.
- Codex recommended model — OpenAI's model and reasoning guidance.
- Codex Fast mode — documented speed and credit multipliers, and how to toggle it.