What is plan validation?

Plan validation is the process of checking whether an agent's proposed plan is actually executable, complete, safe, and consistent with the goal before or during execution.

A plan may look reasonable in natural language but still contain missing prerequisites, impossible steps, permission problems, or unsafe actions.

A simple example

Suppose an agent creates this plan:

1. issue a refund
2. notify the customer

Before executing it, the system may validate:

• Is the order eligible for a refund?
• Does the agent have permission to issue it?
• Is manager approval required?
• Is the refund amount valid?
• Has the refund already been processed?

If these conditions are not satisfied, the plan should not proceed unchanged.

Plan validation checks whether prerequisites are satisfied

Each step may depend on information or work from earlier steps.

For example:

retrieve customer → obtain customer_id → fetch invoices

If the plan tries to fetch invoices before customer_id exists, the dependency is invalid.

Validation can detect this before execution reaches the broken step.

It checks whether required tools exist

A plan may reference an action the agent cannot actually perform.

For example:

Step: update CRM record

But no CRM tool is available.

The plan may need to:

• use another approved capability
• ask for human help
• remove the step
• stop

A plan is only useful if its required capabilities exist.

It checks permissions

A tool may exist but still be unavailable to the current user, tenant, or agent.

Validation should check:

• tool access
• action-level permissions
• tenant scope
• role restrictions
• required approvals

A plan should not assume that technical capability equals authorization.

It checks inputs

A planned action may require:

• an ID
• a date
• a valid amount
• a file
• a specific format

For example:

cancel_order(order_id)

If order_id is missing, the step is not ready to execute.

Validation can identify the missing input and add an earlier step to obtain it.

It checks ordering and dependencies

A valid plan should place prerequisite steps before dependent steps.

For example:

Correct:

1. retrieve order
2. verify ownership
3. cancel order

A plan that attempts cancellation first may be incomplete or unsafe.

It checks for contradictory steps

Plans can accidentally contain actions that conflict.

For example:

1. close support ticket
2. continue investigating support ticket

These steps may not make sense together.

Validation can detect conflicts before the workflow proceeds.

It checks whether the plan can reach the goal

A plan may contain valid individual steps but still fail to satisfy the user's objective.

For example:

Goal: Email the final report.

Plan:

1. collect data
2. generate report

The plan is incomplete because the delivery step is missing.

Plan validation should compare the proposed steps with the completion criteria.

It checks constraints

The plan may need to satisfy:

• budget
• deadline
• rate limits
• safety requirements
• compliance rules
• user preferences

For example, a plan that requires an expensive external API may be invalid if the task has a strict cost limit.

High-impact actions need stronger validation

Actions such as:

• sending money
• deleting data
• making purchases
• changing permissions
• sending external communications

should usually receive stricter checks before execution.

Validation may require explicit approval immediately before the action.

Validation can happen at multiple points

Plan validation is not necessarily a one-time check.

It can occur:

• after the initial plan is generated
• before a sensitive step
• after new information changes the state
• after replanning
• before final completion

This is important because a plan that was valid earlier may become invalid later.

Validation can be deterministic

Whenever possible, important checks should be enforced in code rather than left entirely to model reasoning.

Examples include:

• schema validation
• permission checks
• required-field checks
• numeric limits
• dependency checks
• approval gates

The model may propose a plan, but trusted system logic should enforce hard constraints.

What happens when validation fails?

The agent may:

• repair the plan
• add missing steps
• remove invalid steps
• reorder dependencies
• choose another tool
• request approval
• ask the user for missing information
• stop safely

Validation failure should produce a clear next action rather than silently continuing.

A practical validation flow

Before execution, a system can check:

1. Does the plan still match the goal?
2. Are all required steps present?
3. Are dependencies correctly ordered?
4. Are required inputs available?
5. Are the necessary tools available?
6. Are permissions and approvals satisfied?
7. Are safety and policy constraints respected?
8. Is the completion condition clear?

If important checks fail, the plan should be revised before continuing.

In short

Plan validation checks whether an AI agent's proposed plan can safely and correctly achieve the goal under the current state and constraints.

It helps catch missing steps, broken dependencies, unavailable tools, invalid inputs, permission problems, contradictory actions, and unsafe execution before they become real failures.