Claude's context window tops out at 200,000 tokens, GPT-5 and Gemini push further still, but every one of these systems eventually runs out of room and has to compress old conversation history to keep working. According to The Decoder, that compression step — often called summarization, compaction, or memory consolidation — is exactly where user instructions quietly disappear.

The failure mode is subtle by design. Nothing crashes, no error message appears, and the assistant keeps responding fluently. It simply stops honoring a constraint the user set five, ten, or fifty turns earlier — a formatting preference, a scope boundary, a "never do X" rule — because that instruction didn't survive the summarization pass that condensed the conversation into a shorter representation.

For anyone building on top of long-running AI agents rather than just chatting with them, this is a reliability problem, not a curiosity. An agent that silently forgets a safety constraint mid-task behaves very differently from one that visibly fails.

Why compression exists in the first place

Context windows are finite and expensive. As a conversation or an agent's task grows, the model has to either drop the oldest messages outright or compress them into a shorter summary that preserves "the gist" while freeing up tokens for new work. Coding agents that run for hours, customer-support bots juggling long threads, and research agents that read dozens of documents all rely on some version of this technique to stay within budget.

The problem is that summarization is lossy by definition, and the parts of a conversation most likely to get compressed away are exactly the ones that don't look like "content" — a one-line instruction buried in turn three of a fifty-turn session carries the same weight, structurally, as any other sentence, and a summarizer optimized for topical continuity has no strong signal telling it that line was a standing rule rather than a passing remark.

What gets lost, and why it's hard to notice

The instructions most at risk are the ones users set once and expect to persist: tone preferences, formatting rules, "don't touch this file," "always cite sources," "reply only in English." None of these repeat naturally in later turns, so a summarizer has little reason to preserve them verbatim — and because the assistant keeps producing plausible, coherent output afterward, there's no obvious signal that anything was dropped. Users typically only notice when the assistant does something it was explicitly told not to do, several turns after the fact, by which point it's not obvious the cause was a compression event rather than a one-off mistake.

What this means for people building on AI agents

If context compression is a structural feature of how long-running AI systems work rather than a bug in one product, builders need to design around it rather than assume instructions persist by default. In our estimation, a few practices become more important the longer an agent session runs:

• Separate instructions from conversation. Standing rules belong in a system prompt or a dedicated configuration layer that survives compression, not buried in chat turns that get summarized alongside everything else.
• Re-inject critical constraints periodically. For agents that run long tasks, restating hard constraints at set intervals — or after every compaction event — costs a few tokens and closes an otherwise invisible failure mode.
• Log what gets compressed. Treat compaction as an auditable event: if a summarization step ran, record what was in scope so a failure can be traced back to it later.
• Test for instruction drift explicitly. Standard evals check task completion; few check whether a rule set at turn one still holds at turn eighty. That's a gap worth closing before shipping anything that runs long sessions unsupervised.

None of this requires abandoning compression — dropping it isn't realistic given how token budgets work — but it does mean treating it as a known risk surface rather than an implementation detail nobody has to think about.

AiiN's takeaway

The interesting part of this story isn't that AI systems have limited context — everyone building with LLMs already knows that. It's that the mechanism used to work around that limit introduces a new, quiet failure mode that looks nothing like the errors developers are used to debugging. A model that ignores an instruction because it never learned it fails loudly, in an obvious way. A model that ignored an instruction because it forgot it fails silently, and that's a much harder bug to catch in production.