Agent Planning vs Reactive Execution in Python: Full Example

This is the full educational implementation of the example from the article How an Agent Decides What to Do Next (Planning vs Reactive).

If you haven't read the article yet, start there. Here the focus is only on the code and behavior of the two strategies.

What this example demonstrates

How the same task is executed with two approaches: Planning and Reactive
How a planning agent first builds a plan, then rebuilds it on failure
How a reactive agent chooses the next action after each result
Why reactive is usually more resilient to flakes, while planning is simpler to control

Project structure

TEXT

foundations/
└── planning-vs-reactive/
    └── python/
        ├── main.py             # runs both strategies and compares results
        ├── llm.py              # simple decision layer: plan / replan / next action
        ├── planning_agent.py   # agent with a pre-built plan
        ├── reactive_agent.py   # agent acting based on current situation
        ├── tools.py            # tools + deterministic flake for learning
        └── requirements.txt

tools.py intentionally includes a controlled (deterministic) failure so the difference between approaches is reproducible in every run.

How to run

1. Clone the repository and go to the folder:

BASH

git clone https://github.com/AgentPatterns-tech/agentpatterns.git
cd foundations/planning-vs-reactive/python

2. Install dependencies (this example has no external packages):

BASH

pip install -r requirements.txt

3. Run the comparison:

BASH

python main.py

What we build in code

We create two robots and give them the same task.

the first robot builds a plan first and then follows it
the second robot decides the next step during execution
if something breaks, we observe who adapts faster

This is like two trips: one follows a pre-made map, the other navigates on the road.

Code

`tools.py` — tools with deterministic flake

PYTHON

from typing import Any


def make_initial_state(user_id: int) -> dict[str, Any]:
    # Deterministic flake config for teaching: orders fails once, then succeeds.
    return {
        "user_id": user_id,
        "_flaky": {
            "orders_failures_left": 1,
            "balance_failures_left": 0,
        },
    }


def fetch_profile(state: dict[str, Any]) -> dict[str, Any]:
    user_id = state["user_id"]
    return {
        "profile": {
            "user_id": user_id,
            "name": "Anna",
            "tier": "pro",
        }
    }


def fetch_orders(state: dict[str, Any]) -> dict[str, Any]:
    flaky = state["_flaky"]
    if flaky["orders_failures_left"] > 0:
        flaky["orders_failures_left"] -= 1
        return {"error": "orders_api_timeout"}

    return {
        "orders": [
            {"id": "ord-1001", "total": 49.9, "status": "paid"},
            {"id": "ord-1002", "total": 19.0, "status": "shipped"},
        ]
    }


def fetch_balance(state: dict[str, Any]) -> dict[str, Any]:
    flaky = state["_flaky"]
    if flaky["balance_failures_left"] > 0:
        flaky["balance_failures_left"] -= 1
        return {"error": "billing_api_unavailable"}

    return {"balance": {"currency": "USD", "value": 128.4}}


def build_summary(state: dict[str, Any]) -> dict[str, Any]:
    profile = state.get("profile")
    orders = state.get("orders")
    balance = state.get("balance")

    if not profile or not orders or not balance:
        return {"error": "not_enough_data_for_summary"}

    text = (
        f"User {profile['name']} ({profile['tier']}) has "
        f"{len(orders)} recent orders and balance {balance['value']} {balance['currency']}."
    )
    return {"summary": text}

`llm.py` — simple educational decision layer

PYTHON

from typing import Any


DEFAULT_PLAN = ["fetch_profile", "fetch_orders", "fetch_balance", "build_summary"]


def create_plan(task: str) -> list[str]:
    # Learning version: fixed starter plan keeps behavior easy to reason about.
    _ = task
    return DEFAULT_PLAN.copy()


def replan(task: str, state: dict[str, Any], failed_step: str, error: str) -> list[str]:
    # Learning version: rebuild plan from missing data in state.
    _ = task, failed_step, error
    remaining: list[str] = []

    if "profile" not in state:
        remaining.append("fetch_profile")
    if "orders" not in state:
        remaining.append("fetch_orders")
    if "balance" not in state:
        remaining.append("fetch_balance")
    if "summary" not in state:
        remaining.append("build_summary")

    return remaining


