An hour into a long agent session, something shifts. The agent starts re-reading files it already looked at, forgets a constraint you mentioned at the start, or confidently “fixes” something you already fixed together twenty minutes ago. Nothing crashed. The model just ran out of room to remember everything that came before.
Managing context windows is one of the least discussed but most consequential skills in working with AI coding agents, because everything the model “knows” about your task has to fit in a fixed amount of space. A context window is the total amount of text — your instructions, the files it’s read, its own previous responses — a model can hold at once while generating a reply. Once a session fills that space, older information has to be dropped or summarized to make room for new information, and that’s exactly when quality quietly degrades. This post covers what a context window actually is and the concrete habits that keep long agent sessions accurate.
What a Context Window Actually Is
Every large language model generates each response by considering a limited window of preceding text — the context window — measured in tokens, which are roughly word-and-punctuation-sized chunks. Everything relevant to a task has to fit inside that window at the moment the model responds: your original instructions, any files it’s read, tool output, and the back-and-forth conversation so far.
The window isn’t infinite, and it isn’t cumulative in the sense of “the model remembers everything forever.” As a session grows, older content either gets summarized, dropped, or pushed out to make room, depending on how the tool managing the session handles it. None of this is a flaw specific to any one model — it’s a structural property of how these systems work, and it applies whether you’re using Claude, GPT, or anything else built the same way.
Why This Shows Up as Agent Drift
The practical symptom developers notice isn’t “context window,” it’s what’s often called drift: an agent that was sharp at the start of a session starts making mistakes it wouldn’t have made earlier — misremembering a variable name, re-suggesting something already rejected, losing track of a constraint stated at the beginning. This isn’t the model getting “tired.” It’s a direct consequence of the context window filling up and older, still-relevant information getting crowded out by everything that’s happened since.
Long sessions on large, unfamiliar codebases are the most common trigger, because every file the agent reads to understand the code eats into the same limited space that’s also holding your instructions and the conversation history.
Strategies That Keep Sessions Accurate
A handful of habits meaningfully reduce how often context window pressure turns into visible mistakes:
| Strategy | What it does |
|---|---|
| Scope tasks narrowly | Smaller tasks need less context to complete accurately |
| Start a fresh session per task | Avoids carrying irrelevant history from a previous, unrelated task |
| Re-state key constraints periodically | Keeps critical instructions from aging out of the window |
| Point the agent at specific files | Avoids burning context reading files it doesn’t need |
| Summarize progress explicitly | Compresses a long history into a short, current snapshot |
Scope tasks narrowly matters most. “Fix the pagination bug in SearchResults.tsx” uses a fraction of the context that “improve the search experience” does, because the agent doesn’t need to explore the codebase nearly as much to understand what’s being asked.
Starting fresh per task is the second-highest-leverage habit, and it pairs directly with giving each task its own branch: a new session, on a new branch, isn’t carrying context from an unrelated task earlier in the day, and it isn’t competing with other agents’ context either.
How Tools Try to Manage This For You
Most agent tools don’t leave context management entirely up to you — they run their own strategies in the background to stretch the window further. Common approaches include automatically summarizing older parts of a conversation once it grows past a threshold, retrieving only the specific files relevant to a request instead of loading a whole codebase, and letting you explicitly clear or compact history between tasks.
These mitigations help, but they’re not a substitute for the habits above — a good automatic summarizer can compress history, but it can’t invent context that was never captured clearly in the first place. If your original instructions were vague, summarizing a vague conversation just produces a shorter vague conversation. Clear, narrow instructions up front reduce how much any summarization step even needs to do.
A Practical Pattern: One Task, One Session, One Branch
Rather than running one long, sprawling session across an entire day, treat each discrete task as its own unit: new session, new branch, a tightly scoped instruction. When the task is done, the session’s job is done too — you don’t keep extending the same conversation into the next unrelated task and hoping the context window has room left for it.
# Each task gets a fresh session and its own branch —
# nothing from an earlier, unrelated task is competing for context
git checkout -b agent/fix-pagination-bug
# start a new agent session scoped only to this task
This also has a git-shaped benefit: a session’s context and a branch’s diff end up scoped to the same thing, so when you’re reviewing what came out, the diff review workflow for that branch matches exactly what the agent was actually working on — no unrelated context bleeding into an unrelated diff.
Signs You’ve Hit Context Window Pressure
Watch for these signals mid-session, since catching them early is cheaper than debugging the resulting mistake later:
- The agent asks you to re-explain something you covered earlier in the same session.
- It re-reads a file it already read, as if seeing it for the first time.
- Suggestions start contradicting an earlier, explicit decision in the same conversation.
- Responses get vaguer or more generic as the session goes on, without you changing what you’re asking.
Any of these is a good moment to wrap up the current task, commit what’s working, and start a fresh session for whatever comes next rather than pushing the same conversation further.
Getting Started
- Next time you notice an agent contradicting something it said earlier in the same session, treat it as a context window signal, not a one-off mistake — wrap up and start fresh.
- Practice scoping tasks to a single file or a single behavior change rather than an open-ended request, and notice how much more consistent the results are.
- Pair one task with one session and one branch as your default working pattern, rather than extending a single long-running session across the whole day.
- If you’re running several scoped sessions like this in parallel, Agents keeps each one in its own sidebar entry with its own worktree and branch, so nothing from one task’s context bleeds into another’s diff — try it free for 7 days, then a one-time $9.99.
Context windows aren’t a limitation to work around once and forget — they’re a constraint that shapes how you should structure every session, from how narrowly you scope a task to when you decide to start over. Treat “one task, one session” as the default, and the drift that shows up in long, sprawling sessions mostly stops happening in the first place.