163 ways to spend fewer tokens
The 22 Beginner tips are free to read. The 141 advanced tactics unlock with Pro — plus a fresh tip in your inbox every morning.
Stop Paying Frontier Prices for Boilerplate Work
Most of your token spend is on tasks a small model handles perfectly. Match the model to the job instead of defaulting to your most expensive option for everything.
Buy More Reasoning on the Cheap Model Before You Upgrade the Tier
When a cheap model stumbles on a hard task, the reflex is to jump to the frontier tier. Often the cheaper move is to keep the small model and turn its reasoning effort up — its per-token rate is so low it can brute-reason through the problem and still cost far less.
Cascade: Try the Cheap Model First, Escalate Only When It Fails
Send every request to a small model first, programmatically check the answer, and only escalate to a frontier model when the cheap one falls short.
Set service_tier flex for Batch Prices on the Sync Endpoint
Add a single parameter to your OpenAI Responses or Chat Completions calls to pay Batch-API rates without restructuring anything into async batch jobs. You keep a normal synchronous request/response flow and give up only guaranteed speed.
Don't Burn Reasoning Tokens on Tasks That Don't Reason
Model selection isn't just which model — it's which reasoning mode. Turn thinking down or off for straightforward work and reserve deep reasoning for genuinely hard problems.
The Harness Effect: Fix Your Orchestration Before You Reach for a Cheaper Model
The reflex when an agent bill climbs is to downgrade the model - a flat, one-time per-token discount that costs quality. A controlled study (The Harness Effect, arXiv 2607.06906) held the model fixed and changed only the orchestration layer, cutting tokens/task 38% and cost 41%. Audit and fix the harness - cache-shape, compaction, offload, suspend-don't-poll, failure governance - before you reach for a cheaper model.
Route a Step Down a Tier Only When the Saving Beats the Cache Rebuild
Complexity-aware routing backfires in long agent sessions if you ignore the prompt cache: switching models throws away the warm, model-scoped prefix, and the cold re-prefill can cost more than the frontier model would have for that one step. Make cache-rebuild cost a term in the routing decision.
Call the Critic Only When the Agent Is Unsure: Gate Verification on Action Uncertainty
A common reliability pattern for long-horizon agents is to run an expensive critic/verifier model after every step - which roughly doubles token spend even though most steps are unambiguous and gain nothing from a second opinion. Instead, read two cheap uncertainty signals from the actor's own next-action distribution - global entropy and the top-2 logit margin - to approximate the Value of Information of a critique, and invoke the critic only on the genuinely ambiguous steps. Let the actor internalize the critic's guidance over the run so the calls taper off as it improves.
Pin effort on the Managed Agents agent resource, not the session
In the Managed Agents API, an `effort` level set inside a per-session model override is silently ignored, and changing an agent's model `id` silently resets a pinned effort to the new model's default. Set effort on the agent resource, and re-assert it on every model swap.
Route Each Agent Step to a Model Tier, Not the Whole Run to the Frontier
A single agent trajectory mixes one hard planning step with a dozen trivial extraction steps, yet the reflex is to run every step on the frontier model. A tiny classifier can predict the smallest model tier that clears each step before you spend a token, using where the step sits in the run.
Score the Options, Don't Generate the Action: Offload Bounded Agent Decisions to a Tiny Classifier
Agent loops are full of tiny, bounded decisions with a fixed set of options: which action to take on a form field, whether a step is already done, which of N tools fits. Paying for a full generative LLM call on each is wasteful — a small discriminative model can score the fixed options instead, emitting zero tokens.
Retry Refusals Server-Side and Let Sticky Routing Stop You Re-Running the Doomed Model Every Turn
On a classifier-bearing model, a refusal-prone agent loop re-runs the primary and re-sends the whole thread every turn. Server-side fallback retries in one round trip, and sticky routing pins the conversation to the model that accepted so you stop paying for the doomed attempt.
Use a Big Model as the Planner, Small Models as the Workers
In agentic and multi-step pipelines, reserve the frontier model for orchestration and hard reasoning, and delegate bulk subtasks (search, read, extract) to a cheaper model.
Like what you see?
Get a fresh one in your inbox — weekly free, daily on Pro.