Planning and reasoning

Nothing in a bare loop forces completeness. The model sees a question, sees a tool, makes the obvious call, and the result LOOKS like an answer - so it answers. Three forces push toward the shallow exit:

• No completeness contract - "diagnose" quietly requires compare, decompose, and explain; the bare prompt never spells that out, so one number satisfies it.
• Every extra step has a cost - more calls mean more latency and more chances to err; stopping early is locally safe and globally wrong.
• No visible trail - with no written plan, neither the agent nor you can see which sub-questions were never asked. Anthropic's transparency principle exists precisely to make the gap visible.

Two words that get blurred:

• Reasoning is the model thinking inside one turn - b1's Thought in the T-A-O cycle. Every capable model does some of it unprompted.
• Planning is structure ACROSS turns - a declared set of steps the loop then executes and checks off. It lives in your code and prompts, not just in the model's head.

That is why planning is a lever you engineer, not a capability you hope for: the same model that one-shots a diagnosis will follow a four-step plan faithfully once the loop demands one.

ReAct is b1's Thought → Action → Observation cycle made explicit: the agent must WRITE a thought before every tool call - "I have March, now I need February to compare" - instead of silently jumping to the next action. The lightest planning there is, and it is already in your b2 loop if your system prompt demands a reasoning line before each call. The payoff is the trail: when a run goes wrong, the written thoughts show you exactly where it stopped thinking.

Ask for the whole plan up front - a numbered list of steps - then execute the steps one by one, re-planning only when a result surprises you. The plan is the completeness contract: the run is not done until every step is. This is tonight's build (code below), and it is the technique that unlocks rung 3.

Ng's Module 2 pattern: the agent drafts an answer, then critiques its own draft against the task ("does this name a CAUSE for the dip, or just restate the number?"), then revises. You already met its inner move in b3 - reflection is exactly what the evaluator-optimizer workflow does, with the evaluator turned inward. Cheap to add: one extra model call after the synthesis step.

Plans fail at the seams, so cut carefully:

• A good subtask = one tool call or one judgment. "Get February revenue" is one call. "Explain the gap" is one judgment. "Investigate revenue" is neither - split it.
• Each step should produce a checkable artifact - a number, a list, a yes/no - so the loop can tell done from not-done.
• End with an explicit synthesis step that consumes the artifacts. The one-shot failure is really a missing synthesis step.
• Prefer 3-6 steps. Ten-step plans go stale by step four; re-planning on surprise beats over-planning up front.

Two phases. The first messages.create call asks ONLY for a JSON plan - no tools, no answers. Then a loop feeds each step to your b2 agent loop, appending results as it goes, and closes with a synthesis:

import json
from anthropic import Anthropic

client = Anthropic()

def plan_then_execute(goal, tools):
    # Phase 1: plan only - no tools, no answering
    plan = client.messages.create(
        model="claude-opus-5",
        max_tokens=800,
        system=("Return ONLY a JSON plan for the task: "
                '{"steps": ["..."]}. Each step must be one '
                "tool call or one judgment. End with a synthesis step."),
        messages=[{"role": "user", "content": goal}],
    )
    steps = json.loads(plan.content[0].text)["steps"]

    # Phase 2: execute each step through the b2 loop
    messages = [{"role": "user", "content": goal}]
    for i, step in enumerate(steps, 1):
        messages.append({"role": "user",
            "content": f"Plan step {i}/{len(steps)}: {step}"})
        result = run_loop(messages, tools)  # your b2 loop, unchanged
        messages.append({"role": "assistant", "content": result})

    messages.append({"role": "user",
        "content": "All steps done. Synthesize the final answer "
                   "using only the results above."})
    return run_loop(messages, tools)

Re-planning on surprise is one more branch: if a step's result contradicts the plan's assumption, feed the plan plus the surprise back to phase 1 and ask for a revised remainder. Print the plan before executing - that single print IS Anthropic's transparency principle in practice.