You have been working with an AI coding agent for about an hour. The session started great. But now the agent is re-reading files it already modified, asking questions you already answered, and generating code that contradicts its own earlier output.
What happened behind the scenes is context compaction. The agent's conversation history grew too large for its context window, so the runtime quietly compressed the older parts to make room. Some details survived. Others did not.
How Context Compaction Works
Every AI coding agent has a fixed context window. This is the total amount of text it can process at once, including your messages, the agent's responses, file contents, tool outputs, and system instructions. When all of that exceeds the limit, something has to give.
Context compaction is the process that decides what stays and what gets summarized. The agent's runtime takes the older portion of the conversation and condenses it into a shorter summary. That summary replaces the original messages, freeing up space for new interactions.
Think of it like packing a suitcase for a trip. You can only fit so much. At some point, you stop folding clothes neatly and start stuffing things in. Some items get left behind entirely. Context compaction works the same way, except the agent does not tell you what it left behind.
What Gets Lost During Compaction
Compaction preserves the general direction of the conversation but loses the specifics. Here is what typically survives and what does not.
| Usually Survives | Often Lost |
|---|---|
| The main task or goal | Exact variable names discussed early on |
| Recent file changes | Specific design decisions from 30+ minutes ago |
| Current file contents in context | Rejected approaches and why they were rejected |
| System instructions and project files | Nuanced constraints you mentioned once |
| The last few exchanges | Early corrections or clarifications |
The pattern is clear. Recent information is safe. Older details, especially ones that were mentioned briefly and not repeated, are the first to disappear.
Why Context Compaction Costs You Tokens and Time
When compaction drops something important, the agent does not realize the information is gone. It continues working as if everything is fine. But eventually it hits a gap in its memory and has to compensate.
The most common compensation is re-reading files. The agent opens a file it already read and processed earlier in the session. You pay for those tokens again. Research shows that conversation history re-sending accounts for roughly 50 to 60 percent of total token spend in a typical coding agent session.
Beyond the token cost, there is the time spent on contradictions. The agent might switch from one naming pattern to another because it forgot what it used earlier. Or it might create a duplicate utility function because the compacted summary did not preserve the details of the original one.
"You are not paying for the agent to think harder. You are paying for it to rediscover what it already knew."
Context Compaction vs Context Rot
These two concepts are closely related but not identical. Context compaction is the mechanism. Context rot is the consequence.
Compaction is a technical process that happens automatically when the session exceeds the window. It is not inherently bad. Without it, the agent would simply stop working once the window filled up.
Context rot is the degradation of the agent's understanding that results from lossy compaction. Every time compaction runs, there is a risk that something important gets summarized away. Over multiple rounds of compaction in a long session, the rot compounds.
- Compaction is the cause
- Context rot is the effect
- Token waste is the cost
- Inconsistent code is the outcome
How to Minimize the Damage from Context Compaction
Keep Sessions Short and Focused
The simplest way to avoid compaction problems is to never hit the context limit in the first place. Break your work into focused 20 to 30 minute sessions. One task per session. Start fresh with a clean context for each new task.
Use Instruction Files That Persist
Put your project conventions, database schemas, and architectural decisions in a CLAUDE.md or AGENTS.md file. These files get loaded into every session automatically. They do not depend on conversation memory, so compaction cannot touch them.
Repeat Critical Constraints
If a constraint is critical, do not mention it once at the start and assume the agent will remember. Restate it when you give a new sub-task. Repetition is cheap compared to the cost of the agent forgetting.
Front-Load Important Context
Load the most relevant files and instructions at the very beginning of the session. Information at the edges of the context window, the very start and the very end, tends to survive compaction better than content buried in the middle.
Watch for the Re-Read Signal
If the agent starts re-reading a file it already processed, that is your signal that compaction has kicked in and dropped something. At that point, consider starting a new session rather than pushing forward. Continuing will only add more tokens to an already overloaded context.
The Bigger Picture of Context Management
"The best coding agent session is one that ends before compaction ever runs."
Context compaction is not a flaw. It is a necessary trade-off that lets AI agents handle sessions longer than their raw context window would allow. But it comes with real costs in tokens, time, and code quality.
As AI coding tools become central to how developers work, understanding context compaction moves from nice-to-know to need-to-know. It connects directly to related concepts like context rot, agent drift, and token budgets. Developers who understand the mechanics make better decisions about session length, task scoping, and when to start fresh.
Conclusion
Context compaction is what happens when your AI agent's conversation history exceeds its context window. The runtime compresses older exchanges into summaries, and details get lost in the process. This leads to re-read cycles, token waste, and inconsistent output. The fix is straightforward: keep sessions short, use persistent instruction files, repeat critical constraints, and start a new session the moment you see the agent re-reading files it already touched.
