thinker
Think ahead. Save tokens.
How agent billing works.
One task can trigger many model calls. Each sends context in and generates tokens out.
Cost per token · fresh input = 1× · Claude Opus 5.5 example
Now add up the whole session.
One task, 20 calls. Here’s where the money goes in our example.
80¢ just to read the same context again.
200k cached tokens × 20 calls = 4M input tokens read.
Old context.
New charges.
Each call carries earlier context again, plus new prompts and results. Cached reads are cheaper, but you still pay for them.
Counter tracks the original 200k only. New context adds more cost.
Keep the useful.
Cut the rest.
Rewrite now.
Fewer reads later.
A one-time rewrite adds 28.8¢ to this call. Each later call saves 2.4¢, gradually paying it back.
Write cost first. Savings follow.
Trim once.
Keep relevant context.
Smaller writes.
Cheaper reads. Again.
Learn once.
Save and reuse.
Illustration: 40k exploration replaced by 2k notes. Learning and verification also cost tokens.
More work.
Same token limit.
Illustrative token budget. Actual usage and plan limits vary.
Illustrative economics, not measured savings Model, rates & assumptions
USD at Claude Opus 5.5 API list prices: fresh input $4, one-hour cache writes $8, cache reads $0.20, output $20 per million tokens. Checked November 4, 2026. Subscription allowances are not dollar bills.
The session bill uses 20 calls at 10¢ each, holding the cost mix and 200k cached tokens fixed to show how costs add up. The repeated-cost counter isolates that original context at 4¢ per call; the growing bars illustrate additional context accumulating, whose cost is not included in the counter. These are illustrations, not a measured session. The compression example starts with 200k cached tokens, removes 120k net of placeholders, and assumes 40k retained tokens need rewriting. Each call adds the same $0.060 of fresh input, new writes, and output in both cases. The example isolates this context’s lifetime: it assumes a warm cache, no further cuts, no extra rereads, and identical work. Actual write size depends on reusable cache boundaries; recovery depends on later calls. Instruction and knowledge examples are separate illustrations and are not added to compression savings. Trimming 8k instruction tokens avoids 160k context-read tokens over 20 later calls in the same session; dollar savings depend on fresh input, writes, and reads. The knowledge example replaces 40k exploration tokens with a 2k note pack: 38k less context carried into each later call. Over 20 later calls in the same session, that avoids 760k context-read tokens. Both examples assume the removed context would otherwise remain in every later request, with no intervening compression. The knowledge example assumes the notes answer the same questions without extra exploration. Figures exclude the initial exploration difference and learning or verification costs; they are illustrative read-token reductions, not measured outcomes or net dollar savings.
The final runway visual is conceptual: reducing repeated context can leave more of a token budget available for useful work. It does not specify an increase in tasks, subscription allowance, or session length. Rewrites, learning and verification also consume tokens; actual results depend on the workload and agent.
Compression availability depends on the agent. Instruction trimming and the knowledge cache are separate features. See how Thinker works with your agent →
npx @zerotimedev/thinker