How to Burn Your AI Coding Tokens 2–5× Slower: Off-Peak, Prompt Caching & Sub-Agents
~2–5× slower burn the number that matters here
By Stan K.
The same $80 coding plan can deliver 1.2B or 7.5B tokens a month depending on how you work. The four levers: off-peak discipline, context caching (30–180K corridor), orchestrator + cheap sub-agents, and the PLAN.md relay between sessions.
Our measured experience below comes from the Z.ai GLM Coding Plan (Pro, $64–80/mo) — the only plan that publishes its credit math, which is exactly why we can show the numbers. But the lessons and the methodology apply to every coding plan and every agent — Claude Code, ZCode, OpenCode, Cline, whatever you run. Prices and multipliers are Z.ai’s; the four levers are universal. Wherever we say “cheap model” (e.g. GLM-5.3-Flash), every other vendor has its direct equivalent — Claude Haiku, Gemini Flash, GPT-mini class. Substitute your own.
A coding plan quota is not a number. It’s a range. The same official Pro allowance — 12,000 credits per 5 hours, 60,000 per week — legitimately delivers anywhere from ~1.2B to ~7.5B tokens a month (the full quota math). Our own 30-day anchor landed at 9.63B. The difference between the bottom and the top of that range is not luck or bonuses — it’s four deliberate habits. None of them costs a cent extra.
1. Off-peak discipline: the same credits, burned half as fast
Z.ai charges full credit rate only Mon–Fri 14:00–18:00 UTC+8 (Singapore). Everything else — nights, weekends, all holidays — is 50% off. For a US developer that peak window lands at:
| Your timezone | Peak window (weekdays) | Your 9-to-18 workday |
|---|---|---|
| US Eastern (UTC−5) | 01:00–05:00 | 100% off-peak |
| US Central (UTC−6) | 00:00–04:00 | 100% off-peak |
| US Mountain (UTC−7) | 23:00–03:00 | 100% off-peak |
| US Pacific (UTC−8) | 22:00–02:00 | ~100% off-peak |
| Central Europe (UTC+1) | 07:00–11:00 | morning at full rate |
| East Asia (UTC+8±) | 14:00–18:00 | your core hours pay double |
In practice our measured month ran 92% off-peak, which multiplies effective credits by ~×1.85 (1 ÷ (0.92×0.5 + 0.08×1)). A Tokyo developer running the identical workload burns the same tokens at nearly twice the credit rate. If your plan has any time-based discount — use it by default, not by accident. And note the asymmetry: long batch jobs and agent runs that don’t need you watching are exactly the work that schedules cleanly into the cheap window.
2. Prompt caching: tokens burn when reading, not writing
The single most expensive habit in agentic coding is re-reading context. On the GLM plan, cached input costs ×1.7 per token and uncached input ×6.9 — a 4× difference for the same information. Our 30-day cache hit rate was 92.5%: in a long session on one problem, the system prompt, the project files, and the conversation prefix are read once and then served from cache on every subsequent turn.
The rules that fall out of the math:
- Work in one window, for a long time, on one project. Every new chat re-reads your context uncached. Hopping between five parallel windows is the fastest way to incinerate a quota.
- Keep the context in the 30K–180K corridor. That’s the sweet spot for current LLMs — enough history and project structure to work well, before quality degrades. Past ~200K, run
/compact(or your agent’s equivalent) to shrink the volume. - An overloaded context is a double loss. Beyond ~200K–250K, attention mechanisms start missing details in the middle of the window (“lost in the middle”) — the model skips rules from your instructions, forgets earlier definitions, and gives shallower answers. You pay more per turn for dumber output. And if the cache breaks (a mid-conversation edit, TTL expiry), the full mass re-enters at uncached rates.
3. Orchestrator + sub-agents: expensive model thinks, cheap model reads
The core architecture for token efficiency: your main session is a judge, not a laborer. It runs on the strong reasoning model (GLM-5.3 with high thinking — or your vendor’s equivalent), and its context contains only clean state: the plan, the architecture, function signatures, and the distilled reports from sub-agents. It never sees raw logs.
Every “dirty work” task — high reading volume, low reasoning complexity — goes to an isolated, throwaway sub-agent on a cheap, fast model. The sub-agent swallows 80,000 tokens of raw material and returns 600 tokens of essence; its context is discarded immediately and never pollutes the main session. That keeps the orchestrator in the 30–180K corridor and its cache hit above 90% — lever 2 maintains itself.
The four-variant palette we use (every vendor has the same ladder):
| Task | Agent to give it to |
|---|---|
| Web search, docs lookup, Reddit/GitHub issue hunting | Cheapest tier (GLM-5.3-Flash low / Haiku-class), high volume |
| Reading large files, repo recon (“list the public methods in these 15 files”) | Cheap tier (Flash low) |
| Test runs, parsing 3,000-line stack traces into “which line throws” | Cheap tier (Flash high if it needs judgment) |
| Code writing on a given spec, isolated modules | Mid tier — GLM-5.3 low or Flash high |
| Decisions, architecture, code review, merging, conflict arbitration | Orchestrator only — GLM-5.3 high |
Two hard-won rules:
The biggest model is almost never the answer. If GLM-5.3-high can’t find something, the right move is not a bigger model — it’s a sub-agent sent to search the specialized corners of the internet: niche subreddits, GitHub issues, vendor forums. Aimed search beats raw intelligence.
Never let your main model read raw input that a smaller model could filter. Expensive model for thinking, cheap model for reading — as a golden rule, this single sentence is most of this article.
4. The PLAN.md relay: new sessions inherit knowledge, not history
For a large new project, marathon chats are the enemy — they inflate context past the corridor and re-bill it every turn. Instead, run a relay:
Phase 1 — Recon (cheap agents). Break the project into modules. For each module, answer: which language fits best, which libraries (exact versions), and is there an open-source project that could serve as a partial donor — if the license allows it (MIT/Apache yes, GPL depends)? Loop module by module until nothing is unclear. None of this raw digging ever reaches the main session.
Phase 2 — Synthesis. The recon answers become a draft, and the draft becomes a beta PLAN.md — not a to-do list, but a transfer-of-power document: architectural overview, tech stack with versions, donor code with license notes, a dependency graph (what must be built first), and behavioral guardrails (code style, error handling, forbidden approaches).
Phase 3 — The relay. Start a clean session — zero history, fresh cache — and prompt it with one short line: “Read PLAN.md in the project root. It is your starting point, architecture, and action plan. Take the role of orchestrator.” The new agent picks up the perfectly synthesized information at full intelligence, having spent zero tokens on yesterday’s dead ends.
The new orchestrator then breaks the plan into tasks and assigns each to the right sub-agent tier — Flash low for volume searches, GLM-5.3 high for decisions and code that doesn’t burn many tokens. It sequences the modules, arbitrates conflicts between agents, and keeps results consistent. You can swap agents mid-project five times; each successor steps onto PLAN.md like a professional spec. That’s 80–90% input savings versus dragging the same bloated chat for weeks — and better output, because nobody suffers the lost-in-the-middle syndrome.
How the four levers stack
Our measured month, deconstructed: ×~1.85 from off-peak discipline, ×~3 from the Flash share of work (cheap model yields ~3× more tokens per credit), ×~2.2 from cache discipline versus a cache-poor baseline — with bonus credits (reset cards, daily Flash promos) on top. Stack the levers and the same $80 plan behaves like a much bigger one; ignore them and the same plan feels starving.
These multipliers are from one real workload — long agent sessions, 92% off-peak, US timezone. Yours depends on your plan’s discount windows, your models’ cache pricing, and how read-heavy your work is. The levers don’t change: schedule into cheap hours, keep context cached and lean, delegate reading to cheap models, and relay between sessions through a plan document instead of a chat history.