WritingBooksAboutCommunityContactCommunity

Plan and Execute: Turning Agent Plans into Action with Error Handling & Flexibility

Michael Brenndoerfer•July 21, 2025•12 min read

Learn how AI agents execute multi-step plans sequentially, handle failures gracefully, and adapt when things go wrong. Includes practical Python examples with Claude Sonnet 4.5.

Plan and Execute

In the previous chapter, we learned how to break down complex tasks into manageable steps. Our assistant can now look at a request like "Plan my weekend getaway" and decompose it into a clear sequence: find destinations, check travel options, book accommodations, and plan activities. But having a plan is only half the battle. Now we need to actually execute it.

Think of it like following a recipe. You've read through the instructions and understand the steps, but you still need to gather ingredients, measure them out, and cook them in the right order. If you discover you're out of eggs halfway through, you'll need to adapt. The same goes for our AI agent. This chapter explores how an agent takes its plan and turns it into action, handling each step sequentially while remaining flexible enough to deal with the unexpected.

From Plan to Action

When our assistant has a plan, it needs to work through each step systematically. Let's continue with the weekend getaway example from the previous chapter. The agent created this plan:

  1. Find potential destinations within 3 hours of the user's location
  2. Check available flights or train options
  3. Search for hotels with availability
  4. Suggest activities at the destination

Now comes the execution phase. The agent starts with step 1, uses the tools at its disposal (perhaps a location search API), gets results, and moves to step 2. This sequential approach ensures that each step builds on the previous one. You can't book a hotel before you know which city you're visiting.

Here's a simple implementation of a plan executor:

In[4]:
Code
## Using Claude Sonnet 4.5 for its superior planning and tool-use capabilities
import os
from anthropic import Anthropic

client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

def execute_plan(plan_steps, tools):
    """Execute a plan step by step, using available tools."""
    results = []
    
    for i, step in enumerate(plan_steps, 1):
        print(f"\nExecuting step {i}: {step}")
        
        # Ask the agent to execute this specific step
        response = client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=1024,
            tools=tools,
            messages=[{
                "role": "user",
                "content": f"Execute this step: {step}\n\nPrevious results: {results}"
            }]
        )
        
        # Process tool calls if any
        if response.stop_reason == "tool_use":
            tool_result = handle_tool_call(response.content[0])
            results.append({
                "step": step,
                "result": tool_result
            })
        else:
            results.append({
                "step": step,
                "result": response.content[0].text
            })
    
    return results

## Example plan from previous chapter
plan = [
    "Find destinations within 3 hours",
    "Check travel options to top destination",
    "Search for available hotels",
    "Suggest activities"
]

## Execute the plan
execution_results = execute_plan(plan, available_tools)

Notice how each step receives the results from previous steps. This context is crucial. When the agent searches for hotels in step 3, it needs to know which destination was selected in step 1. The agent maintains this running context throughout execution.

Handling Failures Gracefully

Plans rarely execute perfectly. APIs go down, data is missing, or assumptions turn out to be wrong. A robust agent needs to handle these situations without completely falling apart.

Let's say our agent is executing step 2 (checking travel options) and the flight API returns an error. What should happen? The agent has several options:

Option 1: Retry the step. Maybe it was a temporary network issue. Try the same step again, perhaps with a small delay.

Option 2: Use an alternative approach. If the flight API is down, maybe try a train search API instead.

Option 3: Skip and continue. If this step isn't critical, mark it as failed and move on. The user can book their own travel.

Option 4: Re-plan. If the failure makes the rest of the plan impossible, go back to the planning phase and create a new approach.

Here's how we might implement basic error handling:

