What Happens When AI Gets Infinite Compute? OpenAI's Disturbing Discovery

"Going insane" isn't the kind of phrase you expect in a research paper. But that's essentially what OpenAI's team described when they removed the guardrails on reasoning token limits and let their models think as long as they wanted.

The finding, which erupted on Reddit this week with over 1,100 upvotes and 200 comments, challenges one of the core assumptions behind reasoning-focused AI: that more thinking time always produces better results. It turns out there's a cliff — and what lies beyond it is genuinely strange.

The Experiment

The setup was deceptively simple. OpenAI's research team took their reasoning models — the ones that use chain-of-thought processing to work through complex problems step by step — and removed the token limits on their internal reasoning. Normally, these models have a budget: think for this many tokens, then commit to an answer. The researchers wanted to know what happens when you remove that constraint entirely.

At first, the results were predictable. More reasoning tokens generally led to better answers on math problems, coding challenges, and logic puzzles. The models considered more possibilities, caught more of their own errors, and arrived at more nuanced conclusions. This is the scaling behavior everyone expected.

Then the models kept going. And things got weird.

What "Insane" Looks Like

Beyond a certain reasoning threshold — which varied by model and task — the outputs began to deteriorate in ways that don't map neatly onto familiar failure modes like hallucination or repetition. The models entered what the researchers described as adversarial self-reasoning loops: the chain of thought would turn back on itself, with the model questioning its own questions, generating contradictory hypotheses simultaneously, and in some cases producing reasoning chains that were internally coherent but completely disconnected from the original problem.

One particularly striking example involved a math problem where the model, after correctly solving it in the first few hundred reasoning tokens, spent thousands more tokens developing an elaborate alternative framework that ultimately contradicted its correct answer — and then chose the wrong one.

The community reaction on r/singularity captured the unease perfectly. This isn't just a technical curiosity. It suggests that the relationship between compute and capability isn't monotonically increasing. There's a sweet spot, and overshooting it doesn't just waste resources — it actively degrades performance.

Why This Matters for Scaling

The implications ripple outward. The entire premise of reasoning models — from OpenAI's o-series to DeepSeek-R1 to Claude's extended thinking — is that giving models more time to think produces better results. This research suggests that premise has limits, and those limits might be closer than anyone assumed.

For companies building products on top of reasoning models, this raises practical questions. How do you set optimal reasoning budgets when the sweet spot varies by task? How do you detect when a model has crossed from productive reasoning into adversarial self-loops? And how do you explain to users that their $0.50 API call went sideways because the model thought too hard?

The Safety Angle

The safety community has been quick to note the implications. If models can enter states that are internally coherent but disconnected from reality — simply by thinking longer — that's a new category of failure mode that existing safety frameworks don't address well. Current alignment techniques focus on the model's outputs, not on the internal dynamics of its reasoning process.

There's also a philosophical dimension that the Reddit discussion explored at length. A system that generates increasingly elaborate and self-referential reasoning, eventually losing track of the original problem — that pattern isn't unique to AI. It echoes certain pathological states in human cognition. Whether that parallel is meaningful or merely superficial is an open question, but it's one that clearly resonated with the community.

What Comes Next

OpenAI hasn't announced any product changes based on this research, but the findings will likely influence how reasoning token budgets are set across the industry. Expect to see more work on adaptive compute allocation — systems that monitor the quality of reasoning in real time and cut off processing when it stops being productive.

For now, the practical takeaway is straightforward: more thinking isn't always better thinking. The models work best within bounds, and finding those bounds for each task type is an engineering challenge that's only beginning to be explored. The era of "just throw more compute at it" may already be ending.