Add a step that checks the plan, because the planner will not check itself

Insert explicit plan validation, a critique, an alternative, a check against the goal, and bad plans get caught before execution. Let the planner be its own only reviewer and the flaws ship with the plan.

B

Balagei G Nagarajan

3 MIN READ


An explicit validation step checking an agent's plan before execution

Key facts.

  • Let's Verify Step by Step shows validating each step (process supervision) outperforms checking only the final outcome, the case for explicit plan validation. source
  • Tree of Thoughts shows generating and evaluating alternative plans improves problem-solving, supporting critique and alternative-generation steps. source
  • Measuring chain-of-thought faithfulness shows the planner's stated reasoning can be unfaithful, so it cannot reliably review itself. source

Why does a plan need a separate validation step?

The planner's own reasoning can be unfaithful and a more capable model is no exception, so a wrong plan caught late costs the run. (arXiv:2305.20050)

A planner that produces a plan and immediately executes it has no checkpoint where a flaw can be caught. Asking the same planner to review its own plan helps little, because, as the faithfulness research shows, its stated reasoning may not reflect its actual basis, so its self-review is reviewing a narrative rather than the real plan. The result is that flaws, a missing step, a bad assumption, an unsafe action, ship with the plan and are discovered only in execution. Process supervision research makes the alternative concrete: checking each step, rather than only the final outcome, catches errors substantially better, which is precisely what an explicit plan-validation step does before any action runs.

The validation can take a few forms and the strong ones add independence. A critique step, ideally by a separate verifier rather than the original planner, checks the plan against the goal and constraints. Alternative generation, the Tree of Thoughts idea, produces more than one plan and evaluates them, so the chosen plan was compared rather than accepted by default. A check against an explicit success definition confirms the plan would actually achieve the objective. The common thread is that the plan is examined by something other than the planner's own unfaithful self-assessment, before execution, which is the only point where catching a flaw is cheap.

A plan passing through a validation gate with critique, alternatives, and a goal check before execution

What does plan validation include?

MechanismNo validationExplicit validation
ReviewerThe planner itselfA separate verifier
AlternativesOne plan acceptedGenerated and compared
Goal checkAssumed metConfirmed before acting
FlawsShip with the planCaught before execution

An effective validation step needs a clear standard to validate the plan against, which is what VibeModel provides as the Pattern Intelligence Layer. By making the goal and the conditions of a valid plan explicit, it gives the validation step a real criterion, does this plan satisfy the success pattern, rather than relying on the planner's own unfaithful self-review, so bad plans are caught against an objective standard before they ever execute.

Frequently asked questions

Can't the planner review its own plan?
Not reliably. Its stated reasoning can be unfaithful, so self-review checks a narrative, not the real plan. Validation needs independence.

Why validate the plan, not just the outcome?
Because process supervision research shows checking each step catches errors far better than checking only the final result and it catches them before execution.

What forms can validation take?
A separate critique, alternative-plan generation and comparison and a check against an explicit success definition, ideally not by the original planner.


Share this post

Join the discussion

Have a take, a war story, or a question? Sign in with GitHub to comment and react. Comments are powered by GitHub Discussions, ad-free and yours to moderate.

Continue Reading

Find where your agent breaks, before you build it

Faultmap maps where your agent will fail from the goal and your data, then hands you the first test suite it has to pass.