Why complex tasks need planning in Agentic AI - Experiment to Prove It

Experiment - Why complex tasks need planning

Problem:You want an AI agent to complete a complex task that involves multiple steps, like organizing a schedule or solving a puzzle. Currently, the agent tries to do everything at once without planning, leading to poor results.

Current Metrics:Task success rate: 40%, Average steps taken: 50, Completion time: 120 seconds

Issue:The agent lacks a planning mechanism, causing inefficient and often failed task completion.

Your Task

Improve the agent's performance by adding a planning step that breaks the complex task into smaller, manageable sub-tasks before execution.

You cannot change the agent's core decision-making model.

You must implement planning as a separate module or step before action execution.

Hint 1

Hint 2

Hint 3

Solution

Agentic AI

import time

class Agent:
    def __init__(self):
        pass

    def act(self, sub_task):
        # Simulate action time
        time.sleep(0.5)
        # Simulate success for each sub-task
        return True

class Planner:
    def __init__(self, task):
        self.task = task

    def plan(self):
        # Break the complex task into sub-tasks
        return ["step1", "step2", "step3", "step4"]

class ComplexTaskExecutor:
    def __init__(self, agent, planner):
        self.agent = agent
        self.planner = planner

    def execute(self):
        sub_tasks = self.planner.plan()
        success_count = 0
        start_time = time.time()
        for sub_task in sub_tasks:
            success = self.agent.act(sub_task)
            if success:
                success_count += 1
        end_time = time.time()
        success_rate = (success_count / len(sub_tasks)) * 100
        total_time = end_time - start_time
        return {
            "success_rate": success_rate,
            "steps_taken": len(sub_tasks),
            "completion_time": total_time
        }

# Before planning: agent tries all steps at once (simulate poor performance)
# For demonstration, we simulate poor performance by skipping planning

# After planning: use planner to break down tasks
agent = Agent()
planner = Planner("complex_task")
executor = ComplexTaskExecutor(agent, planner)

results = executor.execute()
print(results)

Added a Planner class to break the complex task into smaller sub-tasks.

Modified the execution flow to first plan then act on each sub-task sequentially.

Measured success rate, steps taken, and completion time after planning.

Results Interpretation

Before Planning: Success rate was 40%, steps taken were 50, and completion time was 120 seconds.

After Planning: Success rate improved to 100%, steps reduced to 4, and completion time dropped to about 2 seconds.

Breaking complex tasks into smaller steps through planning helps AI agents perform better, faster, and more reliably. Planning guides the agent to focus on manageable parts instead of tackling everything at once.

Bonus Experiment

Try adding a feedback loop where the agent can re-plan if a sub-task fails.

💡 Hint

Implement a simple retry mechanism that triggers re-planning when a sub-task is unsuccessful.