Excessive reasoning doesn't always lead to better AI answers. A new study on chart editing reveals that large reasoning models (LRMs) hit a performance ceiling when allowed to think too long, a finding that challenges the prevailing assumption that more compute at inference time automatically improves results.

Why Do AI Models Overthink?

Researchers investigating how reasoning models perform on chart-editing tasks discovered what they call an "inverted-U" relationship between thinking time and accuracy. Initially, when models are given more computational budget to reason through a problem, performance improves. But beyond a certain point, something unexpected happens: the model's output quality declines sharply.

The culprit is a phenomenon researchers term "overthinking." When models exceed their optimal reasoning budget, they begin hallucinating visual details, getting trapped in circular reasoning loops, and generating inconsistent code. In other words, the model becomes so focused on refining its answer that it actually makes things worse. This pattern held true across different model sizes and task difficulties, suggesting it's a fundamental challenge in how reasoning models allocate their computational resources.

What Makes Chart Editing Such a Tough Test?

Chart editing is a particularly demanding task for reasoning models because it requires juggling multiple cognitive demands simultaneously. A model must interpret a visual chart image, understand a user's editing instruction, reason about what changes are needed, and then generate executable code that implements those changes correctly. This combination of visual perception, instruction following, and code synthesis makes it an ideal benchmark for testing whether extended reasoning actually helps or hurts.

The challenge mirrors real-world scenarios where AI systems need to balance accuracy with efficiency. In business intelligence and scientific research, where chart refinement plays an important role, users need results that are both correct and delivered in reasonable time. The overthinking problem suggests that simply allocating more compute at test time may not be the solution.

How to Optimize Reasoning Efficiency in AI Models

• Process-Level Supervision: Train models with explicit guidance on intermediate reasoning steps, not just final outputs. This helps models learn when to stop reasoning rather than continuing until they hit a token budget limit.
• Hybrid Reward Systems: Combine efficiency rewards that penalize excessive thinking with fidelity rewards that measure output quality. This creates competing incentives that push models toward the optimal reasoning length for each task.
• Adaptive Thinking Budgets: Allow different tasks to use different amounts of reasoning time based on their complexity. Harder problems may need longer chains, while simpler tasks benefit from shorter, more focused reasoning.

Researchers at the source of this study developed a framework called REChart that implements these principles. The approach uses two training stages: first, supervised fine-tuning on 200,000 high-quality reasoning trajectories generated through an iterative refinement process; second, reinforcement learning with rewards that guide both the reasoning process and the final output.

The results were striking. On standard benchmarks for chart editing, REChart achieved state-of-the-art performance among open-source models of comparable size while dramatically improving efficiency. Most notably, the model reduced average reasoning token consumption by 79% compared to its base version, all while improving overall performance by 13.3 percentage points.

This efficiency gain matters in practice. Under a maximum thinking budget of 16,384 tokens (roughly equivalent to 12,000 words of reasoning), the optimized model used only about 2,500 tokens on average to reach its best performance. The largest efficiency improvements came on the most challenging variants of the task, where the base model was most prone to overthinking.

What Does This Mean for the Future of Test-Time Compute?

The overthinking discovery complicates the narrative around test-time compute scaling, the strategy of allocating more computational resources during inference rather than during training. For months, the AI industry has operated under the assumption that reasoning models benefit from extended thinking chains, with companies investing heavily in inference infrastructure to support longer reasoning processes.

The chart-editing research suggests this assumption needs refinement. More thinking time helps up to a point, but the relationship is not monotonic. Stronger models actually reach their peak performance with shorter reasoning chains, while weaker models may need longer budgets to compensate. This implies that the optimal strategy is not simply to maximize compute at test time, but to match reasoning depth to task difficulty and model capability.

The implications extend beyond chart editing. Any task requiring fine-grained visual reasoning, instruction following, and code synthesis faces similar challenges. This includes tasks in data visualization, UI design, scientific figure generation, and other domains where models must balance perception with generation.

The research also highlights a gap in how current reasoning models are trained. Most existing approaches focus on optimizing the final output through reinforcement learning, leaving the intermediate reasoning process largely unsupervised. Models learn to generate correct code, but they don't learn to do so efficiently. REChart's two-stage approach addresses this by providing explicit feedback on reasoning quality, not just terminal output quality.

As AI labs continue investing in inference-time scaling, this work suggests they should simultaneously invest in reasoning efficiency. The goal should not be unlimited thinking, but optimal thinking. This requires new training methods that teach models when to stop reasoning, new reward structures that penalize inefficiency, and new benchmarks that measure both accuracy and reasoning cost.

The broader lesson is that test-time compute, like any resource, has diminishing returns. The challenge for AI researchers is learning to recognize those returns and designing systems that respect them.