Flashcard: when would you pick Plan-and-Execute over ReAct?

**Plan-and-Execute** is an agent pattern with two distinct phases. First, a planner LLM reads the goal and writes a complete plan: an ordered list of steps. Then an executor runs the steps one by one, often calling tools, without invoking the planner again at every step. **ReAct** is different. It does not separate the phases. At every turn, the model writes a Thought and then an Action. The Action runs, an Observation comes back, and the next Thought is generated with that Observation in context. Planning and execution are interleaved. The core structural difference is when the planning happens. Plan-and-Execute does it once at the start. ReAct does it inside every loop iteration. This leads to different tradeoffs. Plan-and-Execute is cheaper and faster on long, predictable tasks because the expensive planner call happens once. ReAct adapts better when intermediate results change what should happen next. Modern agent frameworks often blend both: plan up front, execute several steps, and only re-plan when an observation contradicts the plan.

**Plan-and-Execute** is an agent pattern where the LLM writes a complete plan up front (an ordered list of sub-tasks), then a separate executor runs the plan step by step without calling the planner again at every step. **ReAct** interleaves a Thought and an Action at every step, so each new reasoning step sees the latest Observation before choosing the next Action. The structural difference is the timing of the planning. Plan-and-Execute treats planning as a separate phase that runs once. ReAct treats planning as something the model does at every turn, conditioned on the latest evidence. The tradeoffs follow directly. Plan-and-Execute is faster and cheaper on long, predictable tasks because the expensive planner-model call (often a frontier model like Claude Opus 4.7 or GPT-5.5) happens once instead of N times. Execution can use a cheaper model or a deterministic runner. ReAct adapts better when intermediate results genuinely change what should happen next, because the next step is chosen with the latest Observation in context. The cost is N planner calls instead of one. Production systems often blend both. LangGraph's plan-and-execute pattern adds a replanning node that runs only when an Observation contradicts the plan, giving Plan-and-Execute the adaptability of ReAct on the rare cases that need it without paying the ReAct cost on every step.