Table of Contents
You hit your Claude Code session limit because of resent history, not because of your prompts. Every time you press enter, the model receives the entire conversation again from the top, so old messages, old file reads and old command output are paid for on every single turn. In one real audit, the text the user typed made up about 0.01% of total usage. The fix is to shrink and protect that history: clear between jobs, never switch models mid-session, filter noisy output, trim idle tools, delegate carefully and audit scheduled tasks.
Why Does Claude Code Keep Hitting the Session Limit?
The short answer is that the limit is not measuring your effort. It is measuring how many tokens the model had to process, and most of those tokens are things you already sent earlier in the same session. A person can run a modest workload, never leave the machine running for eight hours, and still be told to come back in five hours. That is confusing until you see where the tokens go.
A token is a small chunk of text, roughly a short word or part of a word. Every request to the model is billed and limited by the number of tokens it reads and writes. The model itself holds no memory between requests. So Claude Code has to pack up the system prompt, your project instructions, every earlier message, every tool result and your newest message, then send the whole bundle again. The Anthropic documentation on prompt caching describes this exact behavior: each message is a new API request and the full context is re-sent, with new content appended at the end.
When someone analyzes their own logs, the pattern is stark. The words they typed are a rounding error. The bill is dominated by history being re-read. That is the single idea that makes every fix in this guide make sense, and it is why "write shorter prompts" is one of the weakest pieces of advice you will hear.
Quick definition
Context window: the total text the model can see for one request, including instructions, history, tool definitions and your latest message. Session limit: the usage allowance your plan gives you over a rolling window. A bigger context window means each request costs more against that limit.
How Does Token Consumption Actually Work in Claude Code?
Think of your conversation as a stack of pages that gets photocopied and handed to the model every turn. Turn one is one page. Turn two is two pages plus the answer to turn one. By turn 20 you are handing over a thick folder, and only the top sheet is new. Everything underneath is work you already paid for, being paid for again.
The compounding effect in plain numbers
Here is the part people miss. A file of 3,000 tokens that the agent reads at turn four of a 40 turn session does not cost 3,000 tokens. It is carried along for the remaining turns, so it is processed roughly 37 more times. The same is true of a noisy 800 line install log or a huge pasted stack trace. Anything that enters the conversation rides along until you clear, compact or end the session.
| Turn | What is new | What is resent | Share that is repeat |
|---|---|---|---|
| 1 | Your first message | System prompt, tools, project memory | Low |
| 5 | One message and one answer | Four earlier exchanges plus everything they pulled in | Majority |
| 20 | One message and one answer | Nineteen earlier exchanges, all file reads and command output | Large majority |
| 40 | One message and one answer | Thirty nine earlier exchanges | Nearly all |
Why prompt caching makes long sessions survivable
Prompt caching is the reason long sessions do not bankrupt you. The API matches the start of each request, called the prefix, against content it processed recently. When the prefix is identical, it reads that part from cache at a fraction of the normal price, roughly one tenth in the example used by the video this article builds on. Claude Code orders each request from most stable to most volatile content so that as much as possible stays identical from turn to turn.
The match has to be exact. If something changes anywhere in the prefix, everything after that point is recomputed at full price. There is no per file or per segment caching. This is the hinge for the whole guide: the cheap path is an unchanged prefix, and several innocent looking actions quietly break it.
The cache has a clock
Cache entries expire. In Claude Code the lifetime depends on how you are billed. Subscription plans typically get a one hour lifetime, while API key, Bedrock and Vertex usage defaults to five minutes unless you change it. Community write ups of the current behavior also note that moving onto usage credits can drop your lifetime to five minutes. If you walk away longer than the lifetime, your next message rebuilds the whole cache at full price. Check the current Anthropic documentation for your plan, because these numbers have changed before.
How Do You Audit Your Own Claude Code Setup for Token Waste?
Your setup is not the same as anyone else's. One person is bleeding tokens through a dozen connected tools. Another is dragging a 200,000 token session around all day. A third has a scheduled task firing at 3 a.m. You need to see your own numbers before you decide which fix matters most.
The four built-in views to learn first
- /context shows what is in your window right now, line by line. It is the command you will use most. Look at the tools line in particular. If it says deferred, tool definitions are not all being loaded up front.
- /usage shows how much of your plan you have used and what consumed it. It can name specific skills, tools and agents, so a single quiet offender has nowhere to hide.
- /cost shows what the current session has cost and how that splits between re-reading history and doing new work.
- The status line meter keeps a live number in the corner of the screen. A moving number changes behavior more than any written rule.
Recent Claude Code releases also add a prompt cache line to the session cost view. It summarizes the request count, the share of input tokens served from cache, the misses and whether the cache is warm right now. That line is the quickest way to tell whether your habits are actually hitting the cache. Community guides that decode the miss reasons list causes such as a model change, an effort change, a fast mode toggle, changed tool definitions and idling past the cache lifetime.
Run a one time audit with a prompt
You can also ask Claude Code to audit itself. A good audit prompt asks the agent to read your context breakdown, check whether tool deferral is on, measure the size of your memory files, calculate your cache hit ratio from the session logs and list any scheduled tasks that fire while you are away. Session logs are stored locally, and every reply in them records its token cost, so the agent can compute your own percentage of history re-reads versus new work. That is how the 0.01% figure at the top of this article was found, and you will get your own number instead of borrowing someone else's.
- Open Claude Code in a project you use often and run
/context. Note the size of messages, tools, memory files and skills. - Run
/usageand write down the top three consumers it names. - Ask the agent to read your local session logs and report the share of tokens that were cached reads, cache writes, fresh input and output.
- Ask it to list every connected tool server, plugin and scheduled task, with the approximate cost of each.
- Sort the findings by size and fix the biggest item first, using the seven fixes below.
- Repeat once a week, because setups drift as you add servers and plugins.
Fix 1: Should You Use /clear Between Jobs?
Yes. This is the highest leverage habit you can build, and it costs nothing. When you finish one task and start an unrelated one, run /clear. The old conversation is not sitting quietly in the background. It is resent on every message until the session ends. In the example shown in the source video, messages sat at 80,000 tokens, and after /clear they dropped back to zero.
Every other fix in this guide reduces one component of your context. Clearing resets the entire base that all those components are a fraction of. In that audit, 96% of spend was history being re-read, and clearing is the one tool that deletes history outright. Anthropic's own documentation says the same thing in its own words: when you want a fresh start rather than continuity, clearing costs nothing.
How to clear without losing your work
- Run
/renameon the session first so it has a findable name. - Later, use
/resumeto bring that session back if you urgently need it. - Keep durable decisions in your project memory file, not only in chat history, so a fresh session can pick them up.
- Use
/rewindinstead if you only want to undo a few recent turns. Rewind returns to a point the cache already knows, so nothing has to be reread.
One caution. Clearing is for switching jobs, not for mid task momentum. If you are halfway through a debugging chain where every earlier finding matters, clearing throws away the context you need. Finish the chain, write the result to a file, then clear.
Fix 2: Does Switching to a Cheaper Model Save Tokens?
Usually not, and this is the fix to remember. When you are running low, the instinct is to open /model and drop from a top tier model to a cheaper one. That feels thrifty. It is often the most expensive keystroke in the session.
The reason is the cache. The model is part of the cache key. Change the model and none of your existing history matches the cache, so the entire conversation is reprocessed at full price. The source video gives an example at 200,000 tokens of context on a top tier model where a 10 cent turn becomes a 1 dollar turn, a tenfold jump. Exact prices differ by model and plan, but the direction is the same and the Anthropic documentation confirms that a model switch triggers a slow uncached turn.
What breaks the cache and what is safe
| Action | Effect on cache | What to do instead |
|---|---|---|
| Switching models mid-session | Breaks it | Choose the model when you start the session |
| Changing effort level | Breaks it | Set effort once per session |
| Toggling fast mode | Breaks it | Decide before the first message |
| Connecting or disconnecting a tool server that loads up front | Breaks it | Configure tools before you start, or rely on deferral |
| Enabling a plugin that ships a tool server | Breaks it | Enable plugins between sessions |
| Running /compact | Rewrites history, so it rebuilds | Prefer /clear between jobs |
| Upgrading Claude Code then resuming a long session | Breaks it, and the resumed request can be very large | Upgrade, then start a fresh session |
| Idling past the cache lifetime | Expires it | Clear or compact before a long break |
| Editing files in your repository | Safe | Edit freely |
| Editing your memory file | Safe for the running session, and changes apply on the next start | Edit freely |
| Changing output style or permission mode | Safe | Change as needed |
| Invoking skills and commands, recaps, rewinds | Safe | Use normally |
| Spawning a subagent | Safe for the main session | See Fix 5 for when it pays off |
The working rule is simple. Pick your model and effort at the start of the session and leave them alone. If you want a cheaper model, start on the cheaper model.
The thing you do to save money mid-session is often the most expensive move on the board.
Core lesson of prompt caching
Fix 3: How Do You Stop Noisy Command Output From Filling Your Context?
Imagine you ask the agent to install a package. It runs the command and 800 lines come back: package names, version numbers, warnings, a funding message. You never read them. You only wanted to know that it worked. The agent cannot skim, though. All 800 lines enter the conversation and you pay for them again on every message until you clear.
The remedy is a filter between the agent and the command. You can ask the agent to write it for you. The idea is one small script that runs the real command, saves the full output to a log file, and returns only the short part that matters, such as the last few lines and any errors. Anthropic's costs documentation covers preprocessing hooks for this purpose and describes cutting output from tens of thousands of tokens to hundreds. You set it up once and every later session benefits.
A simple wrapper script you can adapt
This is a minimal example of the pattern, not an official Anthropic script. Ask your agent to adapt it to your shell and tools, then test it on a harmless command first.
#!/usr/bin/env bash
# Run a command, keep the full log on disk, print only a short summary.
LOG="/tmp/quiet-run-$(date +%s).log"
"$@" > "$LOG" 2>&1
STATUS=$?
echo "exit code: $STATUS"
echo "full log: $LOG"
echo "--- errors and warnings ---"
grep -iE "error|fail|warn" "$LOG" | head -n 20
echo "--- last 15 lines ---"
tail -n 15 "$LOG"
exit $STATUSKeep the escape hatch
Always save the full output to a file. If the summary hides a real problem, the agent can read the specific part of the log on demand instead of carrying all of it in every turn.
Other sources of oversized input
- Screenshots of text. An image is not cheaper than the words in it. In the source video's measurements on a top tier model, one screen capture cost about 2,700 tokens and a 4K capture nearly 5,000. Paste the text instead, and the agent can edit it too.
- PDFs. Each page costs tokens for its text and, in many pipelines, again for a rendered image of the page. Ask the agent to convert the PDF to plain text first. The video reports the same document costing around a quarter as much.
- Huge logs and stack traces. Paste the relevant section, not the whole file.
- Broad file reads. Point the agent at specific files or line ranges when you can.
Fix 4: Are Your Connected Tools Eating Context Before You Type?
Yes, and it is easy to miss because connecting a tool takes a single prompt and feels free. It is not. Every tool you connect comes with an instruction manual: what it can do, what to send and what comes back. The agent has to read that manual before it may use the tool. In the source video, a code hosting integration alone was cited at about 26,000 tokens and a team chat integration at about 21,000, all loaded into every session before you type a word.
Tool search and deferral explained
Claude Code now has a behavior often called tool search or deferred loading. Instead of reading every manual up front, the agent loads a short contents page of tool names and descriptions and opens the full definition only when it needs that tool. Reported savings for connected tool servers are around 85%. It is on by default for many setups, so you may not have to do anything.
You still pay for the contents page, and that page grows every time you connect something new. Community bug reports from 2027 show the same pattern for built-in tools and plugins: even deferred entries add up, with one user measuring a baseline of roughly 41,000 tokens in a fresh session before any real work began.
- Run
/contextand expand the tools section. - Confirm the tools line says deferred. If it does, the manuals stay shut until needed.
- Open your tool server management panel and list everything you have ever connected.
- Switch off anything you have not used in the last month. Switching off does not delete the setup. It only stops the loading.
- Re-run
/contextand compare the tools total with your first reading.
Good news on the cost of this housekeeping. While the tools line still says deferred, connecting and disconnecting tools mid-session only appends to the list and does not rebuild your cache the way a model switch does. That is also why the table earlier marks up front loaded servers as a cache breaker and deferred ones as mostly safe.
Memory files and skills count too
Your project memory file is read into every session. A bloated file with stale notes, duplicated instructions and old decisions is a permanent tax. Keep it short, current and specific. The same goes for skills: each one adds a short description to the context, and the full body is read only when it runs. Prune skills you never use, and keep descriptions tight so they trigger accurately.
Fix 5: Do Subagents Really Save Tokens?
They move tokens around more than they save them. This is where common advice is only half true. A subagent works in its own fresh context, so the noisy research it does never enters your main window. In the simulation used in the source video, a subagent read about 6,000 tokens of files and returned a summary of about 420 tokens to the main session. In the main window that is a big win.
Look at the whole picture, though. The subagent had to load its own system prompt, its own copy of your memory file and its own tools, then do the reading. Roughly 9,800 tokens were burned to keep 5,700 out of the main context. In isolation, you lost. Anthropic is open about this elsewhere. Its engineering write up on its multi-agent research system reports that agents use about four times more tokens than chat, and multi-agent systems about fifteen times more.
When delegating is worth it
Delegation pays off when all three of these are true:
- The output is high volume. Many files, long logs or large search results.
- You will not need the detail again. A summary is enough.
- The session will continue for many more turns. Every turn you avoid carrying those tokens is a saving. If you delegate and then end the session, you paid extra for nothing.
The third condition is the whole game. Those 5,700 avoided tokens would have been resent on every remaining turn, so the longer the session runs after the delegation, the better the trade.
Fix 6: How Do You Pick the Right Model Without Wasting Tokens?
Use the smallest model that will still finish the job, and decide at the start. Half of what people ask an agent to do is small: rename these files, write a commit message, tidy a list. None of that needs the most capable model in the lineup.
The catch is Fix 2. You cannot keep hopping between models inside one session without paying for it. So apply the choice at the right level:
- Per session. Start the session on the model that matches the work. Quick edits on a small model, hard architecture work on a larger one.
- Per skill. Skills can specify a model for their own task.
- Per subagent. Run the grunt work on a small model without touching the main session's model or its cache.
The current Anthropic model lineup has a small fast tier, a balanced tier and a most capable tier, with new generations released through 2027. Check the official models page for current names and prices before you standardize a workflow on one of them.
Fix 7: Are Scheduled Tasks and Agent Teams Draining Your Limit While You Sleep?
They can, and this is the trap that can double a bill without you touching the keyboard. A scheduled task fires on its interval whether or not you are at your desk. Each time it fires, it sends its full context. If the task is attached to a bloated session, you pay for that whole context on every fire, including at 3 a.m.
The cache lifetime makes it worse
Remember the cache clock. If the task runs less often than your cache lifetime, every fire misses the cache and reprocesses the full context at full price instead of the cheap cached rate. On a subscription with a one hour lifetime, a task that runs every two hours pays the full price every single time. The interval is a real cost setting. A task that fires every 45 minutes can be cheaper than one that fires every two hours, because the shorter interval keeps the cache warm.
What does not drain your limit
Leaving Claude Code open in the background is often blamed for burning limits. Anthropic's documentation puts idle background usage at a few cents per session, so it is not the problem. The real culprits are scheduled tasks and live agent teams. The costs guidance is explicit that active teammates keep consuming tokens even when idle, and that teams should be cleaned up when the work is finished.
Audit checklist for automation
List every scheduled task. Ask whether it still needs to exist, whether it starts from a clean small context, and whether its interval matches the cache lifetime. Shut down agent teams the moment the job is done.
Which Popular Token Saving Tips Do Not Actually Work?
Some widely shared advice is wrong or backwards. Clearing these up saves you effort as well as tokens.
| Popular tip | Reality | Better move |
|---|---|---|
| Write shorter prompts | Typed text was about 0.01% of usage in the audit. Vague prompts do cost more, but through extra file reads and rework, not length. | Be specific about files and goals |
| Compact to save tokens | Compaction sends your whole conversation once more to write the summary, then invalidates the cache. It buys continuity, not savings. | Use /clear between jobs and /rewind for small undo steps |
| Screenshot text instead of pasting it | An image is not cheaper than the words it contains, and the agent cannot edit it. | Paste the text |
| Switch to a cheaper model when low | The model is part of the cache key, so the whole history is reprocessed. | Choose the model at session start |
| Close Claude Code to stop usage | Idle background usage is tiny. Scheduled tasks and agent teams are the real drain. | Audit automation |
| Upload PDFs directly | You can pay for the text and for a picture of each page. | Convert to plain text first |
What Is a Practical Weekly Routine to Keep Token Use Low?
The labs are not graded on how few tokens you use, so nobody will tidy this for you. It is your desk, and it drifts. You add a server, install a plugin, change a setting, and six weeks later you are back at the limit wondering why. A short weekly routine prevents that.
- Before each job: decide the model and effort, then start a clean session with
/clearor a new window. - During the job: paste text instead of screenshots, point to specific files, and let noisy commands run through a quiet wrapper.
- At natural breaks: name the session with
/renameso you can resume it, then clear. - Once a week: run
/context,/usageand the audit prompt. Disable tools you have not used in a month. - After each automation change: check the interval against your cache lifetime and delete tasks you no longer need.
- After each upgrade: start a new session rather than resuming a very long one.
Which fix should you do first?
| Your symptom | Most likely cause | Start with |
|---|---|---|
| Limit hit after one long day in one thread | History resent for many turns | Fix 1, /clear between jobs |
| Sudden jump after changing a setting | Cache invalidated | Fix 2, stop changing model, effort or fast mode mid-session |
| Large baseline on a brand new session | Tools, memory and skills loading up front | Fix 4, trim tools and memory |
| Usage climbs while you are away | Scheduled tasks or agent teams | Fix 7, audit automation |
| Install and build commands bloat the thread | Unfiltered command output | Fix 3, quiet wrapper or hook |
How Can Students and Self-Learners on a Tight Budget Apply This?
If you study for IT certifications and share one plan between practice labs, scripting and notes, tokens are a real budget. Many learners in Pakistan and across South Asia pay for tools in dollars while earning in rupees, so a wasted hour of quota is a real cost. The same habits apply, with a few study specific tweaks.
- One topic per session. Clear when you move from networking to operating systems, for example. Mixed topics drag irrelevant history along.
- Paste your notes as text. Do not screenshot textbook pages or upload whole PDFs. Convert to text and paste only the section you are studying.
- Start on a small model for drills. Flashcard style questions and quick explanations rarely need the largest model.
- Keep a short study memory file. A few lines on your exam, your weak domains and your preferred explanation style save you repeating yourself every session.
- Do not leave automation running. A forgotten scheduled task can burn a week of quota overnight.
For exam focused learning paths, see our guide to CompTIA study methods that work and our cybersecurity career roadmap. If you use AI tools to practice labs, pair this guide with our notes on using AI tools responsibly for computer science study.
What Has Changed in 2027 That Affects Token Use?
Several things moved in 2027, and they change how you should think about cost. First, Claude Code now exposes prompt cache statistics inside the session cost view, so you can see your cache hit share and the reason for each miss instead of guessing. Second, tool search and deferred loading became the normal way tools are listed, which shrank the up front cost of connected servers but did not remove the contents page. Third, new model generations arrived during the year, so the price gap between the small and large tiers is something you should recheck rather than assume.
Fourth, cache lifetime now depends on how you are billed and on whether you are drawing on usage credits. That makes idle time a real variable. A long lunch on a short lifetime means the next message is rebuilt from scratch. Before a long break, clear the session or finish the task, so you return to a clean start instead of an expensive rebuild.
Finally, agent teams and scheduled routines became more common in everyday workflows. They are powerful, and they are also the easiest way to spend quota without noticing. Treat each one like a recurring subscription: review it, justify it and cancel it when it stops earning its place.
Frequently Asked Questions About Claude Code Token Usage
Why does Claude Code hit its usage limit so quickly?
Because every message resends the entire conversation, including earlier file reads and command output. Most of your usage is the same history being processed again, not the words you type.
Does /clear save tokens in Claude Code?
Yes. It resets the conversation history to zero, so the next job does not carry the old one. It is free and is the highest leverage habit. Use /rename before clearing so you can /resume the old session later.
Is switching to a cheaper model mid-session a good way to save tokens?
Usually not. The model is part of the cache key, so switching makes the whole conversation reprocess at full price on the next turn. Choose your model at the start of a session and leave it alone.
Does /compact save money?
Not really. Writing the summary requires sending the whole conversation once more, and the rewritten history invalidates the cache. Compaction preserves continuity, while /clear is what actually resets cost.
Do subagents reduce total token usage?
They usually increase total usage but keep your main context clean. They are worth it when the output is high volume, you will not need the detail again and the session will continue for many more turns. Running them on a small model cuts the isolated cost further.
How do connected tools affect context size?
Each connected tool adds a description the agent must read. Deferred tool loading shrinks that cost by loading full definitions only on demand, but the list of tool names still grows with every connection. Disable tools you have not used in a month and check that /context shows the tools line as deferred.
Can scheduled tasks drain my limit overnight?
Yes. Each firing resends the task's full context, and if the interval is longer than your cache lifetime every firing is billed at full price. Review scheduled tasks and live agent teams regularly and delete any you no longer need.
Do shorter prompts help reduce token usage?
Barely. In a real audit, typed text was about 0.01% of usage. Vague prompts can cost more because they trigger extra file reads and rework, so clarity matters more than brevity.
Which commands show my Claude Code token usage?
Use /context to see what is in your window, /usage to see plan consumption and what caused it, and /cost for the current session. Recent versions also show prompt cache statistics in the session cost view.
What Should You Do Next?
Start with the two free fixes today. Clear between unrelated jobs and stop switching models inside a session. Then run /context once, disable the tools you have not touched in a month, and review your scheduled tasks. If you do only those, you will remove most of the waste for most setups.
You did not run out of tokens because you asked too much. You ran out because much of what you paid for was the agent re-reading things you had already sent. Now you know where the switches are.
Related Posts
Sources and further reading:
Anthropic: Manage costs effectively (Claude Code docs)
Anthropic: How Claude Code uses prompt caching
Anthropic Engineering: How we built our multi-agent research system
Claude Code Hub: what broke your cache
