Zkitszo - The Real
September 20, 2026

Usage Limit Reached? Not So Fast..

You know the one.. deep into a fix, the agent has finally found the file that matters, it's halfway through the edit- and up pops the usage limit. Resets at 2:47pm. Just great.

A list of eleven "never hit your limit again" tips has been going around for OpenAI's new GPT-6 Astra in Codex. I'm saving the good ones here, mostly for me to remember- because most of them aren't Astra tricks at all. They work on Claude Code, on Gemini CLI, on pretty much any agent that reads your files and runs commands for you. A few of them don't hold up once you check the vendors' own docs. One is built on a feature nobody documents.

So here's what's worth keeping, what only applies to one model or plan, what's plain wrong.. and the whole lot rewritten as free skills you can drop into your own agent.

Where the Tokens Actually Go

Before any of the tips make sense, the thing to know: an agent doesn't just pay for your prompt. It pays for everything it has to read to answer it, every single turn. Your instructions file, the definitions of every tool and plugin you've got switched on, the whole conversation so far, every result from every command it ran.. all of that goes back in on each turn. Prompt caching knocks the price of that re-read way down (a cached read bills at about a tenth of normal input on most Claude models, a fortieth on Fable 5.1; OpenAI charges a tenth for Astra), but over a long session it still piles up.

Then there's the reading it didn't need to do- the searching. Then the rework: runs that went the wrong way and finished anyway, work redone after a crash. The replies come last. Output is the priciest per token, five times the input rate on current Claude models, but in agent work it's usually the smaller pile.

On a subscription you never see a per-token price, but the meter moves the same way- OpenAI's Codex credits map straight onto its API prices, 25 credits to the dollar. Every tip below goes after one of those piles..

Tell It Where to Look

This one has the most backing of the whole bunch. "Debug my website" sends the agent wandering- listing folders, grepping, opening whole files looking for the one that matters- and every file it opens stays in the context, getting re-read on every turn after. "The Save button on the settings page does nothing, it should send the form to the profile endpoint, the handler is in src/routes/profile.ts" sends it straight there.

Slight detour- it's the same with people. Call a help line with "it's broken" and you get twenty minutes of "have you tried turning it off and on again". Call with "the Save button on this one page stopped working after Tuesday's update" and you're done in five. Agents are no different.. except they bill by the word. -OK, back on topic.

Anthropic's cost guide for Claude Code says it plainly: fuzzy requests make it scan broadly, specific ones keep the file reads to a minimum. OpenAI's own Codex tips say the same- give it only the relevant files. The original list claims about 23% fewer tokens just from handing over the right file path, across six comparisons. That's one creator's six comparisons, not a study.. but everyone who has looked at this points the same direction.

Don't know where the problem lives? Have the agent map the codebase once- entry points, which route lives in which file, a "symptom → start here" table- and save it as a small file or a skill. The next bug hunt starts at the right door. Keep the map itself out of the always-loaded instructions file though.. one line there pointing to it is enough. Mostly writing this one down for me- it's the easiest tip to skip when you're in a hurry.

Give It a Budget

..but who's actually reading the meter?

The tip goes like this: tell the agent to finish the job in 3% of your weekly limit. The idea is it'll work more carefully. Since GPT-6 Astra can supposedly see your usage limits now, you can even have it run experiments to squeeze a repeat job down to 1%.

Half of that holds up. A stated budget does change how an agent works- it plans narrower, searches less, stops to ask instead of trying a fifth approach. There's research behind it too: the TALE paper (Token-Budget-Aware LLM Reasoning, December 2024) found that a sensible token budget in the prompt shortens a model's step-by-step reasoning. Sizing the budget to each problem cut tokens for only a slight drop in accuracy. Set it too tight, though.. it backfires.

The other half... not so much. There's no OpenAI doc, changelog or release note (as of September 19) saying the model can read your plan's usage. The meters are for you: /status and /usage in Codex, /usage in Claude Code, /stats in Gemini CLI. What Codex does have are context-window token budgets, switched off by default. There's even an open issue on the Codex repo asking OpenAI for exactly the missing piece- real per-task usage budgets.

