Over the past few weeks, GPT-5.6 High/Very High has gradually become less reliable for long-context development and debugging work. I first noticed subtle behavioral changes around August 19, including what appeared to be a new 25–26 minute cutoff on long-running tasks, but the model was still quite usable then.
Since that point, the decline has felt gradual — until the last few days, when it seems to have accelerated sharply. Yesterday and especially today, the difference was no longer subtle. What had felt like a slow degradation suddenly turned into a cliff.
The problem is not simply that it makes more mistakes. It often still looks like it is reasoning deeply: it spends time, reads a lot of material, explores many possibilities, and produces detailed explanations.
But the reasoning itself often fails to converge.
In the same project and on the same kinds of debugging tasks, it now skips things it previously did almost automatically: comparing against known-good implementations, performing version-delta analysis, carrying failed experiments forward as constraints, eliminating hypotheses, and designing high-information tests that can distinguish several possibilities at once.
I have had cases where I repeatedly told it to compare against an existing known-good implementation, yet it still did not actually do so until I personally identified the exact versions and components, summarized the differences, and explicitly structured the comparison for it.
I have also seen it completely misinterpret diagnostic images, repeat slightly modified versions of approaches that had already failed, and spend a great deal of time exploring possibilities without making the problem meaningfully narrower.
The strangest part is that when I point this out, the model can often explain very accurately what it did wrong — that it failed to preserve negative evidence, expanded the hypothesis space instead of reducing it, or substituted breadth of exploration for depth of reasoning — and then make essentially the same kind of mistake again.
It does not feel like Medium reasoning either. The behavior is stranger than that. It feels like performative reasoning: the outward signals of deep analysis remain, but the actual abilities to compress the problem, propagate constraints, challenge its own conclusions, and converge on the next useful step feel substantially weaker.
It is exhausting to watch a model spend more time looking like it is thinking deeply while requiring more and more user intervention to reach conclusions it used to reach on its own.
I now get much better results only when I explicitly define the reasoning procedure itself: review previous attempts first, identify genuinely unexplored root causes, look for tests that can eliminate several hypotheses at once, establish what evidence would make an approach impossible, and only then move to alternatives. Once I put these rules directly into the project instructions, the model became noticeably more effective again.
That is useful, but also revealing: reasoning strategy that the model previously appeared to construct for itself now has to be supplied by the user.
During roughly the same period, I have also seen several other unusual behaviors:
- long-running tasks repeatedly stopping around 25–26 minutes before work was saved, forcing me to create a checkpoint-before-25-minutes workflow;
- files attached in the immediately preceding message being reported as inaccessible, while the same underlying data could sometimes be accessed after changing only the file extension;
- archive-file availability changing inconsistently over time;
- ordinary, short development requests repeatedly triggering “The system is taking extra time to review this request before responding.”
I cannot see the backend, so I cannot say whether these issues share a cause. But from the user side, reasoning quality, long-running execution, file handling, and request review behavior all became noticeably less predictable during the same period.
The most important regression is still the reasoning itself.
Depth increasingly feels replaced by breadth, judgment by explanation, and contextual inference by explicit user instructions.
The model is still busy. It is still articulate. It still looks sophisticated.
But increasingly, it feels like a convincing performance of deep reasoning, while the user is left to do the actual thinking that High/Very High used to do on its own.
Ironically, ChatGPT helped me write this report. Its ability to articulate the failure is still remarkably intact — perhaps more intact than its ability to avoid the failure in the first place.
It can still explain the crash beautifully. It just seems less able to avoid crashing.