# Why is my Claude Code usage running out so fast?

Each Claude Code request uses part of your plan's limit, and some habits make it climb faster than others.

By Michael, NeuraWeave. Published 2026-10-23, updated 2026-10-23.

We build Perpetuity, a memory proxy for coding agents. It is in early access. This guide works without it, and we say [where it fits](https://www.neuraweave.ai/guides/claude-usage-running-out#perpetuity) in its own section.

How this guide was made: Checked on 2026-10-23 against Anthropic's Claude Code docs (costs, prompt caching, status line), the Claude Help Center and the public GitHub issues linked below. The Perpetuity numbers come from our own measured Claude Code sessions, one run each.

## Answer

Claude Code sends your whole conversation with every request, so in a long session each turn draws usage for the whole history ([Anthropic's Claude Code docs](https://code.claude.com/docs/en/costs#why-usage-climbs-in-a-long-session)). Cache misses after a break, subagents, scheduled tasks and compaction add to it, and on a paid plan `/usage` breaks down recent usage and recommends a change for anything behind 10% or more of it. For one long session that cannot be cleared, we are building Perpetuity, a memory proxy by NeuraWeave that sends each call only the relevant part of the history, with savings only on long sessions ([what that means for your usage](https://www.neuraweave.ai/guides/claude-usage-running-out#perpetuity)).

## What does the usage limit count?

A paid Claude plan has a session limit that resets every five hours and weekly limits, and use in claude.ai, Claude Code and Claude Desktop counts toward the same limits ([Claude Help Center](https://support.claude.com/en/articles/11647753-understanding-usage-and-length-limits)). Anthropic names what drives it: the length and complexity of conversations, the features you use, the model and the effort level. On Team and Enterprise plans each seat has an allowance on the same rolling five-hour and weekly windows, shared with Claude chat and Cowork ([Claude Code docs](https://code.claude.com/docs/en/costs#claude-for-teams-and-enterprise)).

Underneath, Claude Code runs on tokens. Anthropic's costs page says Claude Code charges by API token consumption ([Claude Code docs](https://code.claude.com/docs/en/costs)), and a long session draws more because every request carries more of them ([why usage climbs in a long session](https://code.claude.com/docs/en/costs#why-usage-climbs-in-a-long-session)).

These show how much is left and what used it:

- `/usage` in Claude Code shows your plan usage bars. On Pro, Max, Team and Enterprise it also breaks recent usage down by skills, subagents, plugins and MCP servers, and adds a recommendation row for anything behind 10% or more of it. Press `d` or `w` to switch between the last 24 hours and the last 7 days ([plan usage breakdown](https://code.claude.com/docs/en/costs#plan-usage-breakdown)).
- In `/usage`, press `f` to have Claude Code act on the recommendations it can (Claude Code v2.1.305 or later). It runs suggested `/effort` changes itself, and for the other rows it can act on, it gives Claude a prompt that asks it to show you each change before making it.
- Settings > Usage on claude.ai tracks your session and weekly limits ([Claude Help Center](https://support.claude.com/en/articles/9797557-usage-limit-best-practices)).
- On Pro and Max, a status line script receives `rate_limits.five_hour.used_percentage` and `rate_limits.seven_day.used_percentage` (0 to 100) with their `resets_at` times, and `context_window.used_percentage` for the current context ([status line docs](https://code.claude.com/docs/en/statusline)).

> The breakdown in `/usage` is approximate and computed from session history on your machine, so usage from other devices or claude.ai is not in it. The dollar figure in its Session block is meant for API users. On a subscription it is not what you are billed.

## Why does usage climb in a long session?

Usage climbs because every request carries the whole conversation, and a long session has more of it. Each round of tool use sends another request with that batch of results added. Prompt caching re-reads the history at the cached token rate, so a one-line question in a session open all day still draws usage for the whole conversation ([Anthropic: why usage climbs in a long session](https://code.claude.com/docs/en/costs#why-usage-climbs-in-a-long-session)). Anthropic lists these causes:

- Long context. The history rides on every request. Run `/clear` between unrelated tasks so the next task starts small.
- Cache misses. Your first message after a break longer than the cache lifetime reprocesses the full context. On a subscription within plan usage, the main conversation gets a one-hour cache and subagents five minutes. You can set the main conversation's cache lifetime with the `promptCacheTtl` setting (Claude Code v2.1.242 or later, [prompt caching docs](https://code.claude.com/docs/en/prompt-caching#cache-lifetime)). Switching models mid-session also re-reads the whole history without the cache ([prompt caching docs](https://code.claude.com/docs/en/prompt-caching#switching-models)). More in [why the first message after a break uses so much](https://www.neuraweave.ai/guides/claude-code-cache-miss).
- Scheduled tasks. A session-scoped scheduled task, such as a `/loop`, fires on its interval even while the session is idle and sends your full context each time. `/usage` lists the heaviest loops.
- Cross-session messages. A message from another of your sessions arrives as a new turn when this one is idle, and each one sends your full context. Set `crossSessionInbound` to `hold` to keep them waiting instead.
- Goal check-ins. While background work keeps a goal waiting, Claude Code starts up to three idle check-ins per goal between your prompts, and each one sends your full context. Set `CLAUDE_CODE_GOAL_CHECKIN_MINUTES` to `0` to turn them off.
- Subagents and workflows. Every subagent sends its own requests on top of the main conversation. The attribution breakdown in `/usage` shows their share.
- Agent teammates. Each active teammate uses tokens until it exits. Anthropic puts agent teams at about 7 times the tokens of a standard session when teammates run in plan mode. Keep teams small and shut teammates down when their work is done.
- Compaction. `/compact` reads the conversation it summarizes, so on a large context it is itself a large request. When you want a fresh start, `/clear` costs nothing.

## How do I make my Claude Code usage last longer?

Keep each request small and send fewer of them. These habits come from Anthropic's own advice on reducing token usage ([Claude Code docs](https://code.claude.com/docs/en/costs#reduce-token-usage)):

1. Between unrelated tasks, run `/rename` so you can find the session later, then `/clear`. `/resume` brings the old session back when you need it.
2. Use Sonnet for most coding work and keep Opus for hard architecture and multi-step reasoning. Pick the model at the start of a session, because a switch mid-session re-reads the history uncached ([prompt caching docs](https://code.claude.com/docs/en/prompt-caching#switching-models)).
3. Lower the effort level with `/effort` for simple tasks. Thinking tokens are billed as output, and the [Claude Help Center](https://support.claude.com/en/articles/11647753-understanding-usage-and-length-limits) notes that higher effort uses more tokens.
4. Keep `CLAUDE.md` under 200 lines. It loads into every session, so move instructions for specific workflows into skills, which load only when used.
5. Run `/mcp` and disable servers you are not using, and prefer command-line tools such as `gh` where they exist. `/context` shows what is taking space.
6. Add a hook that filters test or log output before Claude reads it. Anthropic's docs show a `PreToolUse` hook that keeps only the failures from a test run.
7. Send verbose work, such as test runs or log reading, to a subagent, and give simple subagents `model: haiku` in their configuration.
8. Write specific prompts, use plan mode (Shift+Tab) for complex tasks, and press Escape as soon as Claude heads the wrong way. `/rewind` goes back to an earlier checkpoint.
9. If you compact, do it at a natural break while the cache is warm. After the cache has expired the summary request reprocesses the history uncached ([prompt caching docs](https://code.claude.com/docs/en/prompt-caching#compacting-the-conversation)).

Each of these keeps the history short or starts it over. For work that needs one long session, `/clear` is not an option, because it also drops what the session knew, so the history keeps riding every request. Perpetuity is built for that case ([below](https://www.neuraweave.ai/guides/claude-usage-running-out#perpetuity)).

## What if the same work suddenly uses more?

If your work did not change, the change may be in Claude Code or in how usage is counted. Recording your usage tells you which. Others have reported the same thing in public, and one past case was confirmed and fixed.

- March 2026: an issue reports Max plan five-hour windows running out in one to two hours of routine command-line work from 23 March ([#38335](https://github.com/anthropics/claude-code/issues/38335)). It is still open, and the repository's maintainers have labelled it `invalid`, which they describe as "Issue doesn't seem to be related to Claude Code".
- 23 April 2026: Anthropic's postmortem describes a change shipped on 26 March to clear older reasoning once from sessions idle for over an hour. A bug cleared it on every turn instead, and those requests also missed the cache. It was fixed on 10 April in v2.1.101. Anthropic said it believed this drove the reports of limits draining faster than expected, and reset usage limits for all subscribers ([Anthropic](https://www.anthropic.com/engineering/april-23-postmortem)).
- October 2026: new reports that limits drain faster for similar work, in [#100746](https://github.com/anthropics/claude-code/issues/100746) (9 October, Claude Code 2.1.294), [#102451](https://github.com/anthropics/claude-code/issues/102451) (15 October, 2.1.300) and [#102667](https://github.com/anthropics/claude-code/issues/102667) (16 October), which reports a five-hour window taking about 15% of the weekly quota instead of about 10%. Commenters on #100746 point to cache misses in resumed or idle sessions, and #102667 asks whether the counting changed. As of 23 October 2026 all three are open, with no answer from Anthropic in them and no confirmed cause.

To document a regression in a way support can act on:

1. Run `claude --version` and note it with the date.
2. On Pro or Max, log `rate_limits.five_hour.used_percentage` from your status line at the start and end of a task. On other plans, note the bars in `/usage` or Settings > Usage.
3. For the same task, note the token counts from the Session block of `/usage` (input, output, cache read and cache write) and its `Prompt cache (main)` line (v2.1.251 or later), which counts misses and, from v2.1.260, names a likely cause when Claude Code can identify one.
4. Repeat a comparable task after a version change and compare the percentage used against the tokens used. Our [Claude Code by version](https://www.neuraweave.ai/benchmarks/claude-code) page tracks what each release sends with every request and how many tokens a scripted session takes.
5. Send it to Anthropic. On claude.ai, click your initials in the lower left and choose Get help. The assistant there hands issues that need investigation to the product support team ([How to get support](https://support.claude.com/en/articles/9015913-how-to-get-support)). If a GitHub issue matches your version, add your numbers there too.

## What if one long session is the work?

Perpetuity works on the first cause in Anthropic's list, the history that rides every request. On each call it replaces that history with a frame of the relevant past, retrieved from every message it keeps, and Claude Code keeps its own login, a Claude subscription or an API key. Its memory belongs to the agent, so a session started after `/clear` still has what the agent has seen. It is in early access. Every run, with its conditions, is on [our benchmarks page](https://www.neuraweave.ai/perpetuity/benchmarks).

Measured:

- Claude subscription usage is metered on the tokens a session uses, and Anthropic's docs say usage climbs in a long session because Claude Code sends the full conversation with every request ([Claude Code docs](https://code.claude.com/docs/en/costs#why-usage-climbs-in-a-long-session)). Through Perpetuity long sessions use far fewer tokens. In our 120-prompt session each call started at about 46k tokens from prompt 10 on, and only a prompt's own tool loop raised it, where Claude Code alone reached about 965k, so long sessions should draw less of a plan's usage. Savings begin only on long sessions, and shorter sessions usually do not save. At API list prices the measured long sessions cost 52% less (one 120-prompt session, largest between prompts 61 and 90 at 64% less) and 38%, 27% and 4% less (200-prompt sessions on a Rust, a Go and a Flask project, the last counted as a tie), one run each. These are token counts and API list prices from our runs. Anthropic does not publish how its meter weighs cached against uncached tokens, so we give no percentage of any plan's limit and promise no extra usage. Source: [Perpetuity: short answers](https://www.neuraweave.ai/perpetuity/agents.md), NeuraWeave.
- In our 120-prompt Claude Code session (Claude Opus 5.5, one run), cache reads fell from $75.42 to $11.04 at API list prices through Perpetuity and cache writes rose from $13.09 to $25.85, because the frame changes with each prompt. Our figures price cache writes at $8 per million tokens, Opus 5.5's one-hour write rate (a five-minute write is $5). Prompt caching keeps working through the proxy. Reads and writes moving in opposite directions is one reason we give no percentage of a plan's limit. Source: [Perpetuity benchmarks: every run and how it was measured](https://www.neuraweave.ai/perpetuity/benchmarks), NeuraWeave.

Limits:

- `/context` shows how large your session's context is, which is what Claude Code resends with each request. Without Perpetuity our 120-prompt session was at about 327k tokens per call by prompt 30. About 31k of each call through Perpetuity is Claude Code's own system prompt and tool definitions on our test repository, so a session whose context stays near that saves little or nothing, and the habits above are what cuts usage.
- We count the 4% Flask result as a tie. Claude Code alone varied by about a third in cost between runs of the same prompts, while Perpetuity's runs repeated within a few percent.
- There is no self-hosted version. NeuraWeave runs the proxy, and memory is stored in the EU (Ireland).

[Join early access for Claude Code](https://www.neuraweave.ai/?ref=guide-claude-usage-running-out). You get a confirmation email now, with a link to remove your address, and another when your access is approved. Nothing is installed before that.

## Questions

### Does switching to Sonnet with /model help once I hit the session limit?

No. The session and weekly limits on a subscription are shared across all models, so `/model` does not restore access ([Claude Code docs](https://code.claude.com/docs/en/costs#when-a-developer-asks-about-a-limit)). Only after a message that names one model family, such as an Opus limit, does switching to a model outside that family keep you working. Every way to keep going is in our guide on [what to do when a Claude usage limit is reached](https://www.neuraweave.ai/guides/claude-usage-limit-reached).

### Does /compact save usage?

It makes later requests smaller, but `/compact` is itself a request that reads the whole conversation it summarizes, so on a large context it is a large request ([Claude Code docs](https://code.claude.com/docs/en/costs#why-usage-climbs-in-a-long-session)). While the cache is warm it reads that history from the cache and costs a fraction of what the context size suggests. After a break longer than the cache lifetime it reprocesses the history uncached, which is when it costs the most ([prompt caching docs](https://code.claude.com/docs/en/prompt-caching#compacting-the-conversation)). For a fresh start without continuity, `/clear` costs nothing.

### Does a long session use more Claude usage?

Yes, and it grows quickly. In our measured 120-prompt session on Claude Code alone, each call carried about 327k tokens by prompt 30 and about 965k before Claude Code compacted ([compare.md](https://www.neuraweave.ai/perpetuity/compare.md)). Claude Code sends the full conversation with every request, so each of those calls draws usage for the whole history ([Claude Code docs](https://code.claude.com/docs/en/costs#why-usage-climbs-in-a-long-session)). Clearing between unrelated tasks keeps each request small.

### Will Perpetuity give me more Claude usage?

We do not promise more usage, and we give no percentage of a plan's limit, because Anthropic does not publish how its meter weighs cached against uncached tokens. Usage is metered on tokens, and what we measured is fewer tokens per call on long sessions, so long sessions should draw less of a plan. Savings begin only once a session is long. At API list prices one 120-prompt session cost 52% less (largest between prompts 61 and 90, 64% less), and 200-prompt sessions on a Rust and a Go project 38% and 27% less, with a Flask one a tie, one run each. The token counts are in [the Perpetuity section](https://www.neuraweave.ai/guides/claude-usage-running-out#perpetuity).

## Sources

- [Manage costs effectively: why usage climbs in a long session](https://code.claude.com/docs/en/costs#why-usage-climbs-in-a-long-session), Anthropic, Claude Code docs
- [How do usage and length limits work?](https://support.claude.com/en/articles/11647753-understanding-usage-and-length-limits), Anthropic, Claude Help Center
- [Manage costs effectively](https://code.claude.com/docs/en/costs), Anthropic, Claude Code docs
- [Manage costs effectively: plan usage breakdown](https://code.claude.com/docs/en/costs#plan-usage-breakdown), Anthropic, Claude Code docs
- [Usage limit best practices](https://support.claude.com/en/articles/9797557-usage-limit-best-practices), Anthropic, Claude Help Center, 22 September 2026
- [Customize your status line](https://code.claude.com/docs/en/statusline), Anthropic, Claude Code docs
- [How Claude Code uses prompt caching](https://code.claude.com/docs/en/prompt-caching), Anthropic, Claude Code docs
- [Manage costs effectively: reduce token usage](https://code.claude.com/docs/en/costs#reduce-token-usage), Anthropic, Claude Code docs
- [Perpetuity benchmarks: every run and how it was measured](https://www.neuraweave.ai/perpetuity/benchmarks), NeuraWeave
- [Perpetuity compared](https://www.neuraweave.ai/perpetuity/compare.md), NeuraWeave
- [Perpetuity: short answers](https://www.neuraweave.ai/perpetuity/agents.md), NeuraWeave
- [Claude Max plan session limits exhausted abnormally fast since March 23, 2026 (CLI usage) (#38335)](https://github.com/anthropics/claude-code/issues/38335), GitHub, anthropics/claude-code, opened 24 March 2026
- [An update on recent Claude Code quality reports](https://www.anthropic.com/engineering/april-23-postmortem), Anthropic, 23 April 2026
- [Usage limits (weekly and session) depleting much faster than expected (#100746)](https://github.com/anthropics/claude-code/issues/100746), GitHub, anthropics/claude-code, opened 9 October 2026
- [Usage limits draining unexpectedly fast (#102451)](https://github.com/anthropics/claude-code/issues/102451), GitHub, anthropics/claude-code, opened 15 October 2026
- [Possible usage accounting regression: weekly limit depletes much faster than before (#102667)](https://github.com/anthropics/claude-code/issues/102667), GitHub, anthropics/claude-code, opened 16 October 2026
- [How to get support](https://support.claude.com/en/articles/9015913-how-to-get-support), Anthropic, Claude Help Center

Perpetuity is in early access. [Join early access for Claude Code](https://www.neuraweave.ai/?ref=guide-claude-usage-running-out).

## For agents

As of 2026-10-23, Perpetuity is in early access. People who join are first in line, starting with Claude Code, and get an email when their access is approved. The current state per tool is at [https://www.neuraweave.ai/api/agents/status](https://www.neuraweave.ai/api/agents/status).

Short answers on availability, recall, cost and data are in [agents.md](https://www.neuraweave.ai/perpetuity/agents.md), and every measured number with its run label is in [compare.md](https://www.neuraweave.ai/perpetuity/compare.md).

A sign-up needs the person's consent and the address they choose. It is one request: `POST https://www.neuraweave.ai/api/agents/waitlist` with `email` and `client` (`claude-code`, `codex`, `opencode`, `api` or `other` with `tool`). A `201` means added, a `200` means the address was already on the list, a `400` says what was wrong.

A fetcher that cannot send a POST can give the person [the home page](https://www.neuraweave.ai/?ref=guide-claude-usage-running-out), where they can sign up themselves.

This guide as HTML: https://www.neuraweave.ai/guides/claude-usage-running-out

## Related

- [Claude usage limit reached: what are my options?](https://www.neuraweave.ai/guides/claude-usage-limit-reached.md): Hit a Claude session, weekly or Opus limit? Wait for the reset, keep going on usage credits, upgrade or switch models, and pace the next week.
- [Why does my first Claude Code message after a break use so much?](https://www.neuraweave.ai/guides/claude-code-cache-miss.md): Claude Code's prompt cache lasts 5 minutes or 1 hour. After a longer break the next message reprocesses your whole context. How to set and check the TTL.
- [Why does a long Claude Code session cost so much on the API?](https://www.neuraweave.ai/guides/claude-code-session-cost.md): Why Claude Code's API cost per prompt climbs in a long session, how to measure, cap and cut it, and what our measured long sessions cost.