Plan-and-execute pattern in Agentic AI

Introduction

The plan-and-execute pattern helps AI break big tasks into smaller steps and then finish them one by one. This makes solving problems easier and clearer.

When you want an AI to solve a complex problem step-by-step, like planning a trip.

When an AI needs to organize tasks before doing them, like cooking a recipe.

When you want to improve AI's thinking by making it plan first, then act.

When teaching AI to handle multi-step instructions clearly.

When debugging AI decisions by checking its plan before execution.

Syntax

Agentic AI

plan = agent.create_plan(task_description)
for step in plan:
    result = agent.execute(step)
    if result == 'failure':
        agent.adjust_plan()
        break

The plan is a list of smaller steps created from the big task.

The agent executes each step in order and can adjust if something goes wrong.

Examples

The agent plans how to make a sandwich and then follows each step.

Agentic AI

plan = agent.create_plan('Make a sandwich')
for step in plan:
    agent.execute(step)

The agent writes a story step-by-step and fixes the plan if it hits an error.

Agentic AI

plan = agent.create_plan('Write a short story')
for step in plan:
    result = agent.execute(step)
    if result == 'error':
        agent.adjust_plan()

Sample Model

This simple agent plans how to make tea and executes each step, printing what it does. It checks for success and can adjust if needed.

Agentic AI

class SimpleAgent:
    def create_plan(self, task):
        if task == 'Make tea':
            return ['Boil water', 'Add tea leaves', 'Pour water', 'Steep tea', 'Serve tea']
        return []

    def execute(self, step):
        print(f'Executing: {step}')
        return 'success'

    def adjust_plan(self):
        print('Adjusting plan due to failure')

agent = SimpleAgent()
task = 'Make tea'
plan = agent.create_plan(task)
for step in plan:
    result = agent.execute(step)
    if result != 'success':
        agent.adjust_plan()
        break

Important Notes

Planning first helps AI avoid mistakes by thinking ahead.

Execution follows the plan step-by-step, making the process clear.

If a step fails, the agent can change the plan to fix problems.

Summary

The plan-and-execute pattern breaks big tasks into smaller steps.

AI plans first, then does each step carefully.

This method helps AI solve complex problems clearly and safely.

Practice

1. What is the main idea behind the plan-and-execute pattern in agentic AI?

easy

A. Execute the whole task at once without planning

B. Randomly try different actions until one works

C. Break a big task into smaller steps and do them one by one

D. Only plan without doing any steps

Solution

1. Step 1: Understand the pattern purpose

   The plan-and-execute pattern is designed to handle big tasks by dividing them into smaller, manageable steps.

2. Step 2: Match the description to options

   Break a big task into smaller steps and do them one by one clearly states breaking a big task into smaller steps and doing them one by one, which matches the pattern.

3. Final Answer:

   Break a big task into smaller steps and do them one by one -> Option C

4. Quick Check:

   Plan-and-execute = break big task into steps [OK]

Hint: Think: big task needs small steps first [OK]

Common Mistakes:

• Confusing planning with skipping execution
• Thinking AI acts randomly without plan
• Believing the task is done all at once

2. Which of these code snippets correctly shows the start of a plan-and-execute loop in Python?

easy

A. execute(plan)
for step in plan:

B. while plan:
execute(plan)

C. if plan:
execute(plan)

D. for step in plan:
execute(step)

Solution

1. Step 1: Identify correct loop structure for steps

   The plan is a list of steps, so we loop over each step with for step in plan:.

2. Step 2: Check execution inside loop

   Inside the loop, each step is executed with execute(step), matching the pattern.

3. Final Answer:

   for step in plan: execute(step) -> Option D

4. Quick Check:

   Loop over steps then execute each [OK]

Hint: Loop over plan steps, then execute each [OK]

Common Mistakes:

• Using while without updating plan
• Executing whole plan at once
• Incorrect loop syntax or order

3. Given this code snippet using plan-and-execute pattern:

plan = ['step1', 'step2', 'step3']
results = []
for step in plan:
    results.append(f"done {step}")
print(results)

What is the output?

medium

A. ['step1', 'step2', 'step3']

B. ['done step1', 'done step2', 'done step3']

C. ['done step3']

D. Error: append not defined

Solution

1. Step 1: Understand the loop and append

   The loop goes through each step in plan and appends the string 'done ' plus the step name to results.

2. Step 2: Trace the results list after loop

   After all steps, results contains ['done step1', 'done step2', 'done step3'].

3. Final Answer:

   ['done step1', 'done step2', 'done step3'] -> Option B

4. Quick Check:

   Each step marked done in list [OK]

Hint: Append 'done' + step for each plan item [OK]

Common Mistakes:

• Confusing original steps with done steps
• Thinking only last step is appended
• Assuming append causes error

4. This code tries to implement plan-and-execute but has a bug:

plan = ['step1', 'step2']
for step in plan:
    execute(step)
    plan.remove(step)

What is the main problem?

medium

A. Modifying the plan list while looping causes skipping steps

B. The execute function is not defined

C. The loop should be a while loop

D. There is no problem; code works fine

Solution

1. Step 1: Analyze loop and list modification

   The code removes items from the plan list while looping over it, which changes the list size and order during iteration.

2. Step 2: Understand effect on iteration

   Removing items causes the loop to skip some steps because the list indices shift unexpectedly.

3. Final Answer:

   Modifying the plan list while looping causes skipping steps -> Option A

4. Quick Check:

   Changing list during loop skips items [OK]

Hint: Never change list while looping over it [OK]

Common Mistakes:

• Thinking execute is missing
• Believing while loop fixes skipping
• Ignoring list modification effects

5. You want an AI to plan and execute cleaning a house room by room. Which approach best uses the plan-and-execute pattern safely and clearly?

hard

A. Create a list of rooms, plan = ['kitchen', 'bathroom', 'bedroom'], then loop: for room in plan: clean(room)

B. Start cleaning randomly without a plan, hoping all rooms get cleaned

C. Plan all rooms but clean only the first one repeatedly

D. Clean the whole house at once without breaking into rooms

Solution

1. Step 1: Identify safe planning method

   Breaking the big task (clean house) into smaller steps (clean each room) is safe and clear.

2. Step 2: Match approach to plan-and-execute pattern

   Create a list of rooms, plan = ['kitchen', 'bathroom', 'bedroom'], then loop: for room in plan: clean(room) creates a plan list of rooms and executes cleaning each room in order, matching the pattern well.

3. Final Answer:

   Create a list of rooms, plan = ['kitchen', 'bathroom', 'bedroom'], then loop: for room in plan: clean(room) -> Option A

4. Quick Check:

   Plan rooms, then clean each step [OK]

Hint: Plan rooms first, then clean one by one [OK]

Common Mistakes:

• Skipping planning and acting randomly
• Repeating same step only
• Trying to do all at once without steps