Chain-of-Thought Planning Prompt Template for Complex Workflows

This prompt is designed for agent orchestrators and planning modules that must convert a high-level objective into a reasoned, step-by-step execution plan. Use it when a single-pass plan generation produces shallow, incomplete, or logically inconsistent results. The prompt forces the model to externalize its reasoning trace for each step, making the plan auditable, debuggable, and verifiable before execution begins. It is appropriate for autonomous agent workflows, semi-autonomous systems with human-in-the-loop review, and any scenario where the cost of executing a bad plan exceeds the cost of generating a careful one.

The ideal user is an AI engineer or technical decision-maker building a planning module where downstream tool calls, state mutations, or multi-step data pipelines depend on a coherent plan. You must provide the model with a clear objective, a list of available tools with their capabilities and constraints, and any known environmental state. The prompt is most effective when the planning horizon is 3–15 steps and the domain has explicit dependencies, such as 'step B requires the output of step A.' Do not use this prompt for trivial single-step tasks, real-time sub-100ms decisions, or workflows where the available tools and constraints are fully unknown. In those cases, a simpler direct-action prompt or a classification router is more appropriate and cost-effective.

Before using this prompt, ensure you have a validation harness ready to check the output plan for logical consistency, step necessity, and goal alignment. The reasoning trace is a powerful debugging tool, but it also consumes significant output tokens. If your application cannot afford the latency or cost of generating a full trace, consider a lighter-weight planning prompt from the 'Plan Generation and Template Instantiation' playbook instead. Once you have confirmed this is the right prompt for your complexity level, proceed to the template and adapt the placeholders to your specific agent's toolset and risk tolerance.

This prompt template is designed to be pasted directly into your system instructions or as a user message for an agent orchestrator. It forces the model to decompose a high-level objective into a structured plan where every step includes an explicit reasoning trace. This is not a prompt for simple task lists; it is for complex workflows where the 'why' behind each step is as critical as the 'what' for downstream validation, debugging, and human review. The template uses square-bracket placeholders that you must replace with your specific context before sending.

textCopy
You are an expert planning agent. Your task is to decompose a complex objective into a reasoned, step-by-step plan. For each step, you must provide an explicit chain-of-thought that justifies its inclusion, identifies its dependencies, and explains how it contributes to the final goal.

**Objective:** [OBJECTIVE]
**Available Tools & Capabilities:** [TOOLS]
**Known Constraints:** [CONSTRAINTS]
**Success Criteria:** [SUCCESS_CRITERIA]
**Risk Level:** [RISK_LEVEL]

**Output Format:**
Produce a JSON object with the following structure. Do not include any text outside the JSON object.
{
  "plan_name": "A concise name for the plan",
  "goal_summary": "A one-sentence restatement of the objective",
  "assumptions": ["List any assumptions you are making about the environment or inputs"],
  "steps": [
    {
      "step_id": 1,
      "step_name": "Short, action-oriented name",
      "reasoning_trace": "A detailed chain-of-thought explaining: why this step is necessary, what preconditions must be met, what tool or capability will be used, what the expected output is, and how this output enables subsequent steps.",
      "dependencies": ["List of step_ids this step depends on"],
      "expected_output_schema": "A description of the expected output format or data structure",
      "fallback_on_failure": "What to do if this step fails (e.g., retry, skip, escalate, abort)"
    }
  ],
  "final_validation": "A chain-of-thought describing how to verify the final output against the success criteria."
}

To adapt this template, replace the placeholders with concrete values. [OBJECTIVE] should be a single, clear sentence. [TOOLS] should be a list of available functions, APIs, or capabilities with their descriptions. [CONSTRAINTS] must include any hard limits like time, budget, or permissions. [SUCCESS_CRITERIA] should be a measurable, verifiable condition. [RISK_LEVEL] (e.g., 'low', 'medium', 'high') should be used to adjust the verbosity of the reasoning trace and the conservatism of the fallback strategies. For high-risk workflows, ensure a human reviews the generated plan before execution begins. After receiving the output, validate the JSON structure and check that every dependency references a valid step_id to prevent execution deadlocks.

The chain-of-thought planning prompt is not a standalone artifact—it is a contract between the orchestrator and the model. The harness enforces that contract. When you wire this prompt into an application, treat the model's output as a structured plan object that must pass validation before any execution step begins. The harness should parse the reasoning trace and the plan steps separately, validate each step against the available tool set and declared constraints, and reject plans that contain hallucinated tools, circular dependencies, or steps that do not advance the goal. For high-risk workflows—such as infrastructure changes, financial transactions, or clinical actions—the harness must route the validated plan to a human approval queue before execution, not after.

A production harness for this prompt requires several concrete components. First, implement a schema validator that checks the output structure: each step must have an id, description, reasoning, expected_outcome, and depends_on field. The validator should confirm that all depends_on references resolve to existing step IDs and that the dependency graph contains no cycles. Second, implement a tool registry check that verifies every step's required capability exists in the available tool set—if a step calls deploy_to_production but the agent only has deploy_to_staging, the plan must be rejected or sent back for revision. Third, add a retry loop with a maximum of three attempts: if validation fails, feed the validation errors back into the prompt as [PREVIOUS_PLAN_ERRORS] and request a corrected plan. Fourth, log every plan—accepted, rejected, and revised—with the full reasoning trace, validation results, and the model version used. This audit trail is essential for debugging planning failures and for governance reviews. For model choice, prefer models with strong reasoning benchmarks (such as Claude 3.5 Sonnet or GPT-4o) and set temperature=0.3 or lower to reduce variance in plan structure.

The harness should also enforce a step budget to prevent the model from generating unbounded plans. Set a maximum step count (typically 10–20 for complex workflows) and reject plans that exceed it. For long-running agent sessions, pair this prompt with a progress-tracking module that updates the plan state after each step completes, feeding the current state back into a replanning prompt if the original plan becomes invalid. Do not wire this prompt directly to execution without a validation layer—plans that look coherent in the reasoning trace can still contain fatal flaws, and the harness is your last line of defense before the agent takes real action.