The context window is a core function of each frontier mannequin. Measured in tokens, it’s sometimes made up of the system immediate and a rising historical past of prompts, responses and power calls stretching again so far as the restrict permits.
For each token the mannequin generates, it first appears to be like again throughout your complete context window. That is the one mechanism by which it has reminiscence of a chat session. The mannequin holds no persistent inner state from one flip to the subsequent. And as we’ll see, the context window is just not passive storage. Every thing in it has the potential to form the mannequin’s output, for higher or worse.
This can be a frequent expertise: a session that begins sturdy and slowly loses the thread. The gradual decline in a mannequin’s output high quality pushed by the contents of the context window is often known as context rot.
We are able to separate the sources of context rot into two classes. The primary is intrinsic rot: a property of how a mannequin applies consideration throughout the context window because it generates output. We’ll go into extra element under, however for now the important thing takeaway is that this: nevertheless completely related the context is, the mannequin’s potential to recall and distinguish data is imperfect.
The second class we name content material rot. That is the buildup of stale, fallacious and contradictory data throughout a session. The failed method the mannequin retains going again to, or the dozen tangential software calls that went nowhere. All of it repeatedly reprocessed, slowly shaping the end result of the session.
Fortuitously, not like intrinsic rot, content material rot is ours to handle – the place studying to manage it transforms instruments like Claude Code from often irritating to persistently sharp.
Intrinsic rot: the mannequin flooring
Intrinsic rot refers back to the efficiency limitations inherent to the mannequin’s structure. It isn’t ours to immediate round or enhance; it’s the flooring the whole lot else rests on. However the mechanism is price understanding for 2 causes: it explains the motivation behind a few of the practices described later on this submit, and it helps dissolve the phantasm that there’s a little engineer again there quietly accumulating an understanding of your mission. (For a full walkthrough of consideration, 3Blue1Brown’s lesson is great.)
Every flip, your total session (prompts, responses, file reads, software outputs) is flattened into one lengthy sequence of tokens and handed by the mannequin. LLM structure is complicated, however consideration heads are the part that matter most for context. Every head solutions a single query: how a lot ought to every token draw on each token earlier than it? A related token contributes closely to the subsequent prediction; an irrelevant one contributes little, however by no means nothing.
That “by no means nothing” is the crux. Every head’s relevance scores go by softmax, a operate that forces scores to sum to at least one. This implies there’s a fastened finances of consideration. As a result of softmax is constructed on exponentials, no token’s share of the finances can ever attain precisely zero. Each token in your window, nevertheless irrelevant, competes for a similar fastened finances. That is no implementation accident; softmax is central to consideration exactly as a result of it turns competing scores right into a clean, learnable distribution. However, that helpful property displays a tradeoff: irrelevant context is rarely free. To be clear, dilution is just one of a number of main explanations for long-context degradation. And fashions do study partial workarounds, offloading spare consideration onto throwaway positions, however these are mitigations, not escapes.
The consequence of that is delicate. As context grows, the mannequin should still rank the fitting tokens highest; the ordering survives. What erodes is the margin: the hole between the token that issues and the diffuse mass of the whole lot else. Even when the mannequin “is aware of” the place to look, the learn arrives blurred, blended with hundreds of faint contributions from the encompassing window. Consider it as dilution: a set finances unfold ever thinner, worsening signal-to-noise.
The acknowledged context restrict is just not a efficiency cliff; the erosion is gradual, and it begins early.
Place issues too. Phrase order is key to language, so fashions encode the place tokens sit (open fashions sometimes by way of rotary positional encoding; closed techniques hardly ever disclose). The precise mechanism issues lower than the measured consequence: place a reality at various positions alongside a protracted context and retrieval accuracy traces a U, highest on the very begin and really finish, lowest within the center (Liu et al., 2024). The precise trigger continues to be debated. What issues for us is the dip: in an hours-long session, the broad center is the place most of your actual content material lives, and it isn’t protected storage.
These are often known as needle-in-a-haystack benchmarks. For the straightforward case, vendor curves are comparatively flat and basically solved. Make retrieval solely barely tougher, stripping the straightforward word-overlap between query and reply so the mannequin has to match on that means (NoLiMa, Modarressi et al., 2025), and the drop arrives far sooner than the headline restrict suggests. When holding a number of items without delay and reasoning throughout them: efficiency degrades properly contained in the acknowledged window even with excellent retrieval and each distractor stripped out (Du et al., 2025). A mannequin that may discover a reality at 100k tokens can’t essentially suppose with it there.
So, the working assumption for anybody attempting to get work performed: your helpful context finances sits properly under any acknowledged restrict.
Content material rot: how periods degrade
This part is concerning the content material loaded into context throughout a session. Earlier we described content material rot as our area of management. Whereas that is true, in apply a session has a number of actors: us, the mannequin, and any subagents spawned alongside the best way.
The extent of autonomy we permit is often ruled by a set of permitted instructions: grep a mission workspace, pull from a distant git repository, MCP entry to an organization information base. A free leash of autonomy is the purpose of those instruments; it’s the place the productiveness comes from. As we stroll by the varied failure modes that result in content material rot, the purpose is to not shorten the leash, however to recognise that we’re nonetheless one of the best error correction within the loop: to catch the overly broad file learn, the error being circled that is mostly a lacking config, and cease the cycle earlier than the injury is completed.
Your session is a suggestions loop. With every flip, the whole lot within the mannequin’s context window, each file learn, software output and failed try, is fed again by the mannequin, shaping what it produces earlier than being folded into the subsequent token. Output turns into enter. A clear step provides a clear line; a confused step provides a confused one, whereas the mannequin continues to situation by itself confusion. The error persists and feeds ahead.
The 4 failure modes that comply with are Drew Breunig’s taxonomy of context failures (confusion, conflict, distraction, and poisoning), from his submit How Lengthy Contexts Fail, right here grounded within the day-to-day of agentic coding periods:
Loading an excessive amount of into scope (confusion).
It’s turning into more and more frequent to front-load every session with an ever-growing roster of instruments, abilities, and MCP servers. This is sensible in isolation: devoted instruments with specialised instruction units could be extremely environment friendly and carry out properly. However ever discover a mannequin reaching for a software to carry out essentially the most menial duties, and even the fallacious software? Worse, a bloated equipment not solely confuses software choice (Kate et al., 2025), however provides enter on each flip, the place we already confirmed reasoning to degrade with enter size properly under the acknowledged restrict (Levy et al., 2024; Du et al., 2025).
Confronted with a activity, a mannequin with many instruments tends to achieve for them anyway, even when its personal information would do: a measured tendency to invoke instruments to paper over reasoning gaps (Zeng et al., 2026). In plainer phrases, even the idle software is just not free: its definition sits within the window on each flip, taking a slice of the eye finances whether or not you name it or not.
Letting a debugging detour set the speculation (conflict).
Ever end up working laborious to persuade a mannequin that its analysis is fallacious, whereas it bends new contradictory observations in the direction of an assumption that now not is sensible, solely to return to that very same level after the duty is already solved? The impact has been measured: fashions commit early to a studying and battle to let go of it. Duties they resolve cleanly when handed the whole lot in a single go, they fumble as soon as the identical data arrives muddled throughout turns (Laban et al., 2025). The analysis right here is that the trail itself can turn into sticky.
Looking out broad and pulling in look-alikes (distraction).
When the agent greps broad or dumps a listing to search out the factor it wants, it pulls in take a look at fixtures, lifeless implementations, mocks and equally named capabilities from unrelated modules, all of which look believable. The difficulty is that fashions weight the window closely: they don’t deal with context as optionally available reference materials, however reliably incorporate it, even when it’s irrelevant (Shi et al., 2023). A single topically associated distractor is sufficient to measurably drop efficiency (Mirzadeh et al., GSM-Symbolic, 2024), and a codebase is filled with them. The mannequin over-focuses on what the search dragged in, on the expense of the reasoning it will have performed cleanly with out it. This ties straight again to the ground: the margin between the goal and its close to neighbours collapses, and a search meant to make clear as a substitute populates the window with convincing options the mannequin can’t assist however attend to.
Letting a fallacious notice harden into fact (poisoning).
That is notably prevalent on long-running duties. Usually it follows from good intention: because the mission grows and the selections pile up, the agent data what it has present in a NOTES.md, or a collection of named recordsdata monitoring steps taken and work performed, that means to supply helpful future context. Later you see a kind of assumptions within the stay chat and it’s fallacious. You interrupt, right it, transfer on. However the notice was by no means up to date. It sits within the file, will get learn again later, and might outlive your chat correction. As soon as the correction slides out of the window, the stale file is the model that is still. A notice the mannequin wrote is just not proof; it’s a declare ready to be confirmed. The failure mode is stale state, not state itself.
To Breunig’s 4 modes I’d add the compounding. Every feeds the subsequent: a fallacious notice in a file sends the agent looking for a repair that was by no means wanted, the search drags in a pile of believable look-alikes, these mislead it in the direction of a contemporary fallacious concept, and a debugging detour spawned to kind it out lays down one other. Every flip circumstances on the amassed mess of the final, and the errors don’t simply add up; they make the subsequent extra doubtless.
This results in a extra delicate level: the mannequin hardly ever hedges because it degrades. Following a fallacious flip, it builds on the error moderately than flagging it. (Laban et al., 2025), and a session deep in rot can learn like a wholesome one proper up till the output breaks. You’ll be able to’t depend on the mannequin to name time on itself, so an out of doors observer continues to be required for one of the best outcomes.
If the true restrict is content material high quality, then managing context turns into much less about saving tokens and extra about recognising the sample and altering future behaviour.
Managing context: the on a regular basis apply
The sensible rule is straightforward: context is just not storage. It’s energetic enter. Every thing under is framed round Claude Code, the software I do know finest, however every apply is a precept first: the steerage carries over to any agentic software, even the place the command names differ.
Earlier than the primary immediate: curate
If it isn’t already clear, a contemporary begin is price greater than any restoration path later. That is what makes the upfront work worthwhile: a well-curated mission (a decent CLAUDE.md, the fitting abilities and hooks) makes a contemporary session low-cost to spin up. The associated fee is paid as soon as, intentionally, so that each reset after is near free.
Most individuals will probably be conversant in the CLAUDE.md file. Each session begins by studying this file, and it’s carried by every flip. This is the reason it pays to be ruthless when modifying: each line earns its place, and bloat is reduce. A helpful framing is to deal with it because the minimal required studying for a brand new engineer on day one. Particularly, what may they not work out by studying the code alone: the construct and take a look at instructions, the form of the mission, the conventions you truly maintain to, the gotchas. Omit something the mannequin can infer, something that adjustments typically, and something solely typically related. /init provides you a helpful place to begin to prune, aggressively.
Hold the context that’s at all times loaded minimal and excessive sign. Normal information is instantly recalled by the mannequin and is wasted as context, the place it solely provides to the dilution we met earlier. Hold the window for what is restricted, novel, or modified since coaching, and lean on the mannequin’s personal information for the remaining.
What you chop doesn’t must be wasted; transfer it someplace that hundreds solely when required. Procedures and area information turn into abilities, whose content material sits dormant till invoked. Guidelines that should maintain each time (formatting, a blocked command) turn into hooks, which run outdoors of your major session context. Make capturing these a behavior: noting helpful data prices far much less within the second than reconstructing it after the actual fact.
Audit what you place in scope. We’ve got seen how a crowded software house drops efficiency. Run /mcp or /abilities and disable the servers or abilities a brand new activity doesn’t want.
Seed with what narrows, not what is expounded. If you understand the related recordsdata, title them with @path/to/file.
Let it plan earlier than it writes. A fallacious plan prices a paragraph and is an inexpensive repair. Shift+Tab into plan mode, or /plan, for something touching greater than a few recordsdata.
Whilst you work: hold it clear
Hold the aim latest. We all know the center of a protracted context window is the place mannequin recall is least dependable. On longer duties, refresh the session targets at every milestone: restate the present goal, stay constraints, and a brief operating activity listing for the agent to rewrite.
Push verbose work out to subagents. A take a look at run, a log trawl, a dependency audit: something that generates a wall of output you don’t want to maintain. We solely want the conclusion.
Externalise sturdy state, and hold it true. A notes file the agent maintains lives outdoors the window and survives a reset; something that should persist throughout periods can stay right here. However be intentional: a stale reminiscence is worse than none. It might outlive the correction you made in chat and re-enter later as obvious floor fact.
Return to floor fact, and make it a behavior. Test in opposition to the file, the take a look at, the precise error, not the mannequin’s reminiscence of them. The ! prefix runs a shell command and drops its actual output straight into context, so !git standing or !npm take a look at grounds the session once more in what is definitely true moderately than what the mannequin remembers. If you end up doing this typically, make it your individual: a small ability that injects your mission’s actual state (the git standing, the take a look at end result, the sort examine) in a single go.
When it turns: reset, don’t push
That is the toughest steerage to comply with; at this level your historical past of turns appears like progress you’d be throwing away. That’s the sunk price fallacy: these tokens are spent whether or not you retain the window or clear it, and the one query is whether or not the subsequent flip begins from a rotten context or a wholesome one.
Two corrections on the identical level is the sign. When you will have instructed it twice that the bug is just not within the auth layer and it retains circling again, cease. Reset.
Catch it mid-step if you happen to can. For those who see it heading the fallacious means, Ctrl+C and redirect moderately than letting a foul change land and pile up. If it already has, Esc+Esc opens rewind: roll again the dialog, the code, or each to a previous checkpoint.
Regenerate, don’t carry ahead. For self-contained, re-derivable work, regenerating the lead to a clear session typically beats a distilled historical past. The impact is sharpest as soon as an try has already gone fallacious. In Letta’s Restoration-Bench, brokers handed the complete historical past of their failed makes an attempt did worse than these beginning clear, the rotten context actively dragging down restoration moderately than informing it.
When to behave, and what to hold ahead, is dependent upon the present state of the session:
- New, unrelated activity →
/clear. You need not one of the previous context. - Subsequent section of associated work, session wholesome → hand off the state (see under).
- Context restrict reached mid-task, session wholesome →
/compact. You need the distilled historical past of what has occurred. - Session has turned → snapshot the state by hand and clear. You can’t belief the mannequin to summarise a context it may now not learn properly, so that you extract what issues your self, from recordsdata, diffs, assessments, and identified selections, earlier than resetting.
Handoff state, not the transcript. At a wholesome boundary, have the agent write a handoff transient.
Instructive failures are helpful right here, and the best way you retain them issues: distil every to a one-line lesson (“tried X, it failed as a result of Y”).
Open the subsequent session on the transient and on floor fact. A contemporary window is quickest when its first act is to orient, to not guess. Level it on the handoff transient, then set up actuality straight: learn the related recordsdata, run the assessments, examine git standing. The transient tells it the place issues stood; the stay checks inform it the place issues truly are.
For lengthy or parallel jobs
Decompose at verifiable seams. Cut up a activity the place the result’s low-cost to examine (a take a look at that passes, a construct that compiles, a quantity that reconciles), not all the way down to the smallest potential unit.
Fan out subagents solely when the elements are unbiased. A clear context per subtask, every returning a distilled abstract, works properly for breadth: parallel analysis, unbiased lookups. For coding, the place subtasks are often coupled, remoted brokers make conflicting assumptions and also you inherit the job of reconciling them. Hold tightly coupled work in a single thread, and the place you do need isolation with out the coordination threat, a git worktree (claude -w) provides a parallel activity its personal department to work on.
Isolate the debugging. A bug is the case the place forking pays for itself. Ship the investigation to a fork or begin a session from scratch, let it type and discard fallacious theories in a context you’ll throw away, and produce again solely the trigger and the repair.
Usher in contemporary eyes. A /code-review, or a devoted reviewer subagent studying from a clear context, could catch what a rotten session can’t see in itself.
Tying it collectively: a session as a git tree
This part describes my very own workflow, formed by the findings above. It’s meant to make these rules computerized, and to take the choice fatigue out of operating many periods without delay. It isn’t benchmarked, so deal with it as one practitioner’s synthesis.
Body a session like a git department. Your major dialog thread is the orchestrator of the duty, and the purpose is for its context to remain clear and centered on the duty. When a detour comes up (the sort that can burn cycles on analysis, lifeless ends or knowledge digging), you fork it off into its personal session with the historical past up to now (claude --continue --fork-session) and do the messy work there. That is the place the fork differs from a subagent. Subagents already deal with parallel, unbiased work: spawn, discover, return a abstract. The fork is for the sequential detour off your major thread: the messy investigation that wants your full session historical past to make sense, the place there isn’t a computerized path again and also you need to select what returns.
This provides context administration a easy and acquainted form: department, discover, distil, merge. The fork is disposable context by design. It might accumulate as a lot rot because it wants, as a result of you will throw the context window away and hold solely the end result. Nothing that occurs within the department ought to pollute major.
When the department has a solution, you distil it and merge it again. The 2 halves of this course of are abilities I’ve constructed on high of the native fork. A /conclude ability writes the department all the way down to a single file in a devoted folder (I exploit ./cc-branches); a sort argument selects from a variety of templates describing totally different strategies for concluding a department, matching the sort of work carried out. Again in the principle session, a /merge ability hundreds that file, appending to context the conclusion and not one of the noise that produced it.
Past context hygiene, the git framing has introduced readability to my workflow and reduce the fatigue of switching between many duties without delay. It provides a clear psychological mannequin: every named department turns into a discrete query with a clear reply, saved for future reference.
Every thing up to now assumes a corrector within the loop, and more often than not that could be a individual. Not as a result of persons are higher than the mannequin on the work, however as a result of the mannequin has no inner brake. It can’t see its personal rot, so correction has to reach from outdoors it. That’s what governing context comes all the way down to: somebody outdoors the window deciding what enters it, what stays out, and what survives.
Ruled context
Spend any time with Claude Code, watching it learn recordsdata, run instructions, write patches, spawn subagents, and keep notes, and it rapidly begins to really feel like somewhat engineer again there: internalising your codebase, understanding the boundary between duties and errors, and getting on with fixing the issues.
Not fairly, and never in the best way that issues right here.
The mannequin doesn’t expertise your mission as a mission. It experiences the present context: the directions, the seen recordsdata, the software outputs, the latest dialog. All of it, collectively, as working enter. A few of it’s sign. A few of it’s noise. A few of it was once true. A few of it was by no means true. The mannequin has to behave anyway. After we deal with the session as amassed understanding, our behaviours change, our output will get worse, and typically we find yourself blaming the mannequin.
That’s the reason context administration is just not a facet concern. Claude Code is a management floor for the context reaching the mannequin, and its core instructions (clear, compact, rewind, department, subagents, abilities and hooks) usually are not simply comfort options. They’re controls over what enters context, what stays outdoors it, and what survives between periods.
Governing context is just not commanding the mannequin. It’s tending the half of the issue that’s yours, the content material, above a flooring the structure units and you can’t transfer. The ground improves on the labs’ schedule. The content material layer improves with you.
That is the form of profitable work with these instruments: not most context, however ruled context.
