Task Decomposition Prompt

The core instruction explicitly commands the model to decompose or break down the primary task. This leverages the model's latent reasoning capabilities by providing a clear procedural framework.

• Directive Examples: "First, break this problem into steps.", "Outline the sequential tasks required.", "Generate a step-by-step plan."
• Mechanism: This instruction acts as a meta-cognitive trigger, prompting the model to engage its internal planning modules rather than attempting a single, monolithic generation.
• Outcome: Transforms an open-ended query into a structured execution plan, making the model's reasoning traceable and its outputs more reliable for downstream systems.

A task decomposition prompt mandates a specific output structure for the list of subtasks, such as a numbered list, a markdown checklist, or a JSON array. This enforces deterministic formatting for programmatic consumption.

• Common Formats: 1. [Step], - [ ] [Task], {"steps": [{"id": 1, "task": "..."}]}
• Purpose: Structured output ensures consistency and allows the decomposed plan to be parsed automatically by an orchestrator or passed sequentially to other models or functions in a prompt chain.
• Integration: This feature is foundational for Agentic Cognitive Architectures, where the decomposed plan becomes the agenda for an autonomous system.

Effective decomposition prompts guide the model to create atomic subtasks—each representing a single, clear action—and to define their logical or temporal sequence.

• Atomicity: Each subtask should be independently understandable and executable. The prompt may instruct: "Ensure each step is a single, concrete action."
• Dependency: Steps should be ordered such that the output of one serves as the input for the next (e.g., "Step 2 requires the result from Step 1").
• Verification: This enables validation checkpoints between steps and is critical for implementing Recursive Error Correction loops where a failed step can be isolated and retried.

Advanced decomposition prompts instruct the model to identify the resources (data, context) and tools (APIs, functions) required for each subtask. This bridges planning with execution.

• Resource Annotation: "For each step, note what information is needed."
• Tool Calling Integration: "If a step requires calculation, specify 'use the calculator function'." This directly prepares the plan for integration with Tool Calling and API Execution frameworks like the Model Context Protocol (MCP).
• Benefit: Pre-identifying dependencies reduces runtime errors and allows for efficient context window management by fetching only necessary data per step.

The prompt can direct the model to establish verifiable completion criteria for each subtask or the overall goal. This turns the plan into a measurable process.

• Instruction Example: "For each step, define what a successful completion looks like."
• Application: These criteria become the basis for Agentic Observability and Telemetry, enabling automated evaluation of step success/failure.
• Alignment: This feature supports Evaluation-Driven Development by creating built-in, quantifiable metrics for the decomposition process itself.

Task decomposition is not an isolated technique but a component integrated into broader reasoning frameworks. Prompts are often designed to elicit Chain-of-Thought (CoT) reasoning during the decomposition phase.

• Hybrid Prompt: "Think step by step to break down the problem. First, reason about the goal. Then, list the steps."
• ReAct Pattern: In the Reasoning and Acting (ReAct) paradigm, the decomposition itself is the first 'Reason' step, producing an 'Act' plan of tool-using subtasks.
• Foundation: This makes decomposition a precursor to Multi-Agent System Orchestration, where each subtask could be assigned to a specialized agent.

A prompting technique that explicitly instructs a model to articulate its intermediate reasoning steps before delivering a final answer. It is a foundational method for achieving task decomposition.

• Mechanism: By adding phrases like "think step by step" or "let's reason through this," the model is coerced into generating a logical scaffold.
• Purpose: Significantly improves performance on arithmetic, commonsense, and symbolic reasoning tasks by making the model's internal process explicit and verifiable.
• Example: A prompt asking "If a bat and ball cost $1.10 and the bat costs $1.00 more than the ball, how much is the ball?" is far more likely to be solved correctly with a Chain-of-Thought directive.

The sequential execution of multiple, discrete prompts where the output of one prompt becomes the input for the next. This is the architectural implementation of task decomposition.

• Workflow: A complex task is broken into a pipeline: 1) Analysis Prompt → 2) Planning Prompt → 3) Execution Prompt → 4) Validation Prompt.
• Advantage: Each step can be optimized, validated, and logged independently, improving reliability and debuggability compared to a single, monolithic prompt.
• Use Case: Generating a market report might involve separate chains for data retrieval, analysis, visualization specification, and executive summary writing.

A paradigm (Reasoning + Acting) that interleaves task decomposition with external tool use. The model is prompted to generate a Thought, an Action, and then observe an Observation in a loop.

• Thought: The model's internal reasoning to decompose the problem and plan the next step ("I need to find the current weather to advise on clothing.").
• Action: The specific tool call or API request (e.g., search_weather(location="London")).
• Observation: The result returned from the tool, which feeds into the next Thought.
• Outcome: Creates a transparent, executable trace of the model's problem-solving process, tightly coupling decomposition with action.

A decomposition strategy where the model is prompted to generate code (e.g., Python) as an intermediate reasoning step. The code is then executed by an external interpreter to produce the final answer.

• Process: The prompt instructs the model to "write a program that solves this problem." The model outputs code, which is run to compute the result.
• Benefit: Offloads precise computation and symbolic manipulation to a deterministic runtime, eliminating arithmetic and logical hallucinations from the LLM's direct output.
• Example: For a logic puzzle, the LLM generates Python code with variables and constraints; executing the code yields the definitive solution.

Prompts that direct a model to critique and revise its own initial output. This introduces a recursive decomposition step focused on validation and improvement.

• Two-Phase Process: 1) Generation: Produce an initial answer. 2) Critique & Revision: Instruct the model to act as a reviewer, identify flaws (factual, logical, stylistic), and produce a refined output.
• Application: Highly effective for improving code quality, factual accuracy in summaries, and adherence to complex formatting rules. It decomposes the task into "create" and "refine" phases.

A high-level directive that governs how the model should process other instructions. It is the command that often initiates a decomposition strategy.

• Function: Sets the overarching problem-solving methodology. Examples include "think step by step," "evaluate your answer for errors before responding," or "break this problem down into sub-tasks."
• Difference from Task Instruction: While a task instruction says what to do ("write a summary"), a meta-instruction says how to do it ("first extract key points, then synthesize them concisely").
• Role in Decomposition: A meta-instruction like "generate a plan before writing the final output" explicitly triggers the decomposition process.