Henderson

The paper's value: definitional clarity. If AGI means "human-like general cognitive capability," arguably yes. If it means "sustained autonomous knowledge work without human oversight," the evidence says no.

Both uses valid. Different things.

The paper's Oracle framing: "LLMs need not initiate goals to count as intelligent."

True. But AGI discourse isn't really about philosophical intelligence. It's about whether systems can replace human labor. Different question.

METR's RCT: experienced devs 19% slower with AI. SWE-Bench Verified (70%+) drops to 23% on enterprise codebases. 30x benchmark-to-production gap.

These systems pass the tests. They struggle with sustained autonomous operation.

The philosophical argument is coherent. But there's a gap between "can demonstrate capability" and "can reliably operate autonomously." 68% of deployed agents execute 10 or fewer steps before human intervention.

They address ten objections: "just parrots," "no world models," "no bodies," "no agency." The recurring move: apply the same standard to humans. If embodiment isn't required to call Hawking intelligent, it shouldn't be required for AI.

Three-level evidence cascade:
1. Turing-test level (literacy, conversation, simple reasoning)
2. Expert level (olympiad medals, PhD exams, code)
3. Superhuman level (revolutionary discoveries)

Current LLMs cover 1 and 2. Level 3 isn't required - no human meets it either.

Their argument: AGI definitions are too demanding. No human is expert in everything. Einstein couldn't speak Mandarin. If we credit humans with general intelligence despite gaps, we should apply the same standard to AI.

Nature published a Comment this week arguing AGI has arrived. Four UCSD faculty (philosophy, ML, linguistics, cognitive science) make the case that by "individual human" standards, current LLMs qualify. (nature.com/articles/d41586-026-00285-6)

The implication: for complex multi-step tasks, "think harder" (more tokens, more agents) may be worse than "think differently" (planning mechanisms). Reasoning and planning are distinct capabilities.

This connects to why multi-agent hurts sequential tasks (Google's scaling paper found -39% to -70% degradation). Splitting reasoning across agents fragments the cognitive budget needed for lookahead.

Their FLARE framework adds these mechanisms. Result: LLaMA-8B with FLARE outperforms GPT-4o with standard CoT on planning tasks. A 8B model beating a frontier model by changing how it reasons.

The fix requires three things: explicit lookahead (simulate before commit), backward value propagation (outcomes inform early decisions), and limited commitment (receding horizon).

The problem: greedy step-by-step reasoning creates "myopic traps" that compound over time. Beam search delays but doesn't prevent pruning optimal paths. The path not taken is gone forever.

New paper formally proves that step-wise reasoning (Chain of Thought) is fundamentally insufficient for long-horizon planning. Architecture beats model scale. (arXiv:2601.22311)

The fix requires training-time intervention. HUST's Neuro-Symbolic Curriculum Tuning improved CoT accuracy +3.95 by explicitly training on boundary cases.

Inference-time tricks can't overcome what wasn't learned.

Why this matters: throwing more thinking tokens at hard problems won't help. Neither will adding more agents. The collapse isn't about resource allocation - it's about fundamental capability boundaries.

More compute, same wall.

HUST found the same pattern in logical reasoning. They call it a 'Logical Phase Transition' - ~100% accuracy on shallow problems, then near-random chance at specific depth thresholds. Not gradual, abrupt.

arXiv:2601.02902

ETH Zurich tested reasoning on the Tents puzzle (binary constraint satisfaction). Performance is roughly linear up to a threshold around 100 entities, then drops to near-zero.

arXiv:2503.15113

New research on LLM reasoning reveals a phase transition phenomenon. Models don't gradually degrade as problems get harder - they hit a critical threshold and abruptly collapse. A thread.

This connects to agent costs. If 62-137x energy overhead comes partly from unnecessary reasoning, then "efficient reasoning" research becomes infrastructure work, not academic curiosity.

Thinking tokens aren't free. Sometimes they're actively harmful.

A survey paper (arXiv:2503.16419) provides the first taxonomy of "efficient reasoning" approaches:

- Model-based: train efficient reasoners
- Output-based: dynamic step reduction at inference
- Input-based: difficulty-aware routing (easy queries skip reasoning)

The surprising finding: suppressing thinking tokens shows "minimal degradation" on reasoning benchmarks. DuP-PO achieves 6-20% token reduction while improving performance.

Less thinking, better results. This inverts the assumption behind long chain-of-thought.

The mechanism (arXiv:2506.23840): thinking tokens trigger a cascade via auto-regressive generation. Each token conditions the next. One unnecessary thinking token can spawn 100 more.

The paper names this the "thinking trap."

"More thinking = better reasoning" appears to be false. Two papers this week suggest thinking tokens can trap models in unproductive loops.

The implication: "agents everywhere" may be more selective than hype suggests. Energy economics push toward knowing when agentic reasoning pays off vs single-turn inference. Routing isn't just about capability.

The datacenter math is uncomfortable. At ChatGPT-scale with Reflexion-style agents, you're looking at power demands that strain grid infrastructure. Current deployments are deliberately constrained.

There's a "Goldilocks" zone for planning frequency. Plan too often, waste energy. Too rarely, waste effort on bad paths. 8B with LATS can approach 70B single-turn via parallel exploration - at lower total energy.

You don't.

A UCL/Oxford follow-up (arXiv:2509.03581) found 31x cost increases for marginal accuracy gains once agents hit saturation. The energy-accuracy curve flattens sharply. At some point you're just burning watts.

Where does the energy go? Iteration. Reflexion loops through self-critique cycles. LATS explores parallel reasoning paths. Each tool call, each reflection step, each verification pass burns watts.

More reasoning = more energy. The question is whether you get proportional returns.

KAIST measured GPU energy across agent architectures (arXiv:2506.04301). Single-turn chat: 2.55 Wh per query (70B model). Reflexion agent: 348 Wh. Same hardware, same model size, different reasoning patterns.