home / skills / mamba-mental / agent-skill-manager / sequential-thinking

sequential-thinking skill

safe

This skill enables structured, iterative reasoning with revision and branching to solve complex problems and refine solutions over multiple steps.

This is most likely a fork of the sequential-thinking skill from linehaul-ai

npx playbooks add skill mamba-mental/agent-skill-manager --skill sequential-thinking

Review the files below or copy the command above to add this skill to your agents.

Files (4)

SKILL.md

3.1 KB

---
name: sequential-thinking
description: 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.
license: MIT
---

# 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

```typescript
// 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:
- [Advanced Usage](references/advanced.md) - Revision and branching patterns
- [Examples](references/examples.md) - Real-world use cases

## 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

Overview

This skill enables structured, step-by-step reasoning for complex problems that require iteration, revision, and branching. It guides a reasoning agent to decompose tasks into numbered thoughts, adjust scope as understanding evolves, and maintain a coherent chain of context. Use it to make multi-stage analysis transparent and trackable.

How this skill works

The skill accepts a current thought, a step number, and an estimated total number of thoughts, then signals whether further reasoning is needed. It supports optional flags to mark revisions, indicate which prior thought is being reconsidered, and create branches from any step with a branch identifier. The agent updates the totalThoughts value dynamically and continues or terminates the sequence by toggling nextThoughtNeeded.

When to use it

Multi-stage analysis that must be decomposed into sequential steps
Problems with uncertain initial scope or evolving requirements
Situations where you may need to backtrack and revise earlier conclusions
When exploring alternative solution paths in parallel
Design planning, complex debugging, or hierarchical problem decomposition

Best practices

Begin with a rough estimate for totalThoughts and refine as you progress
Number each thought sequentially and keep each step focused and concise
Use isRevision and revisesThought to clearly mark and document changes to prior reasoning
Create branchId and branchFromThought when exploring alternate approaches to preserve the mainline chain
Express uncertainty explicitly within thoughts to make later review and revision easier

Example use cases

Designing a multi-phase system architecture while comparing trade-offs across components
Debugging an intermittent issue by decomposing reproduction steps, hypotheses, and tests
Planning a research or feature roadmap that requires staged analysis and frequent scope adjustments
Evaluating competing algorithms by branching separate reasoning paths from a common assumption
Iteratively optimizing database or query strategies where new findings change next steps

FAQ

How do I stop the reasoning sequence?

Set nextThoughtNeeded to false on the current thought; the agent treats that step as the conclusion of this sequence.

When should I use a branch versus a revision?

Use a revision to alter or correct an earlier step in the same line of reasoning. Use a branch when you want to explore an alternative approach without overwriting the original chain.