Sequential Thinking MCP

The 58/100 score is weighted around the server's real job: improving difficult reasoning enough to justify an extra reasoning loop. Safety is excellent, setup is easy and maintenance is active. The weaker evidence is effectiveness per token on modern reasoning models.

Sequential Thinking MCP is an official Model Context Protocol reference server that gives an AI agent a structured tool for breaking complex problems into numbered thoughts, revising earlier thoughts, branching from earlier reasoning and continuing when more analysis is needed.

The server does not provide a new model or external knowledge source. The model still performs the reasoning. Sequential Thinking supplies the structure used to externalize and organize that reasoning.

The current canonical package is @modelcontextprotocol/server-sequential-thinking. The evaluated release is 2026.8.31 and the package is MIT licensed.

Each tool call carries the current thought, its position in the reasoning sequence, an estimated total number of thoughts and whether another thought is needed. Optional fields allow the model to mark a thought as a revision or branch from an earlier step.

Numbered thoughts

thoughtNumber and totalThoughts make the sequence explicit. The total is an estimate rather than a hard limit, so the process can grow when the task proves more complex than expected.

Revision

isRevision and revisesThought let the model identify and replace an earlier assumption instead of simply appending another linear step.

Branching

branchFromThought and branchId let the model preserve an alternative path without discarding the original chain.

Dynamic continuation

needsMoreThoughts and nextThoughtNeeded allow the sequence to continue beyond the initial estimate or terminate once the model considers the reasoning complete.

It is most useful when the task benefits from explicit course correction, alternative branches or a visible multi-step reasoning state. It is less compelling when a strong model already performs the required planning and reflection natively.

The strongest use cases are complex decomposition, planning with revision, investigating alternative branches, forcing additional reflection and giving weaker models a more deliberate scaffold.

Sequential Thinking externalizes reasoning into an MCP tool. Native reasoning happens inside the model or client. The MCP adds explicit state and portability; it does not make the underlying model more knowledgeable.

Token use has two different layers. The fixed layer is the tool schema and instructions. The variable layer is the sequence of generated thoughts and repeated tool calls.

Fixed tool-schema overhead

The evaluated one-tool description is unusually long for such a small MCP. MCPVerdict estimates a fixed footprint of roughly 600–900 tokens per session, depending on client serialization and tokenizer.

Variable reasoning overhead

The dominant cost is the generated reasoning itself. A 5–10-thought sequence can add several thousand tokens, while deeper tasks can add considerably more. The exact amount depends on thought length, model behavior, client transcript handling and how often the MCP is invoked.

The context-window percentage can hide the real cost

On a 1M-token model, 10K extra reasoning is only about 1% of the window. That can look negligible, but context capacity is not the same thing as economic efficiency. Those tokens can still increase API cost, quota consumption, latency and the amount of prior conversation that must remain active.

The MCP server itself costs $0. It has no required paid API, OAuth service, hosted database or subscription. The practical cost is the additional model usage produced by the reasoning loop.

Two reference calculations are shown below. 10K extra output approximates a thought-heavy sequence. 20K input + 8K output is the evaluation budget used by MCPVerdict for a five-task A/B test. Prices are standard short-context API prices checked on September 27, 2026.

Pricing/context sources checked Sep 27, 2026: OpenAI model and pricing documentation; Anthropic Claude model pages and platform context documentation; Google Gemini model/pricing documentation; xAI model/pricing documentation; Mistral model/pricing documentation. Long-context, priority/fast, regional, caching and batch pricing can differ.

What is the hidden cost?

• additional reasoning tokens;
• extra tool-call latency;
• faster subscription/quota consumption in tool-heavy sessions;
• larger active context;
• time spent reviewing a longer reasoning process that may not improve the final result.

A recent Codex user A/B report in the MCPVerdict evidence set reported up to about 10% token savings after removing Sequential Thinking from that user's workflow. That figure is a community result, not a universal constant.

Sequential Thinking has a very small external security surface. The evaluated server runs locally over stdio, requires no credentials, does not need external network access, does not need filesystem access and does not make persistent writes to external systems.

The server does maintain in-memory thought history and branch state while the process is running. That state is part of how the tool works and matters for client retry/idempotence assumptions.

The codebase is small, but several 2026 issues affect practical confidence: input coercion mismatches, a published version that reported the wrong internal version, client-specific dispatch failures, Docker build failures and incorrect state/idempotence annotations.

The server is stateful even though metadata described it as read-only and idempotent

An August 2026 11-call test showed that each invocation appended to thoughtHistory, while branch calls also mutated branch state. Repeating the same call therefore changes history length and can duplicate branch entries. This is an internal-state correctness issue, not a destructive external write issue.

MCP 2026-07-28 was not adopted in the evaluated implementation

The evaluated server remained on the v1 TypeScript SDK line. This does not mean the server is unusable, but it reduces confidence in current-protocol alignment and contributes to the compatibility score.

Sequential Thinking uses local stdio, so any MCP host that can launch a local command can potentially use it. Search demand is especially concentrated around Claude Code, Cursor, OpenCode and Codex.

The standard path uses NPX and the official npm package. Docker is also supported.

NPX

npx -y @modelcontextprotocol/server-sequential-thinking

Claude Desktop

{
  "mcpServers": {
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    }
  }
}

Codex CLI

codex mcp add sequential-thinking npx -y @modelcontextprotocol/server-sequential-thinking

VS Code

{
  "servers": {
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    }
  }
}

Disable local thought logging

DISABLE_THOUGHT_LOGGING=true

After installation, reload the MCP host, confirm that sequentialthinking appears in the tool list, and test it with a problem complex enough to require several reasoning steps.

A good test contains an assumption that can fail. A database migration is a better example than a simple arithmetic problem because the tool can demonstrate revision and branching instead of merely producing a longer linear chain.

Plan a PostgreSQL 14 → 16 migration with a maximum five-minute downtime window. Revise the plan if a migration step exceeds the limit and compare alternative paths.

This exercises the server's differentiating features: the model can revise an earlier assumption, branch from a prior thought, extend the thought count and then compare the alternative path against the original plan.

These sources document implementation and client-compatibility behavior. Issue reports describe the reporter’s environment and affected versions; they do not establish that every current installation has the same problem.

1. Coercion and package publication: a report describes valid tool calls being rejected and asks for an npm release containing a fix already in the repository. Read the release/coercion report — servers #3856 ↗.
2. Client dispatch: a July 22, 2026 report describes Sequential Thinking calls failing in the Claude.ai chat surface while succeeding through Claude Code, with reproduction steps and version comparisons. This is a reported compatibility problem, not a universal failure. Read the client-dispatch report — claude-ai-mcp #673 ↗.
3. Statefulness and annotations: an issue documents instance state and challenges the server’s read-only and idempotence annotations. This matters when clients use tool metadata to decide how to handle repeated calls. Read the statefulness report — servers #4721 ↗.
4. Implementation reference: the official tool registration is available for checking the current input schema, coercion logic and annotations. The main branch can change independently of the package installed by a user. Inspect the official tool implementation ↗.

Evidence limit: these sources do not establish a general reasoning-quality improvement or a repeatable token-saving percentage. Compare the same tasks with and without the tool before drawing those conclusions.