Agentic AI planning — formulate, execute, adapt

In short

Agentic planning is a system’s ability to formulate a sequence of actions to move from an initial state to a defined objective. Unlike a fixed workflow, a planning agent can revise its plan during execution when it discovers new constraints. This pattern applies when the path to the objective is unknown in advance — if that path is already known, a fixed workflow remains more reliable.

Two fundamental regimes

Before implementing a planning agent, the question to settle is: must the path to the objective be discovered, or is it already defined?

Fixed workflow: the sequence of actions is predetermined. The agent follows a script. This regime works when the solution is well understood, repeatable, and documented — onboarding a new employee, generating a weekly report, validating a form. Reliability is high, errors are predictable and traceable.

Dynamic planning: the agent formulates its plan from the current state, executes it, observes results, then adjusts. This regime works when subtasks emerge during execution — open-ended research, coordinating a project with shifting parameters, solving an ill-defined problem.

Gulli (2025) frames the distinction this way: “Dynamic planning is a specific tool, not a universal solution. When the solution to a problem is already well understood and repeatable, constraining the agent to a fixed, predetermined workflow is more effective.”

The choice between the two regimes is an architecture decision — not a value judgment. Opting for dynamic planning on a repeatable problem adds complexity without benefit.

In short: dynamic planning is not “superior” to fixed workflow — it is suited to a different class of problems. Out of 100 typical enterprise requests, about 80% have a known path (fixed workflow), 15% require conditional routing, only 5% justify a planning agent.

The Plan-Execute-Adapt pattern

The plan-execute-adapt pattern structures agentic execution in three iterative phases:

1. Formulate: the agent decomposes the high-level objective into discrete, ordered subtasks. It identifies dependencies between steps and the required resources.
2. Execute: each subtask is launched via available tools — API calls, web searches, code generation, delegation to other agents.
3. Adapt: the agent analyzes the results of each step. If an obstacle arises (inaccessible source, contradictory result, knowledge gap), it revises the plan accordingly rather than failing or stopping.

Revision can be partial (adjusting a subtask) or total (reformulating the intermediate objective). The agent does not treat obstacles as fatal errors but as information that feeds the next iteration.

The replanning loop

The replanning loop is the key mechanism that distinguishes a planning agent from a sequential executor. It comprises:

• Gap detection: the agent identifies what is missing from its current knowledge to progress toward the objective.
• Query reformulation: based on the detected gap, the agent generates new targeted actions.
• Corroboration: the agent confronts new information with what has already been collected, resolving contradictions.
• Continuation decision: the agent evaluates whether informational saturation has been reached or whether a new iteration is needed.

This process can unfold without human intervention, but requires explicit stopping criteria to prevent infinite loops.

Google DeepResearch: a concrete illustration

Google DeepResearch is the most documented public implementation of the plan-execute-adapt pattern applied to information retrieval.

How it works:

1. The user submits an open-ended question.
2. The agent formulates an initial research plan — a set of targeted queries.
3. It executes the searches, analyzes results, and identifies knowledge gaps.
4. It dynamically reformulates its queries based on detected gaps, corroborating contradictory data.
5. It iterates until saturation, then produces a structured synthesis.

Gulli describes the behavior as: “The agent dynamically formulates and refines its queries based on the information collected, actively identifying knowledge gaps, corroborating data points, and resolving divergences.”

What distinguishes DeepResearch from a standard web search: the order of queries is not fixed in advance. It emerges from successive discoveries. Information found at step 3 can redirect the entire plan — this is dynamic re-prioritization in action.

The OpenAI Deep Research API exposes intermediate steps (queries executed, code applied, reasoning traces), enabling debugging and validation of the process by the user.

Strengths and limits

Strengths

• Adaptability: the plan adjusts to constraints discovered during execution, without external intervention.
• Coverage: knowledge gaps are explicitly addressed rather than ignored.
• Resilience: a partial obstacle does not block the whole — the agent seeks an alternative path.

Limits

• Unpredictability: behavior is less deterministic than a fixed workflow. The final plan can diverge from the initial plan in ways that are difficult to anticipate.
• Computational cost: each replanning iteration consumes tokens and time. Without rigorous stopping criteria, costs can explode.
• Reduced traceability: auditing a dynamic plan is more complex than a sequential workflow. Exposing intermediate steps (as in the Deep Research API) mitigates but does not fully resolve this issue.
• Poorly suited to repeatable tasks: on well-defined processes, dynamic planning adds variance without added value.

When to choose dynamic planning

Dynamic planning is not an improved version of the fixed workflow — it is a different tool, suited to a different class of problems.

Key takeaways

• Agentic planning enables formulating, executing, and adapting a plan of action when facing a complex objective whose path is not known in advance.
• The fundamental distinction is between fixed workflow (known path, maximum reliability) and dynamic planning (path to discover, maximum flexibility).
• The plan-execute-adapt pattern relies on a loop: formulate, execute, detect gaps, reformulate, iterate.
• Google DeepResearch illustrates this pattern: queries are dynamically reformulated based on detected gaps, with no predefined order.
• The limits are real: unpredictability, computational cost, reduced traceability. Explicit stopping criteria are indispensable.