Explain Plan-and-Execute, its advantage over ReAct on complex tasks, and its failure mode

**plan and execute** is an agent pattern that splits the work into two jobs. A planner reads the goal once and writes a full task list, like step one search, step two summarise, step three write. An executor then runs each step in order and feeds the result back. Compare this to ReAct, which decides the next action one step at a time. ReAct looks at everything it has seen, picks a single action, sees the result, and repeats. That is flexible, but on a long task the growing pile of context can pull the model off course. The advantage of planning up front is two things. The plan gives every step a stable anchor so the agent does not drift from the goal, and you make one big reasoning call instead of a fresh reasoning call before every action, which can cut cost. The weakness is that the plan was written before any step ran. If step one returns something surprising that breaks the plan's assumptions, the later steps may now be wrong, and a naive executor follows them anyway. The standard fix is a replanning step that rechecks the plan when a result looks off.

**plan and execute** separates an agent into two roles. A planner decomposes the goal into a structured task list before any tool runs. An executor then carries out each step in sequence, feeding observations back. It beats vanilla ReAct on long, multi-stage tasks. ReAct re-derives the next action from the full transcript every turn. As that transcript grows, accumulated noise drags the model off the original goal. An explicit plan is a stable anchor that survives a noisy context. It also front loads reasoning into one planner call, so per step LLM calls get cheaper and a coherent long horizon strategy emerges. The primary failure mode is plan staleness. The plan is fixed before execution starts. If an early step returns an unexpected result, later steps can rest on broken assumptions. A naive executor follows the stale plan anyway and produces irrelevant work. The core mitigation is replanning. Add a gate after any step whose output could change later steps. The gate asks whether the remaining plan still holds, and rewrites the tail if it does not. Hierarchical plans and a plan act hybrid that keeps small ReAct loops inside each step further soften the brittleness.