The context window is a core characteristic 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 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. All the pieces 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 robust and slowly loses the thread. The gradual decline in a mannequin’s output high quality pushed by the contents of the context window is usually 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: nonetheless completely related the context is, the mannequin’s potential to recall and distinguish info is imperfect.
The second class we name content material rot. That is the buildup of stale, improper and contradictory info 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 result of the session.
Fortuitously, not like intrinsic rot, content material rot is ours to handle – the place studying to regulate 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 every part else rests on. However the mechanism is price understanding for 2 causes: it explains the motivation behind a number 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 venture. (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 way of the mannequin. LLM structure is complicated, however consideration heads are the element 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 move by way of 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, nonetheless 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 rank the best tokens highest; the ordering survives. What erodes is the margin: the hole between the token that issues and the diffuse mass of every part else. Even when the mannequin “is aware of” the place to look, the learn arrives blurred, combined with hundreds of faint contributions from the encompassing window. Consider it as dilution: a set finances unfold ever thinner, worsening signal-to-noise.
The said context restrict is just not a efficiency cliff; the erosion is gradual, and it begins early.
Place issues too. Phrase order is prime to language, so fashions encode the place tokens sit (open fashions sometimes by way of rotary positional encoding; closed programs hardly ever disclose). The precise mechanism issues lower than the measured consequence: place a reality at various positions alongside an extended 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 remains 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’s not secure storage.
These are often known as needle-in-a-haystack benchmarks. For the straightforward case, vendor curves are comparatively flat and primarily solved. Make retrieval solely barely tougher, stripping the simple 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 directly and reasoning throughout them: efficiency degrades effectively contained in the said 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 carried out: your helpful context finances sits effectively under any said 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 follow 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 usually ruled by a set of permitted instructions: grep a venture workspace, pull from a distant git repository, MCP entry to an organization information base. A unfastened leash of autonomy is the purpose of those instruments; it’s the place the productiveness comes from. As we stroll by way of the assorted failure modes that result in content material rot, the goal is to not shorten the leash, however to recognise that we’re nonetheless the very best error correction within the loop: to catch the overly broad file learn, the error being circled that can be a lacking config, and cease the cycle earlier than the harm is completed.
Your session is a suggestions loop. With every flip, every part within the mannequin’s context window, each file learn, software output and failed try, is fed again by way of 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 observe 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 smart in isolation: devoted instruments with specialised instruction units will be extremely environment friendly and carry out effectively. However ever discover a mannequin reaching for a software to carry out essentially the most menial duties, and even the improper 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 effectively under the said restrict (Levy et al., 2024; Du et al., 2025).
Confronted with a activity, a mannequin with many instruments tends to succeed in 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 improper, whereas it bends new contradictory observations in the direction of an assumption that not is smart, 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 every part in a single move, they fumble as soon as the identical info arrives muddled throughout turns (Laban et al., 2025). The analysis right here is that the trail itself can grow to be 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 check fixtures, useless 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 stuffed with them. The mannequin over-focuses on what the search dragged in, on the expense of the reasoning it might have carried out 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 an alternative populates the window with convincing alternate options the mannequin can’t assist however attend to.
Letting a improper word harden into reality (poisoning).
That is significantly prevalent on long-running duties. Usually it follows from good intention: because the venture grows and the selections pile up, the agent data what it has present in a NOTES.md, or a sequence of named recordsdata monitoring steps taken and work carried out, that means to offer helpful future context. Later you notice a type of assumptions within the reside chat and it’s improper. You interrupt, appropriate it, transfer on. However the word was by no means up to date. It sits within the file, will get learn again later, and may outlive your chat correction. As soon as the correction slides out of the window, the stale file is the model that continues to be. A word 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 improper word 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 recent improper idea, and a debugging detour spawned to kind it out lays down one other. Every flip situations on the gathered mess of the final, and the errors don’t simply add up; they make the subsequent extra probably.
This results in a extra delicate level: the mannequin hardly ever hedges because it degrades. Following a improper flip, it builds on the error relatively 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 possibly can’t depend on the mannequin to name time on itself, so an out of doors observer remains to be required for the very best outcomes.
If the actual 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 follow
The sensible rule is straightforward: context is just not storage. It’s energetic enter. All the pieces under is framed round Claude Code, the software I do know greatest, however every follow 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’s not already clear, a recent begin is price greater than any restoration path later. That is what makes the upfront work worthwhile: a well-curated venture (a good CLAUDE.md, the best abilities and hooks) makes a recent 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 likely be conversant in the CLAUDE.md file. Each session begins by studying this file, and it’s carried by way of every flip. This is the reason it pays to be ruthless when enhancing: 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 might they not work out by studying the code alone: the construct and check instructions, the form of the venture, the conventions you truly maintain to, the gotchas. Omit something the mannequin can infer, something that modifications usually, and something solely typically related. /init provides you a helpful place to begin to prune, aggressively.
Hold the context that’s all the time loaded minimal and excessive sign. Normal information is quickly 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 remainder.
What you chop doesn’t should be wasted; transfer it someplace that masses solely when required. Procedures and area information grow to be abilities, whose content material sits dormant till invoked. Guidelines that should maintain each time (formatting, a blocked command) grow to be hooks, which run outdoors of your foremost session context. Make capturing these a behavior: noting helpful info prices far much less within the second than reconstructing it after the actual fact.
Audit what you place in scope. Now we have seen how a crowded software area 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 said. If you understand the related recordsdata, title them with @path/to/file.
Let it plan earlier than it writes. A improper plan prices a paragraph and is an inexpensive repair. Shift+Tab into plan mode, or /plan, for something touching greater than a few recordsdata.
When you work: preserve it clear
Hold the aim latest. We all know the center of an extended context window is the place mannequin recall is least dependable. On longer duties, refresh the session objectives at every milestone: restate the present goal, reside constraints, and a brief working activity listing for the agent to rewrite.
Push verbose work out to subagents. A check 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 preserve it true. A notes file the agent maintains lives outdoors the window and survives a reset; something that should persist throughout periods can reside right here. However be intentional: a stale reminiscence is worse than none. It may outlive the correction you made in chat and re-enter later as obvious floor reality.
Return to floor reality, and make it a behavior. Verify towards the file, the check, 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 check grounds the session once more in what is definitely true relatively than what the mannequin remembers. If you end up doing this usually, make it your individual: a small ability that injects your venture’s actual state (the git standing, the check consequence, the sort verify) in a single go.
When it turns: reset, don’t push
That is the toughest steerage to observe; at this level your historical past of turns looks like progress you’d be throwing away. That’s the sunk value 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 might have informed it twice that the bug is just not within the auth layer and it retains circling again, cease. Reset.
Catch it mid-step should you can. In the event you see it heading the improper means, Ctrl+C and redirect relatively than letting a nasty 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 end in a clear session usually beats a distilled historical past. The impact is sharpest as soon as an try has already gone improper. 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 relatively than informing it.
When to behave, and what to hold ahead, relies on the present state of the session:
- New, unrelated activity →
/clear. You need not one of the outdated context. - Subsequent part 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 well not learn effectively, 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 temporary.
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 temporary and on floor reality. A recent window is quickest when its first act is to orient, to not guess. Level it on the handoff temporary, then set up actuality straight: learn the related recordsdata, run the assessments, verify git standing. The temporary tells it the place issues stood; the reside checks inform it the place issues truly are.
For lengthy or parallel jobs
Decompose at verifiable seams. Break up a activity the place the result’s low cost to verify (a check that passes, a construct that compiles, a quantity that reconciles), not all the way down to the smallest attainable unit.
Fan out subagents solely when the components are impartial. A clear context per subtask, every returning a distilled abstract, works effectively for breadth: parallel analysis, impartial lookups. For coding, the place subtasks are normally 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 danger, 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 improper theories in a context you’ll throw away, and produce again solely the trigger and the repair.
Usher in recent eyes. A /code-review, or a devoted reviewer subagent studying from a clear context, might 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 working many periods directly. It isn’t benchmarked, so deal with it as one practitioner’s synthesis.
Body a session like a git department. Your foremost dialog thread is the orchestrator of the duty, and the goal is for its context to remain clear and targeted on the duty. When a detour comes up (the sort that may burn cycles on analysis, useless ends or knowledge digging), you fork it off into its personal session with the historical past thus far (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, impartial work: spawn, discover, return a abstract. The fork is for the sequential detour off your foremost thread: the messy investigation that wants your full session historical past to make sense, the place there isn’t any computerized path again and also you need to select what returns.
This offers context administration a easy and acquainted form: department, discover, distil, merge. The fork is disposable context by design. It may accumulate as a lot rot because it wants, as a result of you’re going to throw the context window away and preserve solely the consequence. Nothing that occurs within the department ought to pollute foremost.
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 take advantage of ./cc-branches); a kind argument selects from quite a few templates describing totally different strategies for concluding a department, matching the type of work carried out. Again in the principle session, a /merge ability masses 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 directly. It provides a clear psychological mannequin: every named department turns into a discrete query with a clear reply, saved for future reference.
All the pieces thus far assumes a corrector within the loop, and more often than not that may 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 a bit of 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 venture as a venture. 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 true. A few of it was by no means true. The mannequin has to behave anyway. After we deal with the session as gathered 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 aspect 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) will not be 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.