In[3]:
Code
## Using Claude Sonnet 4.5 for robust error handling in agent workflows
def execute_step_with_retry(step, tools, previous_results, max_retries=2):
    """Execute a single step with retry logic."""
    
    for attempt in range(max_retries + 1):
        try:
            response = client.messages.create(
                model="claude-sonnet-4-5",
                max_tokens=1024,
                tools=tools,
                messages=[{
                    "role": "user",
                    "content": f"Execute: {step}\n\nContext: {previous_results}"
                }]
            )
            
            if response.stop_reason == "tool_use":
                return handle_tool_call(response.content[0])
            else:
                return response.content[0].text
                
        except Exception as e:
            if attempt < max_retries:
                print(f"Step failed (attempt {attempt + 1}), retrying...")
                continue
            else:
                # After all retries, ask agent what to do
                print(f"Step failed after {max_retries + 1} attempts")
                return handle_failure(step, str(e), previous_results)

def handle_failure(failed_step, error, context):
    """Ask the agent to decide how to handle a failure."""
    
    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=512,
        messages=[{
            "role": "user",
            "content": f"""This step failed: {failed_step}
            
Error: {error}

Context so far: {context}

What should we do? Options:

1. Try an alternative approach
2. Skip this step and continue
3. Stop and re-plan

Respond with your choice and reasoning."""
        }]
    )
    
    return response.content[0].text

This approach gives the agent some autonomy in handling failures. Instead of hard-coding every possible error scenario, we let the agent reason about what makes sense given the specific situation.

Maintaining Flexibility

The best plans are flexible. As the agent executes steps, it might discover new information that suggests a better approach. Maybe step 1 reveals that the user's preferred destination is fully booked this weekend. A rigid executor would continue anyway, trying to book unavailable hotels. A flexible one would recognize the problem and adjust.

We can build this flexibility into our executor by periodically checking if the plan still makes sense:

In[4]:
Code
## Using Claude Sonnet 4.5 for adaptive planning and execution
def execute_with_flexibility(plan, tools):
    """Execute a plan while remaining open to adjustments."""
    results = []
    current_plan = plan.copy()
    
    for i, step in enumerate(current_plan):
        print(f"\nStep {i + 1}: {step}")
        
        # Execute the step
        result = execute_step_with_retry(step, tools, results)
        results.append({"step": step, "result": result})
        
        # After each step, check if we should continue as planned
        if i < len(current_plan) - 1:
            should_adjust = check_if_adjustment_needed(
                current_plan[i + 1:], 
                results
            )
            
            if should_adjust:
                print("\nAdjusting plan based on new information...")
                current_plan = replan(current_plan[i + 1:], results, tools)
    
    return results

def check_if_adjustment_needed(remaining_steps, results_so_far):
    """Ask the agent if the plan needs adjustment."""
    
    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=256,
        messages=[{
            "role": "user",
            "content": f"""Given these results: {results_so_far}

And these remaining steps: {remaining_steps}

Should we adjust the plan? Answer yes or no, with brief reasoning."""
        }]
    )
    
    answer = response.content[0].text.lower()
    return "yes" in answer

This creates a feedback loop. The agent executes a step, evaluates whether the plan still makes sense, and adjusts if needed. It's like driving with GPS. The GPS gives you a route, but if you miss a turn or encounter road construction, it recalculates.

Bringing It Together: A Complete Example

Let's see a full execution cycle for our weekend getaway assistant. We'll use the plan from the previous chapter and execute it with all the error handling and flexibility we've discussed.

In[10]:
Code
## Using Claude Sonnet 4.5 for end-to-end plan execution
import os
from anthropic import Anthropic
import json

client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

## Define our tools (simplified for illustration)
tools = [
    {
        "name": "search_destinations",
        "description": "Find destinations within specified travel time",
        "input_schema": {
            "type": "object",
            "properties": {
                "max_hours": {"type": "number"},
                "origin": {"type": "string"}
            }
        }
    },
    {
        "name": "search_hotels",
        "description": "Search for available hotels in a city",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {"type": "string"},
                "check_in": {"type": "string"},
                "check_out": {"type": "string"}
            }
        }
    }
]

def execute_complete_plan(user_request):
    """Full plan-and-execute cycle."""
    
    # Step 1: Create the plan (from previous chapter)
    plan_response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": f"""Create a step-by-step plan for: {user_request}

