Skip to content

No transparent per-feature usage/billing breakdown — quota drains with no attributable local or server-side record #41617

Open

Description

@axisrow

Summary

The core problem isn't just background consumption (Chronicle, desktop-app background jobs, etc.) — it's that there is no transparent, per-feature billing/usage breakdown for Codex quota at all. When quota drains unexpectedly, there is no reliable way for a user to answer "what exactly consumed this?"

What I observed

While investigating background quota drain (see #30639), I checked my local usage logs with ccusage — a tool that parses Codex's own local session logs into a usage report.

  • ccusage codex showed no "Exec" entries at all for the period in question.
  • Despite that, my plan limits were fully drained.

So the drain is not just poorly attributed in the product UI — it doesn't even show up as a billable/loggable local event that a usage-analysis tool can reconstruct. This is a silent billing skip: quota is consumed without a corresponding, inspectable record of what consumed it, whether client-side or in whatever server-side accounting feeds the Analytics/limits UI.

Why this matters more than any single background-job bug

Root-causing and fixing individual background features (Chronicle, desktop-app suggestions, subagent overhead, etc. — see the many linked reports below) doesn't solve the underlying issue: users have no way to independently verify or audit what their quota is being spent on. Every one of these reports required manual forensic work (grepping local memory/session files, comparing before/after screenshots of Analytics) because there is no built-in, trustworthy usage ledger.

Ask

  1. A per-feature/per-surface usage breakdown (Chronicle, Exec, desktop suggestions, subagents, CLI, app-server, etc.) that reconciles with the quota meter shown to the user.
  2. Every quota-consuming event — including background/passive ones — should produce a corresponding local and/or server-side record, so tools like ccusage (and the user) can audit it.
  3. Ideally, a documented mapping between local session logs and the billed/limits-consuming events, so discrepancies (like the one above, where limits drained with zero matching local "Exec" activity) can actually be diagnosed instead of guessed at.

Related reports

This overlaps with the broader "abnormal quota depletion" pattern being tracked in #41220, and specifically with:

Environment

  • Codex Desktop (macOS)
  • Local usage inspected via ccusage codex

Activity

  1. added
    enhancementNew feature or request
    appIssues related to the Codex desktop app
    rate-limitsIssues related to rate limits, quotas, and token usage reporting
    on Aug 30, 2026
  2. hankwangtw commented on Sep 2, 2026

    @hankwangtw

    Adding a measured data point to this, because it is exactly the gap you describe.

    On my Mac the Chronicle screen-summary pipeline made 6,002 background model calls over the 8 days of logs I still had, and none of them appear in threads.tokens_used or in any rollout file. The local ledger is accurate for user-initiated work; this path simply bypasses it (0 rows whose cwd points at the chronicle capture directory, against 6,030 logged calls that all do).

    Controlled comparison, same machine, app open, no input: 48 minutes with it on → +23% of the 5-hour window; 197 minutes with it off → 0%.

    Counting method, the on/off data and a read-only script that reproduces the numbers are in #42282. Fully agree the fix is attribution, not disclosure — the cost was documented; where it went was not.

  3. berkyuo2-cpu commented on Sep 8, 2026

    @berkyuo2-cpu

    Adding a measured Windows data point to the request for usage reconciliation.

    Window: 2026-09-08 04:00–21:11 Europe/Istanbul (UTC+3), i.e. 01:00–18:11 UTC. The cutoff was fixed at the start of the analysis; the subsequent analysis itself is excluded.

    Environment: Codex Desktop package 26.901.6511.0 (Windows package registry), bundled session/runtime version 0.153.4, Windows 10 build 19045 x64, ChatGPT Pro.

    Measured local activity

    51 unique local rollout files: 7 root tasks and 44 subagent threads, with 6,149 distinct usage increments.

    Metric Tokens
    Input, including cached input 790,370,851
    Cached input (subset of input) 765,014,144
    Uncached input 25,356,707
    Output, including reasoning 4,183,468
    Reasoning output (subset of output) 1,610,602
    Total: input + output 794,554,319
    • Cached-input share: 96.79%. Average input per counted usage increment: 128,536 tokens; input/output ratio approximately 189:1.
    • Root threads: 444,812,048 tokens. Subagents: 349,742,271 tokens (44.02%). One root task plus its children accounted for 48.88% of the total.
    • Peak hour: 11:00–12:00 UTC+3, 128,106,373 tokens, 1,027 increments. Fifteen threads produced usage within one five-minute bucket; that is an activity measure, not proof of simultaneous requests.
    • GPT-6 Astra accounted for 791,530,402 tokens; GPT-5.6 Luna for 3,023,917. Astra effort breakdown: max 546,645,027, ultra 103,371,612, medium 85,970,053, high 55,543,710. Luna used max.
    • 75 compaction records were observed. Their separate allowance impact cannot be derived from these records.

    Account allowance observations

    The previous weekly window was at 99% at 04:04:08. A new reset epoch first appeared at 0% at 04:28:14; a stale old-epoch snapshot also appeared at 04:29:21. The new window reached 95% at 20:55:05, confirmed by a live account usage query at 21:11. The current reset timestamp corresponds to 2026-09-15 04:25:14 UTC+3. Small 1–4-second reset-timestamp variations were not treated as additional resets.

    This is a 95-percentage-point increase in the new window, alongside substantial visible local activity. The trigger for the reset was not established. I cannot determine how much of that account-wide allowance change is attributable to the measured local events versus other surfaces or unlogged work.

    Counting method

    1. Read the local thread index in read-only mode and include older tasks resumed within the window, plus current-day rollouts. A metadata-only coverage check of session/archive files found no additional in-window usage files.
    2. Deduplicate physical file identities, including Windows extended-path aliases. Do not count both paths to one file.
    3. Process token events chronologically within each file and keep the latest pre-window counter as the baseline. Of 6,618 token events, exclude 469 unchanged cumulative snapshots.
    4. 6,098 component-wise cumulative increases exactly matched last_token_usage; 47 first records had total equal to last usage. At 4 counter resets, the new total also exactly equaled last usage, so start a new segment. Arithmetic mismatches: 0.
    5. Sum input + output once. Cached input and reasoning output are subsets. Read the model from turn_context.model, not from rate_limits.limit_id, whose snapshots can refer to different allowance buckets.

    Naively summing every last_token_usage would produce 851,780,170, overstating the reconstructed total by 57,225,851 tokens (~7.20%). This is a log-analysis pitfall; it does not demonstrate duplicate billing.

    Interpretation and request

    The visible workload contains thousands of large-context steps and substantial subagent activity. High cache reuse helps, but repeated cached context still accumulates usage. OpenAI's current pricing documentation explains that model, context, reasoning, tools and caching affect allowance consumption. Raw processed tokens are not directly equivalent to subscription allowance or a monetary bill.

    Please provide a native, time-bounded export that reconciles account allowance with root tasks, subagents, compaction and background/cloud work; distinguishes cached/uncached input and reasoning/output; records request speed/service tier; and documents counter resets, repeated snapshots and the mapping to allowance consumption. The local records here do not expose per-request service tier, so speed-related allowance weighting could not be checked.

    This analysis does not establish overbilling or a regression. Local counter arithmetic is consistent, but there is no independently verifiable account-wide reconciliation from these records. It covers this device's Codex logs, not all ChatGPT web/mobile usage or other devices. Raw prompts, project names/paths, account identifiers, session IDs and credentials are omitted from this public report.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    appIssues related to the Codex desktop appenhancementNew feature or requestrate-limitsIssues related to rate limits, quotas, and token usage reporting

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions