Claude Context Windows,
Tokens, and Usage Limits.

1. What is a context window?

A context window is everything Claude can see at one moment — Claude's current working memory. It includes:

• · The system prompt
• · Your full conversation so far (every turn, both sides)
• · Every tool call Claude has issued
• · Every tool output that came back
• · Every file Claude has read
• · Every skill, MCP server, or agent loaded into the project
• · CLAUDE.md and any project-level context files

Context window sizes differ by surface. As of April 2026:

The baseline overhead nobody talks about

A fresh Claude Code session isn't at zero tokens. Before you type anything, startup overhead commonly burns 8,000+ tokens from system prompts, CLAUDE.md, context files, MCP tool schemas, and loaded skills.

In heavier setups that baseline is much larger — one fresh session was observed at 62,000 tokensbefore the first user prompt. That's 6.2% of a 1M window spent before the work begins.

2. How tokens actually work

A token is the smallest unit of text Claude reads and bills for. Roughly one token ≈ one word, but not exactly — punctuation, spaces, and word pieces count separately. “Unhappiness” is usually 3 tokens; “the cat sat” is usually 4.

The compounding cost most people miss

Every time you send a message, Claude rereads the entire conversation from the beginning plus the new input, then generates a response. Those re-read tokens are billable input tokens.

This means your session cost doesn't add — it compounds. Rough numbers from a typical coding chat:

Message 30 costs 31× more per turn than message 1. A community analysis of a 100+ message session found 98.5% of total token spend was re-reading the prior conversation — not new input, not output, just rehashing what had already been said.

The implication is unintuitive: the cheapest thing you can do is start a new session sooner, not try to be terser in the existing one.

3. Input vs output tokens

Output tokens cost more per token than input tokens — across every current Claude model, output is priced 4-5× higher.

Instinct says: “tell Claude to be concise, cut output, save money.” In practice this doesn't move the needle. Output volume in a typical coding session is dwarfed by tool outputs — file reads, grep results, test runs, build logs — which all end up on the input side on the next turn.

“Be concise” plugins and prompts have been measured in community A/B tests — real savings are usually in the 5-10% range, not the 50-70% people expect. The thing that actually moves token spend is managing what enters your context in the first place.

4. Context rot (AI dementia)

Context rot is what happens when a session runs long: model performance measurably degrades as Claude's attention spreads across every token in the window. You've seen the symptoms:

• · Contradicting itself across turns
• · Editing files it didn't bother to re-read
• · Forgetting decisions from earlier in the session
• · Getting vague and noticeably sloppier

The numbers from Anthropic's own retrieval benchmarks are stark:

A 14-point accuracy drop means Claude is measurably worseat finding what it needs in a nearly-full window. The session can “technically” hold a million tokens and still be the wrong tool for the job at that size.

Independent community analysis of 18,000 thinking blocks across 7,000 Claude Code sessions found that thinking depth drops 67% as sessions get longer, and edit-without-reading rates rose from 6% in short sessions to 34% in long ones. Longer sessions produce sloppier work — your token efficiency goes down because you need more turns to hit the same output quality you would have gotten at minute five.

5. Usage limits across surfaces

Usage limits work differently on every Claude surface. Here's the rough shape of each:

Claude.ai (Pro, Max, Team, Enterprise)

Usage is measured as a rolling 5-hour allowance of messages, with plan tier determining how many messages that allowance contains. Long conversations count more heavily because each message re-reads the entire thread — the same 10-message chat consumes more quota than 10 fresh 1-message conversations.

Claude Code

Claude Code meters on both a 5-hour rolling window and a weekly limit, with the exact allowance depending on your plan. The new desktop app surfaces your remaining session-limit bar live — watching that bar is the single cheapest habit to build. One monitor for work, one glance at the limit.

API (Anthropic platform)

The API uses token-per-minute and request-per-minute rate limits that scale with your usage tier. Tiers are unlocked automatically as your spend and history grow — see the Anthropic console for your current tier and ceilings.

