Claude Opus 5.5 has a 1M token context window. I keep every agent under 100K anyway. Past 200K a slight drift sets in.
These are personal observations, not measured thresholds.
The orchestrator is the weak point
When a subagent drifts, you can get a weaker answer back. When the orchestrator drifts, that drift can spread through its briefs.
Claude Code's subagents normally start with a fresh, isolated context window. Forks inherit the parent conversation instead. A fresh subagent gets its task through the orchestrator's brief. Without the history, it may miss a constraint the brief dropped.
Compact before the window fills
Anthropic's session guide warns that growing context can hurt performance. Claude Code summarizes automatically near the window's limit. The guide recommends compacting earlier and saying what comes next.
/context
/compact focus on the auth refactor, drop the test debugging
/context shows what's filling the window. The /compact line is the guide's own example. Codex has /compact too.
Chroma's Kelly Hong, Anton Troynikov and Jeff Huber evaluated 18 LLMs in July 2025. Performance "grows increasingly unreliable as input length grows". The models included GPT-4.1 and Claude 4, not Opus 5.5. Neither source draws a line at 100K or 200K.
What the cache fixes
For 100K input tokens on Opus 5.5, using API prices checked on November 3, 2026:
| Billed as | Per million tokens | 100K tokens |
|---|---|---|
| Uncached input | $4 | $0.40 |
| Cache write, 5 minutes | $5 | $0.50 |
| Cache write, 1 hour | $8 | $0.80 |
| Cache hit | $0.20 | $0.02 |
Each amount is the listed rate multiplied by one tenth. These are input costs only; output and tool charges are excluded. They are not subscription prices. Other models have other multipliers.
The hit is 0.05× the input price, and it doesn't buy room. Anthropic's words: "prompt caching changes what you pay for those tokens, not whether they count."
Compaction also rewrites the history. Hits need 100 percent identical prompt segments, so the unchanged start can still hit, and the rewritten part can't. CompactionBench, from Microsoft researchers, lists "disrupting prefix-cache reuse" among the problems.
What compaction can lose
Amp removed compaction on October 23, 2025 and replaced it with Handoff. It calls compaction lossy: the agent decides what survives in the summary. Compacting early still carries that risk. A constraint you stated early can disappear.
Test the number
This comparison has not been run for this article.
- Pick one fixed task and repo snapshot. Keep the same exact model and effort.
- Write a list of constraints. State them only at the start of the session.
- Prepare and save starting contexts at 50K, 100K and 200K. Check the size with
/context. - Compare runs from each saved context before and after
/compact. Restore the repo snapshot before each run. Repeat each comparison. - Score tests passed and constraints kept.
task,model,effort,input_tokens,compacted,run,tests_passed,constraints_kept
On the API, log input_tokens, cache_read_input_tokens and cache_creation_input_tokens. Those separate uncached input from cache reads and writes.
The maintained article, with all ten context terms and what each does to the budget, is on argbe.tech.

Top comments (2)
Your proposed before-and-after compaction test would benefit from separating forgotten constraints from stale task state. A summary can preserve every requirement yet incorrectly carry an earlier assumption that a file was already changed or a failed approach is still viable.
I would include one task where an early hypothesis gets explicitly overturned, then check whether both the orchestrator and a fresh worker use the corrected fact after compaction. Save the generated brief with the result. That helps locate whether the failure happened in summarization, delegation, or execution, instead of attributing every bad run to context length.
"When the orchestrator drifts, that drift can spread through its briefs" is the line I'd underline.
Our setup keeps task briefs and recorded decisions available outside the orchestrator's session. Our manager agent writes each task as a card, and decisions go into a shared memory: an agent records the decision with quotes from the chat messages, the server checks that the quotes match those messages, and a person confirms it. A fresh engineer session can read the card and look up recorded decisions it has access to. A constraint omitted from the brief can be recovered there if it was recorded in a decision. (That's polyroom, which we build.)
Do you have the orchestrator re-read the original task after /compact, or does the compact summary become the new source of truth?