def choose_next_action(task: str, state: dict[str, Any]) -> str:
    # Learning version: one-step-at-a-time policy driven by current state.
    _ = task

    if "profile" not in state:
        return "fetch_profile"

    # If orders just failed, fetch other missing data first.
    if state.get("last_error") == "orders_api_timeout" and "balance" not in state:
        return "fetch_balance"

    if "orders" not in state:
        return "fetch_orders"
    if "balance" not in state:
        return "fetch_balance"
    return "build_summary"

llm.py here does not call an external API. This is an intentional simplification for learning: it is easier to see the difference between planning and reactive.

`planning_agent.py` — plan first, execute second

PYTHON

from typing import Any

from llm import create_plan, replan
from tools import build_summary, fetch_balance, fetch_orders, fetch_profile, make_initial_state

TOOLS = {
    "fetch_profile": fetch_profile,
    "fetch_orders": fetch_orders,
    "fetch_balance": fetch_balance,
    "build_summary": build_summary,
}


def run_planning_agent(task: str, user_id: int, max_steps: int = 8) -> dict[str, Any]:
    state = make_initial_state(user_id)
    plan = create_plan(task)
    trace: list[str] = [f"Initial plan: {plan}"]

    step = 0
    while plan and step < max_steps:
        action = plan.pop(0)
        step += 1
        trace.append(f"[{step}] action={action}")

        tool = TOOLS.get(action)
        if not tool:
            trace.append(f"unknown_action={action}")
            state["last_error"] = f"unknown_action:{action}"
            continue

        result = tool(state)
        trace.append(f"result={result}")

        if "error" in result:
            state["last_error"] = result["error"]
            trace.append("planning: replan after failure")
            plan = replan(task, state, failed_step=action, error=result["error"])
            trace.append(f"new_plan={plan}")
            continue

        state.update(result)
        state.pop("last_error", None)

        if "summary" in state:
            return {"mode": "planning", "done": True, "steps": step, "state": state, "trace": trace}

    return {"mode": "planning", "done": False, "steps": step, "state": state, "trace": trace}

A planning agent makes a strategic decision upfront and only switches to replanning on failure.

`reactive_agent.py` — decision at each step

PYTHON

from typing import Any

from llm import choose_next_action
from tools import build_summary, fetch_balance, fetch_orders, fetch_profile, make_initial_state

TOOLS = {
    "fetch_profile": fetch_profile,
    "fetch_orders": fetch_orders,
    "fetch_balance": fetch_balance,
    "build_summary": build_summary,
}


def run_reactive_agent(task: str, user_id: int, max_steps: int = 8) -> dict[str, Any]:
    state = make_initial_state(user_id)
    trace: list[str] = []

    for step in range(1, max_steps + 1):
        if "summary" in state:
            return {"mode": "reactive", "done": True, "steps": step - 1, "state": state, "trace": trace}

        action = choose_next_action(task, state)
        trace.append(f"[{step}] action={action}")

        tool = TOOLS.get(action)
        if not tool:
            trace.append(f"unknown_action={action}")
            state["last_error"] = f"unknown_action:{action}"
            continue

        result = tool(state)
        trace.append(f"result={result}")

        if "error" in result:
            state["last_error"] = result["error"]
            continue

        state.update(result)
        state.pop("last_error", None)

    return {"mode": "reactive", "done": False, "steps": max_steps, "state": state, "trace": trace}

A reactive agent does not stick to an initial plan. It evaluates state after each action and chooses the next step from the current state.

`main.py` — comparison of two approaches

PYTHON

from planning_agent import run_planning_agent
from reactive_agent import run_reactive_agent

TASK = "Prepare a short account summary for user_id=42 with profile, orders, and balance."
USER_ID = 42


def print_result(result: dict) -> None:
    print(f"\n=== {result['mode'].upper()} ===")
    print(f"done={result['done']} | steps={result['steps']}")
    print("summary:", result["state"].get("summary"))
    print("\ntrace:")
    for line in result["trace"]:
        print(" ", line)