What burns limits fastest

• Long conversations. The compounding re-read is the biggest single line item.
• Large file reads dumped into the session. One multi-megabyte log pasted in stays resident for the rest of the session.
• Auto-compaction firing late.When compaction triggers at 95%, you've already paid to re-read a near-full window many times.
• Opus when Sonnet would do. Opus is roughly 5× the per-token cost of Sonnet and 25× the cost of Haiku; choose the model to the task, not the other way around.

6. The five choices after every Claude response

Anthropic frames session management around a simple insight: after each Claude response, you have exactly five choices. Knowing which to pick is the single biggest lever on token spend.

Why rewind beats “try again”

The most common way people waste tokens: Claude produces broken code, you say “that didn't work, try this,” and Claude tries something else. It often works — but the failed attempt is still in context and gets re-read on every subsequent turn. /rewind lets you jump back and retry with a clean slate.

When you use the Rewind menu in Claude Code, there's also a “Summarize from here”option that creates a handoff message — a note from Claude's future-self to its past-self saying “here's what we figured out, skip the dead ends.” Use it when you want the learning but not the baggage.

7. Manual vs auto compaction

Auto-compaction kicks in at roughly 95% of your context window. The community consensus, which aligns with our experience, is that 95% is way too late. Two problems:

• · Auto-compact only retains 20-30% of the original detail. You lose decisions, file paths, and nuance that the next phase needs.
• · The compaction itself runs at the model's least intelligent point — peak context rot. The summary quality is at its worst.

Analogy: packing for a trip. If you pack the night before, you make a list, check it, and remember everything. If you throw clothes in the bag five minutes before leaving, you forget your charger, your toothbrush, the adapter. Auto-compact at 95% is the five-minutes-before pack.

The manual-compact pattern that works

Instead of waiting for auto, use this three-step pattern at around 50-60% of your window:

Why this beats /compact: you control the summary quality because Claude is still sharp at 60% fill. You also get a chance to review the summary before committing, strip anything irrelevant, and add tracking files (decision log, task list, plan doc) so nothing important lives only in chat history.

8. Sub-agents done right

A sub-agent is a Claude task delegated to its own fresh context window. It does its work, synthesizes results, and returns a bounded output to your main session. Your main session never sees the intermediate steps.

Think of it as briefing a research intern. If you wanted an intern to synthesize 50 articles, you wouldn't sit behind them reading each article alongside. You'd say “find the three most important findings and hand me the summary.” You spend one sentence of headspace; they do the grind.

When to delegate

• · Codebase exploration— “map how auth works, summarize the flow, list the three files I need to read”
• · Documentation lookup— “find the correct API signature in node_modules, return just the signature”
• · Verification— “run the test suite and report only the first failing test”
• · Independent review— “check this migration for concurrency issues, return a yes/no + one-paragraph reasoning”

Match the model to the task

Sub-agents don't have to run on your main session's model. A “summarize these 15 files” agent on Haiku costs ~4% of what it costs on Opus and delivers the same quality. Be explicit in the delegation prompt: “Use Haiku. Return a bulleted summary under 200 words.”

9. Practical token-saving techniques

Watch your session meter constantly

If you're on the Claude desktop app, keep the session- limit bar visible on a second monitor. Nothing changes habits faster than seeing the number tick down in real time. If you're at 60% and the reset is an hour away, abuse it — spin up agents, run heavy tasks. If you're at 20% with four hours left, be strategic.

Convert everything to markdown before Claude reads it

PDF, DOCX, and HTML carry layout, metadata, and styling noise that the model doesn't need. Stripping to markdown gives you roughly the same content in a fraction of the tokens:

A 40-page PDF and a 130-page markdown file fit in roughly the same amount of context. Tools like Docling, Marker, or a quick pandoc conversion handle this in seconds. PDF-with-OCR for scanned documents is a separate conversation — there you need vision input and the savings don't apply.

