Why Your AI Agent Gets Dumber After 30 Minutes

You start a session at 9am. The agent is sharp. You ask for a small function, it nails it. You ask for a refactor, it understands the file layout. You ask for a bug fix, it finds the right line.

By 11am the same session feels different. You ask for a similar small function and the agent forgets a parameter you defined an hour ago. You ask for a tweak to existing code and it rewrites the whole file. You point at a bug and it suggests fixes for code that is not even in the project.

The model did not change. The context window filled up.

Why longer conversations produce worse output

Most people assume more context means better answers. The agent sees more of the codebase, more of the conversation, more of the corrections. It should be smarter, not dumber.

The opposite happens. Every token in the context window influences every output. Old mistakes, abandoned approaches, outdated assumptions, and resolved tangents all sit there pulling the model in directions you did not intend. As the window fills, the signal-to-noise ratio drops.

The result looks like memory loss. The agent "forgets" things it knew an hour ago because those things are now competing with a wall of accumulated noise. You did not lose the model. You lost the signal.

The three rules that govern this

One: every model has a context size cap. Past that cap, the conversation simply cannot continue. You hit the wall and have to start over.

Two: every token influences every other token. There is no junk you can leave in the window for free. Old code, dead experiments, and resolved conflicts all tax the output.

Three: smaller windows usually produce better output than larger ones, even when both fit. The model performs best when it sees exactly what it needs and nothing else.

What this changes about how you work

If your workflow is one long chat thread for the whole project, you are paying for it in quality. The fixes are simple but require breaking habits.

Start a fresh thread for each distinct task. The agent loses nothing important if the task is self-contained. It does not need to remember yesterday's refactor to write today's bug fix.

Cut dead branches early. The moment you abandon an approach, restore the conversation to before that branch. Do not let the failed attempt sit in the window. It will leak into the next output.

Move background context into files. Instead of pasting ten pages of documentation into the chat, put it in AGENTS.md or a project note and reference it. The agent reads what it needs when it needs it.

When long sessions still make sense

Long threads are not always wrong. Debugging sessions where each step depends on the previous one benefit from continuity. So do exploratory conversations where the goal is to map a problem space together.

The judgment is whether the accumulation is signal or noise. A debugging thread where every message is a new clue is signal. A working thread where the agent has tried three abandoned approaches is noise.

Reset when the noise wins. The agent will not tell you it is confused. It will produce plausible-sounding output that is subtly wrong. The only signal is the quality drop, and by the time you notice, you have already lost an hour.

The practical test

If you cannot remember everything in the current thread, the agent cannot either. Start a new one.