List each step clearly."""
        }]
    )
    
    plan_text = plan_response.content[0].text
    print(f"Plan created:\n{plan_text}\n")
    
    # Step 2: Execute each step
    print("Beginning execution...\n")
    
    results = []
    messages = [{
        "role": "user",
        "content": f"Execute this plan step by step:\n{plan_text}"
    }]
    
    # Execute until complete
    while True:
        response = client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=2048,
            tools=tools,
            messages=messages
        )
        
        # Add assistant response to conversation
        messages.append({
            "role": "assistant",
            "content": response.content
        })
        
        # Check if agent wants to use a tool
        if response.stop_reason == "tool_use":
            # Find the tool use block
            tool_use = next(
                block for block in response.content 
                if block.type == "tool_use"
            )
            
            print(f"Using tool: {tool_use.name}")
            
            # Simulate tool execution (in real code, call actual APIs)
            tool_result = simulate_tool_call(tool_use.name, tool_use.input)
            
            # Add tool result to conversation
            messages.append({
                "role": "user",
                "content": [{
                    "type": "tool_result",
                    "tool_use_id": tool_use.id,
                    "content": json.dumps(tool_result)
                }]
            })
            
        elif response.stop_reason == "end_turn":
            # Agent is done
            final_response = next(
                block.text for block in response.content 
                if hasattr(block, "text")
            )
            print(f"\nFinal result:\n{final_response}")
            break
    
    return final_response

## Example usage
result = execute_complete_plan(
    "Plan a weekend getaway within 3 hours of San Francisco"
)

When you run this, you'll see the agent working through its plan step by step. It might produce output like this:

Plan created:

1. Search for destinations within 3 hours of San Francisco
2. Check weather forecasts for top 3 destinations
3. Search for available hotels in the best option
4. Compile recommendations with activities

Beginning execution...

Using tool: search_destinations
Found destinations: Napa Valley, Lake Tahoe, Monterey

Using tool: search_hotels
Found 12 available hotels in Napa Valley

Final result:
I recommend a weekend in Napa Valley. I found several excellent hotels 
with availability, and the weather looks perfect. Here are three options 
with different price points, plus suggested wineries and restaurants to visit.

The agent moved through each step, used tools when needed, and synthesized everything into a coherent recommendation. If any step had failed (say, no hotels were available in Napa), the agent could have fallen back to the second destination on its list.

When to Re-Plan

Sometimes execution reveals that the original plan won't work. Maybe the user's requirements were unclear, or the situation changed. In these cases, the agent needs to go back to the planning phase.

Here are signs that re-planning might be necessary:

  • Multiple consecutive failures: If several steps in a row fail, the plan might be fundamentally flawed.
  • Changed requirements: The user provides new information that invalidates the plan.
  • Impossible constraints: The agent discovers that the goal can't be achieved as originally envisioned.

When re-planning, the agent should use everything it learned from the failed execution. This is valuable information. If the hotel search failed because everywhere is booked, the new plan might include alternative dates or nearby cities.

In[5]:
Code
## Using Claude Sonnet 4.5 for adaptive re-planning
def replan_if_needed(original_plan, execution_results, user_request):
    """Create a new plan if execution revealed problems."""
    
    # Analyze the execution results
    failures = [r for r in execution_results if "error" in r]
    
    if len(failures) > 2:  # Multiple failures suggest plan issues
        print("\nMultiple failures detected. Re-planning...\n")
        
        response = client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=1024,
            messages=[{
                "role": "user",
                "content": f"""Original request: {user_request}

Original plan: {original_plan}

Execution results: {execution_results}

