Every proposed fix for AI agents doing complex, multi-step tasks shares a hidden requirement: something that can check whether the agent is on the right track. Whether it's self-critique, reinforcement learning, or tree search, the underlying mechanism is the same. Strip away the jargon and you find a verifier, a component that judges whether a candidate solution is correct. When that verifier is sound, agents work. When it's absent or unreliable, they fail.

Why Does Every AI Planning Method Need a Verifier?

Researchers and engineers have proposed a long list of approaches to help AI agents handle long-horizon planning, the ability to break down complex goals into steps and execute them over time. The list reads like independent research directions, but they all share something fundamental.

• Hierarchical Planning: Breaks a goal into subgoals but needs something to confirm each subgoal was actually achieved before moving to the next one.
• Inference-Time Search: Generates multiple candidate solutions but requires a ranker to pick the best one.
• Process Supervision: Rewards intermediate steps but needs correctness labels at each step, which is itself a verification task.
• Formal Proof Checking: Explicitly uses a verifier to check mathematical proofs.
• Learned Verifiers: Trains a separate model to judge whether outputs are correct.
• Neuro-Symbolic Architectures: Wires a language model generator to a symbolic checker.
• Adaptive Computation: Requires knowing when to stop, which means knowing whether you are done, a verification task.
• Belief-State Tracking: Requires detecting when the model's understanding has diverged from reality.
• Invariants and Failure Conditions: Explicitly encode checks for when things go wrong.

The pattern is unmistakable. Nine different methods, one core component. What differs between them is not the sophistication of the approach but where the verifier comes from and how reliable it is.

What Happens When AI Tries to Verify Its Own Work?

The most optimistic version of the story is that a language model can serve as its own checker. Generate a candidate answer, critique it, revise, repeat. This is the premise behind reflection, self-refinement, and most of what gets marketed as an agentic loop. The logic seems sound: verification should be easier than generation, so a system that can generate imperfectly should be able to verify well enough to improve.

But the evidence tells a different story. Researchers tested this directly across three domains, Game of 24, graph coloring, and STRIPS planning, using GPT-4 to critique its own answers and comparing the results to an external, guaranteed-correct verifier. The findings were stark: self-critique produced significant performance collapse, while sound external verification produced significant performance gains.

The collapse was not a minor stumble. In graph coloring, the system failed to recognize a correct coloring as correct, rejecting valid solutions. The mechanism matters because it reveals something unexpected: the content of the critique barely mattered. What mattered was whether the accept-or-reject signal was actually sound. A model critiquing itself generates plausible-sounding feedback that feels authoritative but lacks grounding in actual correctness.

How Much Better Do Agents Perform With Real Verifiers?

When researchers provided sound external verification, the improvements were substantial. On a classical planning domain, performance jumped from roughly one-third to four-fifths. On a travel-planning benchmark where the unaided model scored 0.6%, external verification pushed performance to 20 percent. These are not marginal gains; they represent the difference between an agent that barely works and one that is genuinely useful.

However, external verification has a ceiling. When the same domain was tested with names obfuscated, verification could no longer help. The reason is revealing: the generator could no longer propose a candidate worth checking. The verifier is only as good as the candidates it receives. If the generator cannot produce something in the ballpark of correct, even a perfect verifier cannot salvage the result.

What Is the Real Cost of Building Verifiers?

The verifiers that do exist come at a price. The best-documented process reward model, which judges whether intermediate steps in reasoning are correct, required eight hundred thousand human step-level labels to build. That is not a one-time cost; it is the cost of creating a single verifier for a single domain.

This reveals why the intuition from complexity theory does not transfer to real AI systems. In theory, checking should be easier than finding. But in practice, approximate retrieval systems like language models do not benefit from that principle. A model that generates imperfectly cannot easily verify its own imperfect outputs. The verifier needs to be either supplied from outside at real cost, or supplied by the model itself, in which case the measured result is not improvement but collapse.

How to Improve AI Agent Reliability in Practice

• Invest in External Verification: Build or source verifiers from outside the generative model, even if it requires human labeling or formal systems. The performance gains justify the cost.
• Use Domain-Specific Checkers: Prioritize domains where sound checkers already exist, such as code that compiles and passes tests, mathematics with canonical answers, or games with simulators.
• Avoid Self-Critique Loops: Do not rely on a model to critique its own outputs without external grounding. The feedback will feel authoritative but lack actual correctness signals.
• Store Plan Representations Explicitly: Maintain plans as structured objects with conditions attached, not just as text in a context window. This enables detection of when a plan has failed.
• Implement Belief Updates: Build systems that compare expected observations against actual observations, allowing the agent to detect when its model of the situation has diverged from reality.

The core insight is that autonomy is not distributed evenly across domains. It is concentrated precisely where a sound checker happens to exist. Outside that set, the thing you would need to certify the agent's work is the thing you were hoping the agent would do in the first place.

This has profound implications for where AI agents will succeed and where they will struggle. In formal planning domains, code that compiles and passes tests, mathematics with a canonical answer, and games with a simulator, agents can work reliably because verifiers exist. In open-ended domains like creative writing, strategic planning, or real-world problem-solving where no clear verifier exists, agents will continue to struggle, no matter how sophisticated the underlying model becomes.