Agent Planning: Task Decomposition and Execution Strategies (2026)

When to Use

• ✓Tasks with 5+ steps where the agent needs a roadmap to stay on track
• ✓Tasks where early failures should trigger replanning, not crashing the whole workflow
• ✓Research or analysis tasks where the required steps depend on what's discovered
• ✓Multi-day or multi-session tasks where the plan must persist between interruptions
• ✓Tasks requiring resource estimation upfront (API call budget, time estimate, cost limit)

How It Works

1. 1Plan-and-execute pattern: first prompt the agent to generate a complete plan (ordered list of steps with expected outputs), then execute each step in sequence, checking after each step whether to continue, replan, or stop.
2. 2Hierarchical planning: decompose into high-level goals → subgoals → atomic steps. The agent knows its place in the hierarchy, preventing premature zoom into details before the high-level approach is validated.
3. 3Dynamic replanning: after each step, ask: 'Does the original plan still make sense given what we've learned?' If a step revealed that the approach is wrong, generate a revised plan before continuing. Limit replanning to 2-3 times to prevent overthinking.
4. 4Resource-bounded planning: give the agent a budget (N tool calls, K tokens, T minutes) and require it to produce a plan that fits within the budget. This prevents unbounded exploration on tasks that should be quick.
5. 5Task state tracking: maintain explicit state (not just conversation history): current_step, completed_steps, discovered_facts, current_plan. This state persists across session breaks and enables recovery after failures.

Examples

# Step 1: Generate plan
plan_response = client.messages.create(
    model='claude-3-5-sonnet-20241022',
    system='You are a planning agent. Given a task, create a numbered execution plan. Each step should have: action, expected_output, tools_needed.',
    messages=[{'role': 'user', 'content': f'Task: {task}\n\nCreate an execution plan. Be specific about which tools to use at each step.'}]
)
plan = parse_plan(plan_response.content[0].text)

# Step 2: Execute plan with replanning capability
for i, step in enumerate(plan.steps):
    result = execute_step(step, available_tools)
    
    if result.status == 'failed' or result.requires_replan:
        new_plan = replan(original_plan=plan, completed=plan.steps[:i], 
                         failed_step=step, failure_reason=result.error)
        plan = new_plan
    
    plan.steps[i].result = result

System: You are a research agent. For complex tasks:
1. First output a PLAN: numbered list of steps you will take
2. Then execute each step, prefixing each with STEP N:
3. After each step, output STATUS: [continue|replan|complete] and WHY
4. If status is 'replan', output REVISED PLAN: before continuing
5. Conclude with SUMMARY: of findings

This structure makes your work auditable and allows human review at each step.

Common Mistakes

• ✗Over-planning before acting — generating a 20-step plan upfront for a task that might be completed in 3 steps wastes tokens and creates false confidence in a plan that will need replanning anyway. Generate the minimal plan that unblocks the first 2-3 steps.
• ✗No plan validation — plans generated by the LLM can contain logical errors, impossible steps, or undefined dependencies. Validate plans before execution: check that each step has available tools, that dependencies are ordered correctly, and that the plan fits within resource budgets.
• ✗Treating the plan as immutable — agents that rigidly follow the original plan even when execution reveals it's wrong will fail. Build explicit replanning checkpoints after steps that gate the continuation of the plan.
• ✗Not persisting plan state — for long-running tasks, plan state must be serialized to a database between steps. If the agent crashes on step 7 of 15, it should resume from step 8, not restart from scratch.

FAQ