The original plan encountered problems. Create a new plan that accounts 
for what we learned. Be specific about what to do differently."""
            }]
        )
        
        new_plan = response.content[0].text
        print(f"New plan:\n{new_plan}")
        return new_plan
    
    return original_plan

This creates a learning loop. The agent tries a plan, sees what works and what doesn't, and adjusts accordingly. Over time, with enough examples, an agent can get better at creating plans that are more likely to succeed on the first try.

Practical Considerations

As you build plan-and-execute agents, keep these principles in mind:

Start simple. Begin with straightforward sequential execution. Add error handling and flexibility only when you need it. A simple executor that works is better than a complex one that doesn't.

Log everything. When debugging why a plan failed, you'll want to see exactly what happened at each step. Log the plan, each step's input and output, any errors, and the final result.

Set timeouts. Some steps might take a long time or get stuck. Set reasonable timeouts so your agent doesn't wait forever for a response that will never come.

Consider costs. Each step might involve API calls to your language model and external services. If a plan has 20 steps, that's 20+ API calls. Sometimes it's worth combining steps or using a simpler approach.

Test edge cases. What happens if step 1 returns zero results? What if a tool returns malformed data? Your executor should handle these gracefully rather than crashing.

Looking Ahead

We now have an agent that can plan and execute multi-step tasks. It breaks down complex requests, works through them systematically, and handles problems along the way. This is a significant capability. Our personal assistant can now tackle requests that would have been impossible with simple question-answering.

But we've been assuming our agent works alone. What if we had multiple agents, each specialized in different tasks? One agent could focus on planning while another handles execution. Or different agents could work on different parts of the plan in parallel. That's the world of multi-agent systems, which we'll explore in the next chapter.

For now, try building a plan-and-execute agent for a domain you care about. Maybe it's a research assistant that plans and executes literature reviews, or a personal finance agent that plans and executes budget analyses. The pattern is the same: break it down, execute step by step, and stay flexible.

Glossary

Execution: The process of carrying out each step in a plan, using available tools and resources to accomplish the intended goal.

Sequential Execution: Performing plan steps one after another in order, where each step can build on the results of previous steps.

Retry Logic: A strategy for handling failures by attempting a failed operation multiple times before giving up or trying an alternative approach.

Graceful Degradation: The ability of a system to continue operating in a limited capacity when parts of it fail, rather than crashing completely.

Re-planning: The process of creating a new plan when execution reveals that the original plan won't work or needs significant adjustment.

Feedback Loop: A cycle where the results of actions inform future decisions, allowing the agent to learn and adapt during execution.

Context Propagation: Passing the results and information from earlier steps to later steps so the agent maintains awareness of what has happened so far.

Quiz

Ready to test your understanding? Take this quick quiz to reinforce what you've learned about plan execution in AI agents.

Loading component...

Reference

BIBTEXAcademic
@misc{planandexecuteturningagentplansintoactionwitherrorhandlingflexibility, author = {Michael Brenndoerfer}, title = {Plan and Execute: Turning Agent Plans into Action with Error Handling & Flexibility}, year = {2025}, url = {https://mbrenndoerfer.com/writing/plan-and-execute-ai-agents}, organization = {mbrenndoerfer.com}, note = {Accessed: 2025-12-25} }
APAAcademic
Michael Brenndoerfer (2025). Plan and Execute: Turning Agent Plans into Action with Error Handling & Flexibility. Retrieved from https://mbrenndoerfer.com/writing/plan-and-execute-ai-agents
MLAAcademic
Michael Brenndoerfer. "Plan and Execute: Turning Agent Plans into Action with Error Handling & Flexibility." 2025. Web. 12/25/2025. <https://mbrenndoerfer.com/writing/plan-and-execute-ai-agents>.
CHICAGOAcademic
Michael Brenndoerfer. "Plan and Execute: Turning Agent Plans into Action with Error Handling & Flexibility." Accessed 12/25/2025. https://mbrenndoerfer.com/writing/plan-and-execute-ai-agents.
HARVARDAcademic
Michael Brenndoerfer (2025) 'Plan and Execute: Turning Agent Plans into Action with Error Handling & Flexibility'. Available at: https://mbrenndoerfer.com/writing/plan-and-execute-ai-agents (Accessed: 12/25/2025).
SimpleBasic
Michael Brenndoerfer (2025). Plan and Execute: Turning Agent Plans into Action with Error Handling & Flexibility. https://mbrenndoerfer.com/writing/plan-and-execute-ai-agents
Direct link:
https://mbrenndoerfer.com/writing/plan-and-execute-ai-agents