The biggest AI bill is often caused by a simple mistake: using the most expensive model for every part of the job.
The alternative is token maxxing. Use a cheap but capable model for most of the volume. Bring in an expensive frontier model when the work is unusually difficult or its quality will materially affect the outcome. Then measure the result so that “cheap” means cheap per completed job, not merely cheap per million tokens.
This is already how many businesses use people. Routine execution and senior judgment are different kinds of work. AI models now vary enough in capability and price for the same distinction to matter.
The interesting part is not recognising the distinction. It is making the hand-offs reliable without building an absurd management structure around them.
Tokens are the meter, not the goal
A token is a small piece of text read or written by a model. Providers usually charge separately for input and output. Input includes your request, instructions, tool definitions and often the previous conversation. Output includes the answer and, depending on the service, reasoning generated along the way.
“Maxxing” does not mean generating the most text possible. The useful measure is:
Accepted work divided by total cost, including retries and checking.
A model with a tiny advertised price can still be expensive if it writes enormous answers, repeatedly misunderstands the job or needs a premium model to repair everything. Conversely, a more expensive model can be economical for a difficult decision it gets right quickly.
Artificial Analysis makes this distinction visible. Its June 2026 assessment placed Z.ai’s GLM-5.2 on the intelligence versus cost-per-task Pareto frontier. It also found that GLM-5.2 used 43,000 output tokens per Intelligence Index task—more than MiniMax M3, Kimi K2.6 and DeepSeek V4 Pro in that comparison.
Price is only one measure
Cost per token and cost per completed task are not the same.
Open the current Artificial Analysis source.
Route work according to how much the answer matters
| Work | Default route | Why |
|---|---|---|
| Search, summaries, first drafts, routine edits, repeated checks | Capable low-cost model | High volume; mistakes are cheap to notice and correct |
| Architecture, difficult debugging, important editorial judgment, ambiguous planning | Frontier model | A weak decision can spoil all the work that follows |
| Publishing, spending money, deleting data, legal or financial claims | Frontier review plus human approval | Consequences extend beyond the model session |
The dividing line is not file count, prompt length or whether a task sounds impressive. It is whether weaker judgment at that point would materially change the result.
The FrugalGPT paper explored model cascades: try an economical service first and escalate when its response is unlikely to meet the required standard. Its experiments reported savings of up to 98% while matching the strongest model on the tasks studied. That is evidence that cascades can work, not a promise that everybody will save 98%.
A practical starting point: Claude coordinates, Codex works
For somebody already comfortable in Claude Code, OpenAI’s official Codex plugin for Claude Code is an approachable first step. It keeps Claude Code as the place where you describe the job while allowing Claude to ask Codex for a review, transfer a session or delegate work.
The plugin currently exposes commands including /codex:review, /codex:adversarial-review and /codex:rescue. Its documented requirements include Node.js 18.18 or later and either a ChatGPT subscription or OpenAI API access.
A maintained first hand-off
Codex can work from inside the Claude Code workflow.
Claude Code reads persistent project instructions from CLAUDE.md. A useful starting instruction is:
Act as the coordinator and final reviewer.
Delegate substantial implementation work to Codex when it is clearly
worth the hand-off. Give Codex the exact outcome, relevant files,
constraints and the checks that must pass. Review the result before
presenting it as complete. Handle small tasks directly when delegation
would create more work than it saves.That is less absolute than “you only exist as quality control”. The harder version is memorable, but it can make Claude delegate tiny jobs that would take less time to finish directly. Reviewing another model’s work is itself real work.
The next price step: Chinese-developed models through OpenRouter
Once the hand-off works, the next saving comes from changing the model doing the high-volume execution.
OpenRouter offers one API through which many model families and hosting providers can be selected. That reduces the work needed to test alternatives: in many integrations, switching model is primarily a configuration change rather than a new vendor project.
Several Chinese-developed model families—DeepSeek, Qwen, Kimi, GLM and MiniMax—now occupy unusually strong positions on cost-quality comparisons. “Chinese-developed” is more accurate and useful than turning nationality into a joke. It lets readers investigate the actual labs, models, licences and providers.
The careful claim is not that these models are universally as good as Claude or GPT. It is that the strongest are now close enough on important benchmarks, and cheap enough, that using a premium American model for every routine job no longer makes economic sense.
In June 2026, Artificial Analysis scored GLM-5.2 as the leading open-weight model on its Intelligence Index and reported it effectively level with GPT-5.5 xhigh on its GDPval-AA v2 agentic benchmark. OpenRouter’s June review described the open-weight gap as real but narrow, highlighted DeepSeek V4 Flash on the cost-performance frontier, and advised testing models against your own workload.
The market moved
Different open models now lead on cost, planning and multimodal work.
Read OpenRouter’s current review, then compare it with the Artificial Analysis model directory and the OpenRouter model directory.
What my own sessions show
My local telemetry records cumulative input and output tokens by agent, model, provider and session. It deliberately does not publish prompts or responses.
The following snapshot uses four real sessions. A GPT-5.6 Sol parent coordinated one piece of work while a GLM-5.3-Flash worker handled high-volume execution. Two OpenCode sessions used Claude Opus 5 through OpenRouter for targeted frontier work.
Measured, not hypothetical
Agent work repeatedly pays to re-read its working context.
The startling numbers are the input totals. The GLM worker did not write 202 million fresh words; it processed repeated instructions, tool definitions and working history across a long sequence of calls.
This is why cheap capable models unlock so much volume. They make repeated context affordable. It is also why careless orchestration can erase the saving: every extra manager, reviewer and retry can re-read another large block of context.
The data does not prove that the GLM worker produced twice as much value as the Sol parent, or that either Opus session was better. Token volume measures traffic. Accepted results, corrections, elapsed time and cost are needed to judge efficiency.
For more evidence, see the analysis of 551 Codex sessions, the measured simplification from several orchestration layers to one agent, and the GLM provider-routing benchmark.
Where orchestration becomes a wormhole
Manual routing is easy. Reliable automatic routing introduces questions: Who decides that the first model is struggling? Can two models edit the same files? How are retries and partial results recorded? Is the reviewer adding independent judgment or merely repeating the first model? Which provider receives the data?
The tempting response is to add a manager model, planner, reviewer, task database, message bus and several automatic gates. I tried versions of that. The telemetry showed that oversight could cost more than execution.
My current position is simpler:
- One agent owns each task from plan to proof.
- One economical model handles the routine path.
- Escalation happens only for a stated reason.
- A second agent is used when work is genuinely independent or would swamp the first agent’s context.
- Model calls are measured separately from the task outcome.
Automation should encode routing decisions you have already seen repeatedly. It should not invent a corporate hierarchy for three prompts.
From beginner setup to automatic coordination
Choose manually. Use a cheap model for routine work and switch when you reach a difficult judgment. This captures most of the economic idea with almost no setup.
Put the policy in CLAUDE.md. Tell Claude when to ask Codex for substantial implementation and what evidence it must inspect afterwards.
Change the workhorse. Route delegated execution to a lower-cost model through OpenRouter or another provider. Record the resolved model and host, because an alias may hide what actually answered.
Add evidence-based escalation. Escalate on failed tests, unresolved contradictions, repeated attempts, missing evidence or a decision explicitly marked as consequential—not because a prompt contains words such as “architecture” or “security”.
Review the economics. Compare total cost per accepted result. Include parent, workers, retries, reviewers and human correction time.
The rules that keep this honest
- Cheap per token is not cheap per job. Include output length, retries and repair.
- Benchmarks are evidence, not instructions. Test the jobs you actually run.
- Model names are not providers. The same model can behave differently across hosts.
- Two models agreeing is not proof. They may share the same blind spot.
- Do not send sensitive work everywhere. Read privacy and retention terms.
- Keep human approval for publishing, payments, deletion and high-stakes claims.
- Record missing prices, model names or token counters as unknown, not zero.
The point
Token maxxing is not a competition to burn the largest number of tokens. It is the decision to buy abundant routine intelligence cheaply and scarce judgment selectively.
The first useful version needs two tiers and a written routing rule. The advanced version adds telemetry and automatic escalation after you understand where the simple version fails. Otherwise, the coordination machinery becomes the product and the actual work becomes an afterthought.