Planning & Task Decomposition

An agent that picks each step as it goes adapts well and tends to wander. Planning has it lay out the steps first. Used well, planning cuts steps and mistakes; used on every task, it adds a slow, costly stage that simple tasks never needed.

Two ways to control an agent

ReAct (reason and act) has the model write a short thought before each action: think, act, observe, repeat. Each step uses the latest information, which is good when the path depends on what you find. With no overall plan, though, it can wander or lose the thread on long tasks.

Plan-and-execute has the model write the whole plan first ("1. get X, 2. use X to work out Y, 3. format Z") and then carry it out. It's more direct and often uses fewer calls on multi-step tasks, because it isn't rethinking the whole strategy every turn. The risk is that a plan made before you know what you'll find can be wrong, and following a wrong plan closely fails badly.

The trade-off, measured

On 30 multi-step research tasks, the two patterns split cleanly. On structured tasks with known sub-steps, like comparing four products on price, rating and shipping, plan-and-execute averaged 5.1 steps against ReAct's 7.8. On discovery tasks, where step 2 depends on a surprise in step 1, fixed plans went stale: plan-and-execute succeeded 61% of the time and ReAct 84%. Neither wins everywhere. A good middle path is to plan first and replan whenever a result makes the plan wrong.

Decomposition also keeps context small

Splitting a big task into named sub-tasks helps with more than ordering. Each sub-task can run with only the context it needs and pass forward a short result, instead of one long conversation carrying every intermediate output. That's the same fight against growing context that the next chapter covers from another angle.

Starter code

TASK = "Compare 3 laptops on price, rating, and weight, then pick the best value."

# Mock world: 3 lookups exist; the "answer" needs all three then a decision.
DATA = {"A":{"price":900,"rating":4.4,"weight":1.3},
        "B":{"price":1100,"rating":4.6,"weight":1.1},
        "C":{"price":800,"rating":4.1,"weight":1.5}}

def react_steps():
    # ReAct re-decides each turn: look up A, think, look up B, think, look up C,
    # think, then decide -> ~7 model calls (one per thought+act, plus final).
    return 7

def plan_steps():
    # Plan-and-execute: 1 planning call enumerates "look up A,B,C then decide",
    # then executes them without re-deciding strategy -> ~5 model calls.
    return 5

# TODO: if USE_REAL_API, implement both for real with the Anthropic SDK:
#   ReAct: loop with a "think then act" system prompt.
#   Plan:  first call returns a JSON list of steps; execute each.
# Then print the two counts and the ratio.

r, p = react_steps(), plan_steps()
print(f"react {r} steps, plan {p} steps  (plan/react = {p/r:.2f})")
# => react 7 steps, plan 5 steps  (plan/react = 0.71)

# Live version sketch (plan-and-execute):
# plan = client.messages.parse(model="claude-opus-4-8", max_tokens=400,
#          messages=[{"role":"user","content":f"List the steps to: {TASK}"}],
#          output_format=Plan).parsed_output    # Plan: list[str]
# for step in plan.steps: execute(step)         # no strategy re-derivation