Anyone who uses autonomous AI agents in development projects knows the pattern: at first the agent works briskly, finds files, proposes changes, corrects errors. After a while it goes round in circles. It tries variations of the same idea, reaches the same conclusions and seems to have a blind spot. Researchers from Microsoft have presented an explanation for this behaviour and a surprisingly simple counter-proposal.
Context becomes a shackle
Autonomous agents accumulate an ever-longer conversation history during their work: every instruction, every intermediate result, every error message, every discarded hypothesis. This history is the so-called context, i.e. everything the language model reads along with every new step. Intuitively this sounds like an advantage, since more information should lead to better decisions.
The Microsoft researchers observe the opposite. The growing context draws the agent into what they call idea sinks: local solution regions from which the agent can no longer find its way out. Once a line of thinking has been taken, it reproduces itself because it is in the history and thus acts as a frame again at every further step. The agent remains trapped in the neighbourhood of its own earlier attempts.
This is less a fault of the model than a property of the way it works. An agent that carries its complete history with it behaves like a person who rereads all failed approaches before every decision. The probability that a genuinely different approach emerges falls with every line.
What Fork-and-Flush does
The proposed method is called Fork-and-Flush. Its principle can be summed up in one sentence: the conversation history is deleted, the workspace is retained.
This separation is the decisive point. Only the record of the conversation is deleted, i.e. the chain of reasoning, intermediate steps and justifications. What is retained is the state of the work itself: the files, the changes already made, the result the agent is working on. So the agent does not start from scratch but looks at the current state with fresh eyes — without the burden of its own prior history.
According to the study, this approach achieves significantly better results with the same compute budget. That is the remarkable part: it is not about more compute time, not about a larger model and not about longer context windows. It is about distributing existing resources differently — away from dragging the history along, towards a genuinely new attempt.
Why this runs counter to common intuition
In practice, the opposite assumption has dominated so far. Larger context windows are regarded as progress, and many teams try to make as much project knowledge as possible available to an agent at the same time. The observation of idea sinks does not fundamentally relativise this logic, but it does reveal a limit: context is not automatically information, it can also be inertia.
For day-to-day work with coding agents, this yields a concrete signal. If an agent repeatedly proposes the same kind of solution, only with small variations, that is an indication of an idea sink. Instead of continuing to press for more, resetting the history can be the more productive step.
Transferring this to project practice
Working habits can be derived from the finding that can be implemented without additional tools:
- Recognise stuck sessions. Repeated solution patterns, circular justifications and ever-smaller variations are warning signs.
- Restart deliberately. A fresh session with the current file state is often more effective than the tenth follow-up question in the same history.
- Secure the working state. For a reset to be possible without loss, the state must lie outside the chat — in version control, in files, in documented intermediate results.
- Cut tasks down. Smaller, clearly delimited sub-tasks produce shorter histories and thus less opportunity to get stuck.
- Keep requirements outside the history. What is to apply permanently belongs in stable project documentation, not in a fleeting conversation thread.
Limits of the method
A history reset is not a panacea. It helps against getting stuck in local solution regions, not against badly posed tasks, missing test coverage or unclear requirements. If an agent fails because it lacks contextual knowledge about the system, deleting is more likely to make the situation worse.
The distinction is therefore important: if the agent lacks information, it needs better specifications. If it is going round in circles, it needs a restart. This diagnosis can hardly be automated at present — it remains the task of the person leading the agent.
Assessment
For web and software projects, part of the responsibility thus shifts from model selection to work organisation: how tasks are cut, how intermediate states are secured and when sessions are deliberately ended measurably influences the result. Teams that map their project state cleanly in version control and documentation can use such resets without risk — those who leave all knowledge in the chat cannot.The finding is therefore above all a reminder that the usefulness of AI agents depends less on model size than on the processes in which they are embedded.