So budget anyway, in units the agent can count for itself: tool calls, files read, subagents started. "Keep this under 20 tool calls, check in with me halfway" works on every model out there. For a hard stop, Claude Code's headless mode takes --max-turns (and --max-budget-usd when you're on API billing). Subagent files in Claude Code and Gemini CLI take a max-turns setting too.

The experiment idea is still a good one- for jobs you run every week. Measure one run, change one thing, measure again, keep whatever comes out cheaper without getting worse... then save the winner as a skill.

Cheaper Hands, Same Brain

Astra really is trained to split work up and hand pieces to subagents running in parallel- OpenAI's prompting guide says so. The tip: let Astra plan and review, and let GPT-5.6 Luna do the grunt work. Luna's per-token price is about 2% of Astra's ($0.20 in and $1.20 out per million tokens, against $10 and $50), after OpenAI cut Luna's price by 80% at the end of July. On a Plus plan, going by OpenAI's own ranges, that's roughly 5 to 45 Astra messages per 5 hours against 250 to 2,000 on Luna.

Then there's the claim that "Luna Max" matches Claude Sonnet 5 at max effort for a seventh of the price. "Luna Max" isn't a separate model- it's Luna with the reasoning effort turned up to max. Artificial Analysis does score the two level, 38 each. The price gap is wider than a seventh, though.. about a ninth on list price, about 1/28 on what they measured per task. Wrong in the good direction, for once!

One strong model, cheaper hands Strong model plans, splits writes the specs Cheap model find every call site of X + own prompt and tools Cheap model update 40 test fixtures + own prompt and tools Cheap model run tests, report failures + own prompt and tools Same model reviews results reads a few in full Every subagent pays its own setup, so cap how many run.

The catch? Delegation multiplies tokens. Every subagent starts by reading its own system prompt, tools and instructions before it does a thing. OpenAI's own subagent docs say subagent runs use more tokens than a single agent doing the same job. Anthropic reported their multi-agent research system using about 15 times the tokens of a plain chat. The saving only shows up when cheap tokens replace expensive ones on real volume. Hand a crowd of agents a vague job and a limit goes fast- one Claude Code bug report describes a single research request that spun up 48-plus background agents, where only the first few added anything.

So: narrow specs (exact inputs, a short output format, a done-when check), a cap on how many run, one level deep. Review, don't redo. If the big model ends up redoing the work, the job was too big.. split it smaller.

  • Claude Code- a subagent file in .claude/agents/ with model: haiku. Heads up- since v2.1.198 the built-in Explore agent runs on your main model instead of Haiku. Define your own agent named Explore with model: haiku if you want cheap searches back.
  • Codex- default_subagent_model under [agents] in ~/.codex/config.toml, or a custom agent file in ~/.codex/agents/. Codex only delegates when you ask it to, when AGENTS.md or a skill tells it to, or when you're running at the top ultra effort.
  • Gemini CLI- a Markdown agent file in .gemini/agents/ with its own model: and max_turns:.

One more gotcha.... a "cheap" model at maximum effort still burns a lot of thinking tokens (Artificial Analysis counted about 28,000 per task for Luna at max). Start it at medium, raise it if the results need it.

The 6am Ping

This one is a scheduling trick, not a saving. Claude's paid plans, and ChatGPT plans used through Codex, meter usage in 5-hour windows that start with your first message, with a weekly cap on top. OpenAI documents that. On Claude it's how the session limit behaves in practice. That limit is shared across all models- a Haiku ping starts the same clock as an Opus day. First message at 9, out of juice by 10.. you're waiting until 2. Send one tiny message from a scheduled job at 6 while you're still asleep. The window that opened at 6 resets at 11 instead.

The 5-hour window, with and without a 6am ping No ping work out of usage, waiting reset 2pm first prompt 9am 6am ping work wait reset 11am tiny ping open, unused fresh 5-hour window 5am 6 7 8 9 10 11 noon 1 2 3 4pm Same allowance per window. The ping only moves when the clock starts.

