Plan-and-execute agents separate the planning phase from the execution phase, first generating a complete step-by-step plan and then carrying out each step individually. This two-phase architecture addresses limitations of purely reactive agents like ReAct by providing a structured roadmap before any actions are taken. The approach improves reliability on complex multi-step tasks by reducing compounding errors that arise from step-by-step improvisation.

The plan-and-execute pattern consists of two core components operating in sequence:

• Planner: An LLM that receives the user's objective and decomposes it into an explicit, ordered sequence of steps. The planner considers dependencies between steps and the tools available for execution.
• Executor: A separate agent (often a ReAct-style agent) that carries out each step, invoking tools as needed and reporting results back.

State management persists the plan, current step index, and accumulated results, enabling resumability if execution is interrupted. This separation of concerns allows different models or configurations for planning versus execution – for example, using a more capable model for planning and a faster model for routine execution steps.

from langgraph.graph import StateGraph, START, END
from langchain_openai import ChatOpenAI
from typing import TypedDict, Annotated
import operator
 
class PlanExecuteState(TypedDict):
    objective: str
    plan: list[str]
    current_step: int
    results: Annotated[list[str], operator.add]
    final_answer: str
 
planner_llm = ChatOpenAI(model="gpt-4o")
executor_llm = ChatOpenAI(model="gpt-4o-mini")
 
def plan_step(state: PlanExecuteState) -> dict:
    """Planner: decompose the objective into ordered steps."""
    resp = planner_llm.invoke(
        f"Break this objective into 3-5 concrete steps:\n{state['objective']}\n"
        "Return each step on a new line, numbered."
    )
    steps = [line.strip() for line in resp.content.split("\n") if line.strip()]
    return {"plan": steps, "current_step": 0}
 
def execute_step(state: PlanExecuteState) -> dict:
    """Executor: carry out the current step using available context."""
    idx = state["current_step"]
    step = state["plan"][idx]
    context = "\n".join(state["results"]) if state["results"] else "No prior results."
    resp = executor_llm.invoke(
        f"Execute this step: {step}\nPrior results:\n{context}"
    )
    return {"results": [resp.content], "current_step": idx + 1}
 
def should_continue(state: PlanExecuteState) -> str:
    """Route: continue executing or finalize."""
    return "execute" if state["current_step"] < len(state["plan"]) else "finalize"
 
def finalize(state: PlanExecuteState) -> dict:
    """Synthesize all step results into a final answer."""
    all_results = "\n".join(state["results"])
    resp = planner_llm.invoke(f"Synthesize these results:\n{all_results}")
    return {"final_answer": resp.content}
 
# Build the LangGraph state machine
graph = StateGraph(PlanExecuteState)
graph.add_node("plan", plan_step)
graph.add_node("execute", execute_step)
graph.add_node("finalize", finalize)
graph.add_edge(START, "plan")
graph.add_edge("plan", "execute")
graph.add_conditional_edges("execute", should_continue)
graph.add_edge("finalize", END)
 
app = graph.compile()
result = app.invoke({"objective": "Research and summarize HNSW algorithms"})
print(result["final_answer"])

BabyAGI pioneered a dynamic variant of plan-and-execute where the task queue is continuously regenerated. Rather than creating a fixed plan upfront, BabyAGI's task creation agent generates new tasks based on execution results, and a prioritization agent reorders them. This produces adaptive planning that evolves with the task, combining the structure of plan-and-execute with some of the flexibility of ReAct.

Modern frameworks have adopted this pattern with hierarchical supervisors for multi-level task decomposition, where high-level goals are broken into sub-plans, each managed by specialized agents.

LangChain implements plan-and-execute through LangGraph's stateful graphs, providing:

• Structured Workflows: Nodes represent planning and execution stages, connected by edges that manage state transitions
• Dynamic Replanning: Feedback loops allow the executor to report failures to the planner, triggering plan revision mid-execution
• Tool Integration: Executors access shared tool registries, RAG systems, and external APIs
• Human-in-the-Loop: Checkpoint nodes where humans can review and modify the plan before execution continues

Plan-and-execute and ReAct represent fundamentally different strategies for agent decision-making:

In practice, hybrid approaches dominate: plan-and-execute for the overall structure with ReAct-style execution within individual steps, combining strategic planning with tactical flexibility.

Static plans fail when the environment changes or unexpected results occur. Modern plan-and-execute agents incorporate feedback loops for mid-execution adaptation:

• Execution Feedback: Executors report step outcomes, including failures, to the planner
• Plan Revision: The planner generates an updated plan incorporating new information
• Selective Replanning: Only affected downstream steps are revised, preserving completed work
• Iteration Limits: Maximum replan counts prevent infinite loops

LangGraph implements this through graph cycles where execution nodes can route back to planning nodes based on conditional logic.

Complex tasks benefit from multi-level planning hierarchies:

• Supervisor Agents: High-level planners that decompose objectives into major phases
• Mid-Tier Planners: Create detailed step sequences for each phase
• Worker Agents: Execute individual steps using tools and report results upward

Patterns include hub-and-spoke (central orchestrator), pipeline (sequential handoffs), and peer-to-peer (collaborative decomposition). These hierarchies scale plan-and-execute to handle workflows that would overwhelm a single planning step.

Late 2025 research emphasizes production-grade plan-and-execute with:

• Parallel DAG execution for independent plan steps
• Human-in-the-loop verification at critical decision points
• Security through separated planning and execution contexts
• Process reward models for evaluating plan quality
• Frameworks like LangGraph, CrewAI, and AutoGen providing built-in plan-and-execute primitives

• Wang, L. et al. "Plan-and-Solve Prompting: Improving Zero-Shot Chain-of-Thought Reasoning by Large Language Models." arXiv:2305.04091, 2023.
• Yao, S. et al. "ReAct: Synergizing Reasoning and Acting in Language Models." arXiv:2210.03629, 2022.
• Yao, S. et al. "Tree of Thoughts: Deliberate Problem Solving with Large Language Models." arXiv:2305.10601, 2023.
• Shinn, N. et al. "Reflexion: Language Agents with Verbal Reinforcement Learning." arXiv:2303.11366, 2023.
• GitHub: yoheinakajima/babyagi – Original BabyAGI task-driven agent by Yohei Nakajima.
• LangChain Documentation – Plan-and-execute patterns via LangGraph.
• Wang, L. et al. "A Survey on Large Language Model based Autonomous Agents." arXiv:2308.11432, 2023.

• ReAct Agents
• BabyAGI
• Agent Loop
• Chain of Thought Agents
• Modular Architectures