Reasoning models change the economics of planning, not the need for it

Reasoning models turned planning quality into something you buy per query — an effort dial, billed in thinking tokens. What they did not do is repeal the reason planning discipline exists. The need for external verification, explicit structure, and knowing when to stop thinking survives intact; what changed is the price list.

The economic shift is real and worth stating plainly. Test-time compute scaling means a smaller model thinking longer can match a bigger model answering cold, so planning depth stopped being a property you baked in at training time and became an allocation decision you make at inference time. The serious engineering now lives in that allocation: estimating problem difficulty and routing compute accordingly, choosing best-of-N sampling for easy problems and search-guided strategies for hard ones, cascading so cheap queries exit fast. The scaling curves even bend the right way — accuracy keeps climbing as you spend more. But they bend down too: over-optimizing against a reward model, drifting context, and plain overthinking — a model circling a problem, burning budget on re-derivations — are documented failure modes, which is why "how much should this query think" is a budgeting question, not a maximization question.

What the verifier still decides

Here's the part the economics doesn't change. Kambhampati's critique of LLM planning was never "models can't produce plans" — it was that they can't soundly verify their own plans, and the model that hallucinated a plan is structurally the wrong judge of the hallucination. That circularity does not go away when the chain of thought gets longer. Look at where reasoning training actually succeeded: math and code — precisely the domains where an external verifier exists, because a test suite or a symbolic checker can tell the reward signal the truth. Reasoning RL is the LLM-Modulo loop industrialized: generate candidates, let something sound judge them, learn from the judgment. The same holds at inference. Every credible test-time strategy — best-of-N, beam search over steps, process reward models scoring trajectories — is a proposer paired with a verifier, and the quality ceiling belongs to the verifier. A reasoning model without one is an eloquent proposer with no one sound checking its work.

Agentic planning inherits both halves

For agent systems this cashes out concretely. The new economics argues for spending model judgment where enumeration is expensive — and the persistent need for verification argues for keeping the deterministic scaffolding that judges the result: schema checks, execution against sandboxes, budgets and stopping conditions, plans decomposed into steps something external can evaluate. Routing frameworks that send reversible, low-stakes actions down a fast path and irreversible ones through a verified path are just difficulty-aware compute allocation with consequences attached.

One honest concession: emergent self-correction is real. Models trained with reasoning RL genuinely catch and fix a class of their own mid-trajectory errors — the "wait, actually" behavior emerged from reward, nobody programmed it — and it absorbs some of what we used to need explicit scaffolding for. But self-correction inside a trajectory is not self-verification of the outcome; the model still can't certify its own final plan, and the domains where correction emerged are the ones where a verifier trained it. So my planning bill has genuinely gone down. The line items that remain — an external check on every plan that matters, and a budget on every thought — are the ones that were never the model's to begin with.