sequential-thinking

Use when complex problems require systematic step-by-step reasoning with ability to revise thoughts, branch into alternative approaches, or dynamically adjust scope. Ideal for multi-stage analysis, design planning, problem decomposition, or tasks with initially unclear scope.

⭐1.1kstars🔀227forks📁View on GitHub🕐Updated Dec 30, 2025

When & Why to Use This Skill

Sequential Thinking is a specialized Claude skill designed for systematic problem-solving and complex reasoning. It enables an iterative approach to analysis, allowing the agent to decompose intricate problems into manageable steps, revise previous thoughts based on new insights, and explore alternative reasoning branches. This skill is essential for architecture design, technical planning, and navigating tasks with ambiguous or evolving scopes, ensuring a rigorous and transparent thought process.

Use Cases

  • Software Architecture Design: Systematically decomposing high-level system requirements into detailed technical components and evaluating various architectural patterns.
  • Complex Debugging & Troubleshooting: Tracing intricate software issues through multiple layers of logic by branching into different diagnostic hypotheses and revising conclusions as data is uncovered.
  • Strategic Project Planning: Breaking down large-scale, ambiguous projects into sequential milestones and adjusting the total scope dynamically as the problem becomes better understood.
  • In-depth Analytical Research: Conducting multi-stage investigations where initial findings require the revision of earlier assumptions or the exploration of alternative theoretical paths.
namesequential-thinking
descriptionUse when complex problems require systematic step-by-step reasoning with ability to revise thoughts, branch into alternative approaches, or dynamically adjust scope. Ideal for multi-stage analysis, design planning, problem decomposition, or tasks with initially unclear scope.
licenseMIT

Sequential Thinking

Enables structured problem-solving through iterative reasoning with revision and branching capabilities.

Core Capabilities

  • Iterative reasoning: Break complex problems into sequential thought steps
  • Dynamic scope: Adjust total thought count as understanding evolves
  • Revision tracking: Reconsider and modify previous conclusions
  • Branch exploration: Explore alternative reasoning paths from any point
  • Maintained context: Keep track of reasoning chain throughout analysis

When to Use

Use mcp__reasoning__sequentialthinking when:

  • Problem requires multiple interconnected reasoning steps
  • Initial scope or approach is uncertain
  • Need to filter through complexity to find core issues
  • May need to backtrack or revise earlier conclusions
  • Want to explore alternative solution paths

Don't use for: Simple queries, direct facts, or single-step tasks.

Basic Usage

The MCP tool mcp__reasoning__sequentialthinking accepts these parameters:

Required Parameters

  • thought (string): Current reasoning step
  • nextThoughtNeeded (boolean): Whether more reasoning is needed
  • thoughtNumber (integer): Current step number (starts at 1)
  • totalThoughts (integer): Estimated total steps needed

Optional Parameters

  • isRevision (boolean): Indicates this revises previous thinking
  • revisesThought (integer): Which thought number is being reconsidered
  • branchFromThought (integer): Thought number to branch from
  • branchId (string): Identifier for this reasoning branch

Workflow Pattern

1. Start with initial thought (thoughtNumber: 1)
2. For each step:
   - Express current reasoning in `thought`
   - Estimate remaining work via `totalThoughts` (adjust dynamically)
   - Set `nextThoughtNeeded: true` to continue
3. When reaching conclusion, set `nextThoughtNeeded: false`

Simple Example

// First thought
{
  thought: "Problem involves optimizing database queries. Need to identify bottlenecks first.",
  thoughtNumber: 1,
  totalThoughts: 5,
  nextThoughtNeeded: true
}

// Second thought
{
  thought: "Analyzing query patterns reveals N+1 problem in user fetches.",
  thoughtNumber: 2,
  totalThoughts: 6, // Adjusted scope
  nextThoughtNeeded: true
}

// ... continue until done

Advanced Features

For revision patterns, branching strategies, and complex workflows, see:

Tips

  • Start with rough estimate for totalThoughts, refine as you progress
  • Use revision when assumptions prove incorrect
  • Branch when multiple approaches seem viable
  • Express uncertainty explicitly in thoughts
  • Adjust scope freely - accuracy matters less than progress visibility