No window gets any bigger, and the weekly cap still rules. It only changes when the clock starts. Still... if mornings are when you run dry, waiting one hour instead of four is a real difference. On a long day it can even squeeze one more reset into your working hours.

The pings, written out here so I stop hunting for them- cheapest model, one short prompt:

claude -p "hi" --model haiku --no-session-persistence
codex exec --ephemeral --skip-git-repo-check -m gpt-5.6-luna -c 'model_reasoning_effort="low"' "hi" </dev/null

That Codex line looks overbuilt. Every piece of it earned its spot. Run from a scheduler, Codex starts outside any Git repo (your home folder under cron, / under launchd)- without --skip-git-repo-check it refuses and exits.. every morning, silently. The </dev/null stops it sitting there waiting for input. The low effort matters more than you'd think. Even a one-word "hi" carries your instruction files and skill list- a few thousand tokens you can't avoid. At a high effort setting the model can also think for thousands more before replying. In one quick test the same ping used about 15,500 tokens at the top effort setting, and about 5,800 at low.

Put it in cron on Linux, launchd on a Mac or Task Scheduler on Windows- the limit-window-warmup skill further down has all three written out, plus how to remove it. Gemini CLI's free tier counts per minute and per day, so there's no window to shift there.

Is it gaming the limits? It's the vendors' own headless command, one tiny request a day, and no cap goes up.. if it still sits wrong with you, skip it.

Do It Once, Save It as a Skill

The first time an agent works through a job, it explores, guesses, fails, retries, and finally lands it. Every time after that it can skip all of it- if the working steps get written down as a skill. A skill is just a folder with a SKILL.md in it- the open Agent Skills format. Claude Code, Codex, Gemini CLI, Cursor, GitHub Copilot and a few dozen others all read the same thing. If Markdown is new to you, I went through GitHub's flavour of it in Get Up Get Down Get Hip With Git Markdown.

The tip says skills are "nearly free" to keep around, since the agent only reads each skill's name and one-line description until it needs one. True-ish. Codex caps that whole list at about 2% of the context window. Past that it starts cutting the descriptions down. OpenAI's own write-up on Astra says that once Codex cuts them, the model has a harder time picking the right skill.. their advice is to write them short yourself. One run of Codex 0.146 even printed a warning that it had shortened them to fit. Claude Code trims long descriptions in its listing too. One skill costs next to nothing.. forty you never touch cost something on every session, so clear out the ones you don't use.

Easiest way to make one: when something finally works, tell the agent to turn it into a skill. The skillify skill below walks it through doing that properly- only the steps that worked, scripts for the fiddly bits, a check at the end.

Say It Once, Keep It Short

Stop introducing yourself to the agent every session. The stuff you keep typing- keep it short, we're on Next.js, write like this- belongs in the instructions file it reads at startup. That's AGENTS.md for Codex (the Custom instructions box in the Codex app writes to ~/.codex/AGENTS.md), CLAUDE.md for Claude Code, GEMINI.md for Gemini CLI. Gemini can be pointed at AGENTS.md instead through context.fileName in its settings. By default, Claude Code only reads AGENTS.md when there's no CLAUDE.md around (a /config setting or an @AGENTS.md import gets you both)- a gotcha if you're trying to share one file across tools. Any time you correct the same thing twice.. that correction goes in the file.

