Claude usage, explained: where your Pro and Max tokens actually go

The meter is tokens, and the window is rolling

The mental model that trips people up is thinking in messages. Claude does not count messages. It counts tokens, and it weights them by conversation length, the model you picked, the features in use, and the tool calls the agent makes. A two-line prompt at the end of a long session can cost far more than the same prompt at the start, because the whole live context rides along on every turn.

The session window is rolling, not a fixed clock. It opens with your first prompt and covers the next five hours, then resets with a fresh allowance. Fire your first prompt at 10 AM and the window resets at 3 PM regardless of how many prompts you sent in between. Sitting on top of that are weekly caps that accrue across sessions; Max plans carry two of them, one across all models and one for Sonnet usage specifically. Anthropic publishes relative multipliers (Pro at 1x, Max at 5x and 20x) rather than fixed token counts, and its own best-practices doc confirms the shared-pool behavior across claude.ai, Desktop, and Claude Code.

Where the tokens really go in an agent session

Visible prompts and responses are a small slice of the bill. In an agentic session the larger contributors are the parts you do not type: the CLAUDE.md files loaded at every launch, auto-memory, MCP tool definitions, and codebase search, which is usually the single largest contributor. Every retry re-sends context too. None of this shows up as a message in your transcript, but all of it counts against the 5-hour window.

This is the part the limit numbers cannot tell you. Two people on the same Max 20x plan can have wildly different reset timers because one of them keeps short, focused windows and the other runs a single sprawling session all day. The plan sets the ceiling. The tool sets how fast you walk into it.

Why a no-compact wrapper changes your usage math

Fazm is a native macOS app that runs the real Claude Code agent loop and signs in with your existing Claude Pro or Max account. There is no separate metering: usage hits your existing plan and the same shared 5-hour and weekly pool as everything else. That is the boring, important part. The interesting part is what Fazm does differently with context, because that is what moves the meter.

Raw Claude Code auto-compacts a long session: when the conversation approaches the context limit it silently summarizes earlier turns and drops detail to keep going. That saves tokens, but the summary is lossy and you cannot see what was cut, so a decision you made an hour ago can quietly vanish. Fazm does not do that. The full chat history stays live in context for the lifetime of the window, which means nothing gets silently dropped and also means a long window genuinely costs more per turn. The lever that controls that cost is the one-click fork: when the accumulated context gets heavy, you fork to a fresh window from a clean checkpoint and leave the original untouched. You decide when to reset the token weight, instead of a compaction heuristic deciding for you.

Verify it yourself: the “usage hits your existing plan” behavior and the no-auto-compact design are stated on the Claude Code wrapper page and live in the open-source app at github.com/m13v/fazm. You bring the account; Fazm changes only how context is kept and reset, never who gets billed.

Practical ways to stretch a Claude session

None of these are Fazm-specific tricks; they follow directly from the meter being tokens. Keep CLAUDE.md lean, since it loads on every launch. Avoid re-running the same broad codebase search when you already had the agent read the files. Pick the smaller model for routine turns and save the largest one for the hard problem. And when a window has accumulated a lot of context you no longer need, start fresh from a checkpoint rather than dragging the whole history into every remaining turn. Check the /usage readout before a big run so you know how much of the window you have left.

For more on when compaction actually helps versus hurts, see controlling Claude Code context compaction.