Use /btw for side questions

Claude Code's /btw opens a quick overlay for side questions that don't enter your conversation history. Use it when you're deep in a task and need a quick reference — what's the flag for X, which file is config in — without polluting the main context.

Start every session in plan mode

Boris Chernyi, creator of Claude Code, has said publicly that he starts every session in plan mode. Getting agreement on the plan before writing a line of code consistently costs fewer total tokens than jumping straight to implementation. Bad plans cause rework. Rework compounds. One good 10-minute plan saves an hour of mid-task pivots.

CLAUDE.md discipline — under 200 lines

CLAUDE.md loads on every session. If it's 600 lines of meandering conventions, you pay for those 600 lines every time. The rule of thumb:

• · CLAUDE.md: under 200 lines / ~2K tokens
• · Specialized instructions → move to skills or context files loaded on demand
• · Large repos → add a .claudeignore so Claude doesn't pull in vendor directories, build artifacts, or lockfiles

Session chaining for big projects

If you're running a large project across multiple days, don't try to do it all in one session. Split into an assembly line where each session has a specialized job:

10. Knowing where your tokens go

You can't optimize what you can't see. If your only signal is “session limit hit again,” you have no basis for changing habits. A useful token-observability setup tracks at minimum:

• · Tokens per project — which repos burn the most
• · Tokens per prompt — which specific requests were the most expensive, so you can reverse-engineer why
• · Input vs output split— a project that's 80% input is usually a read-heavy setup that would benefit from more aggressive file filtering
• · Cache hit rate— Anthropic's prompt cache gives you a ~90% discount on cached input tokens. Low cache hit rate is a sign your prompts are changing too much session-to-session
• · Skill + tool invocation frequency— a skill running 181 times a week is either paying for itself or you're accidentally triggering it

A simple approach: log each message's input / output / cache-read / cache-create token counts into a spreadsheet or a small SQLite database, group by project and model, and review weekly. You don't need a fancy dashboard — a Monday-morning 5-minute review catches the runaway sessions before they become monthly-bill surprises.

11. Why 1M doesn't mean “use 1M”

When people hear “1 million token context window,” they treat it like a budget to spend. Three failure modes follow:

• · Stop using sub-agentsbecause there's “room” in the main session
• · Stop compacting because the progress bar still looks mostly empty
• · Offload everything into one giant session instead of chaining

The rules of how transformer models work didn't change when the window got bigger. A bigger window means more room for context rot, not a better output ceiling. The first 20%of a session is prime time — CLAUDE.md is fresh, the model's attention is focused, and retrieval accuracy is near its ceiling.

If you're new to Claude Code, stay on the 200K context models for a few weeks before moving to Opus 1M. Learn the discipline — compaction habits, session chaining, CLAUDE.md hygiene — on the smaller window first. When you graduate, the larger window is insurance, not a target.

12. Tool ecosystem

A handful of open-source tools tackle token reduction from different angles. Don't install all of them — each has overhead and they don't all play well together. Pick one or two that match your actual workload.

How to pick: the cheapest approach is to point Claude itself at the list, describe your workflow in 3-4 sentences, and ask for the best match given your actual pain points. Any one tool is a small win. Good habits across all 13 sections of this guide are a 50-70% win.

13. When to just start over

Sometimes a session is just off. The model is repeating itself, it's missing obvious things, tool calls are failing for no clear reason. You're below your usual threshold for compaction. Should you soldier through?

No. Clear it. Start fresh. The cost of “wasting” a half-full session is almost always lower than the cost of pushing through context rot. Your best guard against burning tokens on a bad session is the discipline to walk away from it.

This is the habit people underrate the most. Having a tracking file or a handoff summary saved somewhere means that “starting fresh” costs you two minutes, not thirty. Build the safety net and using it becomes reflex.

FAQ