Never Hit a Codex Limit Again (12 Rules, Metered)

Overview

The video is a “rules + measurements” guide for avoiding Codex token limits, so you don’t run out mid-job. The speaker repeatedly describes testing on GPT-6 Astra and compares results against Luna, focusing on practical prompt and configuration changes that affect token usage and meter windows.

Meter / allowance system (key analysis)

Two concurrent token meters

Codex has two token meters running at once:

• A 5-hour window
• A weekly window

5-hour window timing

• The 5-hour window starts when you send your first message
• It then runs for 5 hours from that point
• This matters because the window can expire while you’re still working

Messages are weighted by model

On the $20 plan, OpenAI’s published table (as quoted) suggests:

• Astra: roughly 5–45 messages per window
• Luna: roughly 250–2,000

The speaker claims Astra is ~50x “more expensive” per allowance than Luna (i.e., one Astra message ~= ~50 Luna messages).

12 rules the speaker claims reduce token burn (measured)

The speaker says they metered every rule on a “broken button” scenario using the same bug prompt on their own account, with consistent results attributed to specific prompt/config changes.

1. Config: set service tier / fast mode

   • In the config file, look for service tier (the old name for fast mode).
   • Fast mode consumes ~2x allowance per turn.
   • If not intentionally using fast mode, remove the line and enable “fast” only for turns that need it.

2. Disable unused plugins; measure token overhead

   • Tested “clean install” vs real setup with 17 plugins:
     • Clean input tokens: 14,164
     • Real input tokens: 19,040
     • +4,876 extra tokens per turn (~34%) before typing anything
   • If a plugin isn’t needed for the job, turn it off.
   • The speaker claims image generation is especially costly (about 3–5x faster token burn than normal text).

3. Fix “buttons” cost in code

   • The speaker claims a UI inefficiency costs tokens.
   • They reference toolbar.js and a handler that sets the body theme.
   • Reported outcome: ~32% less tokens in both runs and half the runtime.
   • They also suggest Code execution spends time searching for where to start, and adding two prompt clauses to skip the search helps.

4. Constrain agent output format (short success path)

   • In a project’s agents file:
     • “Reply in three lines or fewer”
     • “Say only that a check passed”; provide detail only on failures
   • Token reduction reported: ~28% (from 1,173 → 842 tokens).
   • If you need more explanation, request it explicitly.

5. Model effort setting: avoid overusing “high”

   • The video references OpenAI guidance: try Astra at low/medium first.
   • The speaker reports:
     • Using low didn’t help (example: 99k vs 80k tokens against 90k baseline)
   • Heuristic from the speaker:
     • medium by default
     • high only for genuinely hard problems
     • low for “just answer” questions

6. Failed strategy: “use at most X% of weekly limit”

   • The speaker tests whether Astra can read remaining quota; they claim it cannot read your meter.
   • Prompted Astra with: “Use at most 2% of my weekly limit…”
   • Result: ~13% worse (example 102k vs 90k tokens).
   • Conclusion: telling it to be “careful” apparently increases checking, raising tokens.

7. Using Luna sub-planning (and why token math matters)

   • Same bug with Luna as main model:
     • Example: 69,116 vs 90,932 tokens (~24% fewer)
   • But the speaker emphasizes raw numbers can “under-represent” true cost because allowance weighting differs.
   • Recommended architecture:
     • Let Astra plan
     • Delegate routine execution to Luna sub-agents
     • Have Astra review results
   • The speaker notes OpenAI docs warn sub-agents can consume more tokens total, but allowance math can make it worthwhile.

8. Schedule to shift the 5-hour window

   • Because the 5-hour window starts with the first message, the time of day matters.
   • Example automation:
     • send a single-line message at 6:00 AM so the window expires around 11:00
     • instead of later in the afternoon
   • Claim: on the $20 plan, this is the “cheapest hour” to buy.

9. Put shared stack/tone/formatting into global agents

   • Store recurring formatting/tone/instructions once in a global agents file, instead of retyping per session.
   • Keep it short.
   • The speaker warns Codeex stops reading at 32 KB without notification.
   • Periodically (monthly), ask Codeex to clean up duplicated/outdated instructions.

10. Save working workflows as “skills”

    • When a workflow works, save it as a skill.
    • The speaker claims Codeex reads only:
      • the skill name
      • a one-line description
      • and only loads full instructions if it decides to use it
    • Benefit: unused skills “cost almost nothing” to keep.

11. Steer follow-ups + manage timing

    • The speaker describes steering behavior so a correction arrives while Codex is still working, not after the job ends (too late).

12. Manage context and compression; avoid cache-breaking changes

    • Requests beyond 272,000 tokens are described as “built at double cost per token” (as claimed).
    • Set autocompact around 200,000 tokens.
    • Don’t add/remove tools mid-thread: it breaks the cache (cache lasts ~30 minutes).
    • For runs over an hour: have Codeex maintain a short progress file so a crash doesn’t mean paying again.

Review / tutorial-style presentation

• The core of the video is a tutorial structured as 12 rules, with:
  • quantified before/after token and time results for several rules
  • explicit comparisons (Astra vs Luna; success vs failed strategies)
  • config/code/prompt guidance (config, agents file, toolbar.js, automations, skills)

Calls to action / where to find it

The speaker says full details are in:

• a “window card”
• config/agents blocks
• linked “beginner guides”

They also encourage subscribing/joining, but that’s outside the technical content.

Main speakers / sources

• Main speaker: The channel creator who performed the token metering tests and reports results (no specific name given in the subtitles).
• Sources referenced: OpenAI documentation/help pages (e.g., effort levels and allowance-related guidance) and internal tooling/UI/code references mentioned by the speaker (e.g., toolbar.js, agents file).