The flip side: that file loads on every turn of every session, so it has to stay lean. Anthropic suggests keeping CLAUDE.md under about 200 lines. Codex is stricter than it lets on- once your AGENTS.md files pass 32 KiB combined (project_doc_max_bytes), it stops reading and drops the rest (one GitHub issue reports it doesn't even warn you).

Same goes for everything else that's switched on. Every MCP server and plugin adds to the context before you type a word, used or not. Claude Code now defers MCP tool definitions until they're needed. That helps a lot- tool names and server instructions still load though. OpenAI's own Codex tips list MCP servers as a usage cost. Image generation in Codex burns limits 3 to 5 times faster than a normal turn, on average.. worth remembering before asking for pictures for fun.

To see what's eating your context before you've typed anything: /context in Claude Code, /status in Codex (plus codex debug prompt-input, which prints exactly what the model sees), /memory show and /mcp in Gemini CLI (/stats model for token counts and quota). There's a rule of thumb in the original list worth keeping: if you didn't switch it on for this job, switch it off.

Once a month, have the agent read your instructions file and skills, list anything repeated, stale or making easy jobs harder than they need to be, and show you the edits before it makes them. OpenAI's own launch advice for Astra leaned the same way- trim the old "always do X first" scaffolding, since the newer models do a lot of that on their own anyway.

Grab the Wheel Early

If it's building the wrong thing, don't sit there and let it finish. Tokens it already spent don't come back.. the next ones don't have to be spent. The "steer vs queue" setting from the original tip is how the Codex app does it. Every tool has its own version:

  • Codex CLI- Enter steers the run in progress, Tab queues your message for after. In the app it's Settings → General → Follow-up behavior.
  • Claude Code- Esc stops the turn and keeps the work done so far, then you redirect. Typing while it works queues the message. Claude gets it as soon as the running tool calls finish, still inside the same turn.. close to Codex's steer. Double Esc opens the rewind menu.
  • Gemini CLI- model steering is experimental and off by default. Switch on Model Steering in /settings and anything you type mid-run becomes a hint.

While we're on the subject- pick your model and effort up front instead of switching halfway. On Claude Code, changing either mid-session means the next request re-reads the whole conversation with no cache discount (on most models).

Less Noise In

Every command the agent runs sends its output back into the context. A test suite that passes with 400 lines of names and dots, a search that returns every match in 200 files, a full npm install log.. the agent reads all of it, then pays for it again on every turn after. The fix is boring: quiet flags (pytest -q, cargo test -q, git status --short, rg -l), files read in slices, one line for a success, the whole error for a failure. Codex already clips each tool output it keeps (Astra's default is 10,000 tokens per output, set by tool_output_token_limit).

Careful though. Cut too much and the agent loses the one line that explains the failure. Then it guesses, re-runs, or reasons its way back to what you cut. That's not theory- JetBrains tested RTK, a popular output-compressing hook for Claude Code advertised at 60 to 90% savings, on 86 real tasks. At low reasoning effort it came out a median 7.6% more expensive per task. At high effort it made no difference at all.

Even the example in Anthropic's own cost docs trips on this. It's a hook that filters test output down to the failures- nice idea- but it pipes everything into head. Pipe into head and the exit code you get back is head's: zero, even when the tests failed. A passing run prints nothing at all, so the agent can't tell "passed" from "didn't run". Here's a version that fixes both- saving it here mostly for me. It only touches plain test commands, so anything chained or piped still gets the normal permission prompt. A pass comes back as the runner's last five lines, a failure as the last 150 with the passing-test noise stripped out. The real exit code survives either way:

#!/bin/bash
input=$(cat)
cmd=$(printf '%s' "$input" | jq -r '.tool_input.command // empty')

# Only plain test commands: anything chained, piped, redirected or commented passes through untouched.
unsafe='[;&|<>`$()#]'
if [[ "$cmd" =~ ^(npm\ test|pytest|go\ test)(\ |$) && ! "$cmd" =~ $unsafe && "$cmd" != *$'\n'* ]]; then
  # rc, not status: status is read-only in zsh, the Bash tool's shell on a stock Mac
  filtered_cmd="( out=\$( { $cmd; } 2>&1 ); rc=\$?; if [ \$rc -eq 0 ]; then printf '%s\n' \"\$out\" | tail -n 5; else printf '%s\n' \"\$out\" | grep -v -E '(PASSED|^ok )' | tail -n 150; fi; exit \$rc )"
  printf '%s' "$input" | jq --arg filtered "$filtered_cmd" \
    '{hookSpecificOutput: {hookEventName: "PreToolUse", permissionDecision: "allow", updatedInput: (.tool_input + {command: $filtered})}}'
else
  echo '{}'
fi

Save it as ~/.claude/hooks/filter-test-output.sh, chmod +x it, and register it as a PreToolUse hook on Bash in ~/.claude/settings.json- the quiet-tools skill has the exact JSON. It needs jq. Against a fake test runner printing 300 passing lines, a failing run came back as 4 lines with exit code 1 and a passing one as 5 lines with exit code 0- same in bash, zsh and plain sh. That zsh part matters.. on a stock Mac the rewritten command runs in zsh, where a variable named status is read-only. The first version of this hook used exactly that name and reported every run as failed.

Less Essay Out

Output tokens cost the most- five times input on every current Claude model. OpenAI prices Astra's output at five times its input too. A token is about three quarters of an English word, so a 100-word reply runs around 130 tokens.. closer to 170 on current Claude models, whose newer tokenizer makes about 30% more tokens for the same text. Ask it to change a button and you don't need six paragraphs about its button-changing journey.

The fun one here is Caveman, a skill that makes the agent talk like a caveman, sitting at over 100,000 GitHub stars. It advertises around 65% fewer tokens. JetBrains tested that too, on 86 real coding tasks: 8.5% fewer output tokens with it forced on (their ceiling), roughly 10% off the bill at best, no detectable drop in quality. Decent! Just not 65%... the big numbers come from chat-style answers. In agent work, most of what the model writes is code and tool calls- caveman-speak leaves those alone. Its own author said on Hacker News it was "very much intended to be a joke and not research level commentary". The other one people mention, I Have ADHD, reshapes replies around the next action with short numbered steps- it doesn't claim to save tokens at all.

The bigger lever is the one you can't see- reasoning. Hidden thinking tokens bill as output. Set the effort to match the job (/effort in Claude Code, the effort picker in Codex's /model or model_reasoning_effort in its config). Remember that 15,500 versus 5,800 token ping? Same model, same "hi"- the only thing changed was the effort.

For the visible part, one line in the instructions file does it: keep replies as short as the job allows, lead with the result, no preamble, no recap. Claude Code has a built-in /output-style concise that does exactly that and still keeps error reports complete. Codex already defaults its current models to low verbosity.

Leave a Trail

This one I'm writing down for me as much as anyone- nothing burns usage like watching an agent redo something it already did. On anything long- a batch of emails, a folder of files, a job that'll run past half an hour or into tomorrow- have it keep a short progress file: what's finished and where it is, what failed and why, what's next. Updated right after each piece is checked, not at the end. Crash, compaction, new session.. it reads the file first and picks up from "next".

Anthropic's harness for long-running agents does the same with a progress log plus git commits, so each fresh context window can get its bearings. Two catches. A session that crashed mid-step can claim more than it finished, so spot-check the last few "done" items before trusting them. Also, a stale progress file from an old job misleads the next agent with total confidence.. delete it when the job's done.

What Didn't Hold Up

A few claims from the original list, checked against the vendors' own docs as of September 19, 2026:

  • None of the old token-saving tips apply to Astra. Wrong. OpenAI's current Codex pricing page still says keep prompts and source material small, shrink your AGENTS.md, limit MCP servers, and switch to a smaller model for routine work.
  • Keeping context under 270K isn't necessary anymore. Misleading. 272K is still Astra's default window in Codex. On the API, a prompt over 272K input tokens is billed at 2x input and 1.5x output for the whole request.
  • The cache used to reset every 5 minutes, now it's 30. Right number, wrong model. The 30-minute minimum arrived with GPT-5.6 in July, not with Astra- and writing to the cache now costs 1.25x the input rate.
  • Changing effort mid-conversation doesn't re-read the chat anymore. Only through the API's configuration update, only on Astra, only with a single agent. The matching Codex feature sits behind a flag that's still off. Either way the model reads the history every turn; caching just makes it cheaper.
  • The model can see your usage limits. Nothing documents it (see the budget section above).
  • OpenAI's own docs say Astra can be optimized through prompting. That line is real, but it's about how Astra writes, delegates and tests.. not about usage.
  • The headline numbers- up to 91.75% saved, 33.3% in the live demo- come from the creator's own runs, with no data published. The demo changed four or five things at once on one small bug, so there's no telling which change did what.

The Skills- Free, Grab What You Want

There's a GitHub repo for skills like these now. All of the above is in it, rewritten to work on any model and checked against the docs- MIT licensed, one folder each, plus one umbrella skill with all ten tucked inside it. Most of the tactics were sound all along.. they just aren't Astra-only. More skills will land in there as they come up.. so, check back.

  • token-saver- the whole playbook in one skill. Install this one on its own if you only want one entry in your skill list.
  • pinpoint- turns "fix my site" into a brief with a place and an expected result, and maps a codebase once.
  • usage-budget- works to a budget the agent can count, checking in at 50% and 80%.
  • context-audit- measures and trims what loads before your first message.
  • cheap-subagents- the strong model plans and reviews, cheap models do narrow jobs, under a cap.
  • quiet-tools- small tool output, full failures, and the fixed test-output hook.
  • short-answers- replies as short as the job allows.
  • progress-ledger- the progress file, with the resume and clean-up rules.
  • skillify- turns a workflow that worked into a skill.
  • workflow-optimizer- measures a repeat job and tests cheaper versions against a quality check.
  • limit-window-warmup- the morning ping, written out for cron, launchd and Task Scheduler.

For any agent that speaks the format (Claude Code, Codex, Gemini CLI, Cursor and more):

npx skills add MissSophieSterling/agent-skills --skill token-saver

Or in Claude Code, as a plugin:

/plugin marketplace add MissSophieSterling/agent-skills
/plugin install token-saver@sophie-skills

Read them before you install them- they're plain Markdown. The two that touch your machine (the hook and the scheduled ping) say so, and tell the agent to ask you first. The umbrella skill also has a five-line "house rules" block you can paste straight into AGENTS.md or CLAUDE.md, no install needed at all.

That's plenty for now. Enjoy the extra hours.

Oh- if the morning ping doesn't seem to fire, check the machine was actually awake at 6. Cron just skips a missed run, and launchd runs it when the Mac wakes- too late to help. sudo pmset repeat wakeorpoweron MTWRF 05:55:00 wakes a Mac on weekdays. Double oh.... the ping still loads your instruction files and skills, so a lean setup makes even the ping cheaper.

What's been eating your limits? The plugins, the test logs, the agent wandering off on a search? If you've measured any of these, even one before-and-after, leave a comment- I'd love to see real numbers next to the ones above.

Glossary

  • Token — the unit a model reads and writes in; roughly four characters, or three quarters of an English word (current Claude models count about 30% more).
  • Context (context window) — everything the model reads on a turn: instructions, tool definitions, the conversation so far and every tool result.
  • Prompt caching — reusing an already-processed start of the prompt at a discount; cached reads cost about a tenth of normal input on most Claude models and on Astra.
  • Agent — an AI model that works in a loop, reading files and running commands until a task is done.
  • Subagent — a separate agent the main one starts for a piece of work, with its own context and, often, its own cheaper model.
  • Agent Skills / SKILL.md — an open format: a folder whose SKILL.md holds a name, a description and instructions that an agent loads only when a task needs them.
  • AGENTS.md, CLAUDE.md, GEMINI.md — instruction files an agent reads at the start of every session.
  • MCP (Model Context Protocol) — a standard way to plug tools and data sources into an agent; each server adds tool definitions to the context.
  • Reasoning effort — how much hidden "thinking" the model does before answering; it bills as output.
  • Verbosity — how long the visible reply is; some APIs let you set it low, medium or high.
  • 5-hour window — the usage period on Claude and ChatGPT subscription plans, starting with your first message, with a weekly cap on top.
  • Headless mode — running an agent from the command line with one prompt and no interactive session (claude -p, codex exec, gemini -p).
  • Hook — a script the agent host runs at a set moment, for example just before a tool runs (Claude Code's PreToolUse).
  • Exit code — the number a command hands back when it finishes: 0 for success, anything else for failure.
  • cron, launchd, Task Scheduler — the built-in job schedulers on Linux, macOS and Windows.

Sources

Comments

Post a Comment

← Newer