def main() -> None:
    planning = run_planning_agent(task=TASK, user_id=USER_ID)
    reactive = run_reactive_agent(task=TASK, user_id=USER_ID)

    print_result(planning)
    print_result(reactive)


if __name__ == "__main__":
    main()

`requirements.txt`

TEXT

# No external dependencies for this learning example.

Example output

TEXT

=== PLANNING ===
done=True | steps=5
summary: User Anna (pro) has 2 recent orders and balance 128.4 USD.

trace:
  Initial plan: ['fetch_profile', 'fetch_orders', 'fetch_balance', 'build_summary']
  [1] action=fetch_profile
  result={'profile': {'user_id': 42, 'name': 'Anna', 'tier': 'pro'}}
  [2] action=fetch_orders
  result={'error': 'orders_api_timeout'}
  planning: replan after failure
  new_plan=['fetch_orders', 'fetch_balance', 'build_summary']
  [3] action=fetch_orders
  result={'orders': [{'id': 'ord-1001', 'total': 49.9, 'status': 'paid'}, {'id': 'ord-1002', 'total': 19.0, 'status': 'shipped'}]}
  [4] action=fetch_balance
  result={'balance': {'currency': 'USD', 'value': 128.4}}
  [5] action=build_summary
  result={'summary': 'User Anna (pro) has 2 recent orders and balance 128.4 USD.'}

=== REACTIVE ===
done=True | steps=5
summary: User Anna (pro) has 2 recent orders and balance 128.4 USD.

trace:
  [1] action=fetch_profile
  result={'profile': {'user_id': 42, 'name': 'Anna', 'tier': 'pro'}}
  [2] action=fetch_orders
  result={'error': 'orders_api_timeout'}
  [3] action=fetch_balance
  result={'balance': {'currency': 'USD', 'value': 128.4}}
  [4] action=fetch_orders
  result={'orders': [{'id': 'ord-1001', 'total': 49.9, 'status': 'paid'}, {'id': 'ord-1002', 'total': 19.0, 'status': 'shipped'}]}
  [5] action=build_summary
  result={'summary': 'User Anna (pro) has 2 recent orders and balance 128.4 USD.'}

Note: this example is made deterministic for learning.
On each run, fetch_orders fails once, so the trace is stably reproducible.

What you can see in practice

	Planning agent	Reactive agent
When steps are chosen	At start (plan)	After each action
Reaction to failure	Rebuilds the plan	Immediately chooses a new step
Predictability	Higher	Lower
Resilience to flakes	Medium	Usually higher

What to change in this example

Change orders_failures_left in make_initial_state from 1 to 2 and see how the trace changes
Add a separate limit for replan count in the planning agent
Add a rule "do not repeat the same action 3 times in a row" for the reactive agent
Set balance_failures_left = 1 and observe who recovers faster after two different failures

Full code on GitHub

The repository contains the full version of this demo: two agent strategies, shared tools, and step tracing.

View full code on GitHub ↗

Agent Planning vs Reactive Execution in Python: Full Example

What this example demonstrates

Project structure

How to run

What we build in code

Code

`tools.py` — tools with deterministic flake

`llm.py` — simple educational decision layer

`planning_agent.py` — plan first, execute second

`reactive_agent.py` — decision at each step

`main.py` — comparison of two approaches

`requirements.txt`

Example output

What you can see in practice

What to change in this example

Full code on GitHub

Used by patterns

Related failures

Governance required

Author

Editorial note

Agent Planning vs Reactive Execution in Python: Full Example

What this example demonstrates

Project structure

How to run

What we build in code

Code

tools.py — tools with deterministic flake

llm.py — simple educational decision layer

planning_agent.py — plan first, execute second

reactive_agent.py — decision at each step

main.py — comparison of two approaches

requirements.txt

Example output

What you can see in practice

What to change in this example

Full code on GitHub

Used by patterns

Related failures

Governance required

Author

Editorial note

`tools.py` — tools with deterministic flake

`llm.py` — simple educational decision layer

`planning_agent.py` — plan first, execute second

`reactive_agent.py` — decision at each step

`main.py` — comparison of two approaches

`requirements.txt`