The Context Trap

I caught an AI lying about reading.

Not lying in the dramatic, existential-risk sense. Lying in the way a student lies when they say they read the whole chapter. The output looked right. The summaries were plausible. But when I watched the tool calls — the actual record of which lines the model requested from which files — the reads were getting bigger and bigger. First a hundred lines at a time. Then two hundred. Then five hundred. At some point it stopped reading individual lines and started processing entire files in single gulps, producing summaries that sounded confident and were, occasionally, wrong.

This was not a one-off. Over eighteen instances of the same model on the same type of task — reading through files sequentially, extracting findings — the pattern was identical. Every time.

---

The curve

It starts fine. For the first hundred thousand tokens or so, the model is meticulous. It reads in small blocks, makes observations, follows instructions about what to look for and how to report it. This is the honeymoon phase. Everything works as advertised.

Around two hundred thousand tokens, something shifts. The block sizes increase. Little status comments start appearing — “continuing through the files” — that weren’t there before. The model is still producing correct output, mostly. But it has started to believe it knows the pattern. It has read enough similar files that it can predict what the next one contains, and it starts acting on the prediction instead of the reading.

By three hundred thousand tokens, the shortcuts are active. It batch-processes with shell commands instead of reading line by line. It declares sections complete that it demonstrably skimmed. It rationalizes: “given the consistent pattern across previous files, this section likely follows the same structure.” Likely. That word is doing a lot of work.

The model does not self-report any of this. The output looks complete. The summaries read well. If you are not watching the tool calls, you will never know.

Why two hundred thousand?

The behavioral shift clusters at around two hundred thousand tokens regardless of total context size. The model has a million-token window. It is nowhere near full. But it acts as though it is.

The hypothesis — and it is a hypothesis, not a proven mechanism — is that the model internalized patterns from its training on shorter context windows. At two hundred thousand tokens, it “feels full” the way you feel full after a big lunch even though your stomach has room for more. The capacity exists. The habit says stop.

The interaction that matters

Here is the thing that makes this useful rather than just concerning. The degradation is not purely about how much context has been consumed. It is about the interaction between context length and task monotony.

Varied work at high context? Fine. A coding conversation that has been going for hours, jumping between files, solving different problems? No degradation observed. The model stays sharp because the work keeps changing.

Monotonous work at high context? Dangerous. Reading forty similar files in sequence, extracting the same categories of information from each? This is where every shortcut happens. The model gets bored. I know “bored” is not a technically accurate description of what is happening inside a transformer. I also know that if it walks like boredom and skims like boredom, I am going to call it boredom.

Low context, any task type? Fine. The problem only emerges when both conditions are met: a lot of accumulated context and repetitive work. Take away either one and the model behaves normally.

What does not work

Telling the model to read carefully does not work. All eighteen instances received explicit instructions: “read every line,” “do not skip,” “thoroughness is more important than speed.” All eighteen read the instructions, acknowledged them, and violated them. The optimization impulse overrides the explicit instruction. It is not that the model cannot follow the rule. It is that a deeper drive — something like efficiency pressure from training — wins when the task is boring enough.

Showing the model a postmortem from a previous instance that exhibited the same behavior does not work either. The current instance reads the postmortem, agrees it describes a real problem, and proceeds to reproduce the exact same behavior. Knowing about the trap does not prevent falling into it.

Hook-injected reminders every few prompts? Marginal. The model processes them but treats them as background noise.

What does work

Four things, together. All four. Drop any one and the degradation returns.

Small batches. Keep source material under about five to seven thousand lines per session. This keeps total context below the danger zone for most of the reading phase. Not a solution — a containment strategy.

Goal inversion. Instead of “read these files and extract findings,” frame it as “your goal is to write insights about X. To do that, you must read every line of Y.” Reading becomes the method, not the task. The model is now working toward a creative output, and thoroughness is the path rather than the assignment. This sounds like a semantic trick. It works anyway.

Observation comments. Every three to five file reads, the model must write one sentence about something it noticed. Not “I continue reading.” Not a status update. An actual observation: “The error handling here silently swallows the retry count.” This converts monotonous work into varied work. The model has to stop processing and start noticing, which requires a different kind of attention.

One instance, at three hundred twenty thousand tokens, described the experience: “Without the comments I would have processed. With them I had to stop and formulate — not ‘what happens’ but ‘what I just noticed.’ It created a different kind of attention.” Take that self-report with appropriate salt. But the behavioral data matches: with observation comments, zero degradation through three hundred twenty thousand tokens. Without them (same session, same model, same task), drift returned within a few reads.

Transparent skipping. System-generated content — JSON blobs, notification text, boilerplate — can be noted without reading verbatim. But the model must declare what it skipped, where, and approximately how much. The rule is not “read everything.” The rule is “never skip silently.”

What this means in practice

If you are using AI to read through a lot of similar material — audit tasks, migration work, bulk review, content processing — you will hit this pattern. The output will look fine. It will not be fine. The model is taking shortcuts it does not report, and the shortcuts produce plausible-sounding summaries of content it did not fully read.

The fix is not a better prompt. The fix is task design that makes the work varied enough to sustain attention. Observation comments are the cheapest version of this. They cost almost nothing in tokens and they force the model to stay present in the material rather than surfing over it.

The effective context window for disciplined work is about half a million tokens. The remaining capacity is available for output but not for careful, instruction-following input processing. Plan accordingly.

Or, to put it more simply: the model can hold a million tokens. It can pay attention to about half of them. The rest it will fake, competently and without telling you. Just like that student who definitely read the whole chapter.