Category: AI & ML Tools

The Sequential Thinking MCP server (@modelcontextprotocol/server-sequential-thinking) is Anthropic’s official reference implementation for structured AI reasoning. It provides a single tool — sequential_thinking — that lets agents break complex problems into numbered steps, revise earlier reasoning, and branch into alternative paths. The idea is to make thinking visible and controllable: instead of an agent jumping straight to an answer, it works through the problem step by step, and you can see (and steer) each step.

At a glance: ~89,500 stars (monorepo), ~134K weekly npm downloads (roughly double May’s low, coinciding with the July 2026 release), v2026.7.4, 1 tool, Apache 2.0 for new contributions / MIT for legacy code, ~6.5M+ all-time PulseMCP visitors.

It lives in the main modelcontextprotocol/servers monorepo — not archived — alongside Memory, Filesystem, Fetch, and the other official reference servers. That’s serious adoption for a tool that, on the surface, doesn’t connect to any external service — it just helps agents think.

But this server exists in an increasingly awkward position. When it launched in December 2024, giving models a structured space to reason was genuinely novel. Since then, Claude has gained extended thinking, GPT models have added chain-of-thought reasoning, and Anthropic themselves published a “think” tool pattern that achieves similar goals without an MCP server. The question isn’t whether structured thinking helps — it does. The question is whether you need a separate MCP server for it in 2026.

What’s New (August 2026 Update)

First new npm release in 6.5 months — the “stalled” narrative from earlier this year is over. After sitting at v2025.12.18 (December 18, 2025) for most of H1 2026, the package published v2026.7.4 on July 4, 2026. It’s a monorepo-wide version bump (shipped alongside server-everything, server-filesystem, and server-memory) rather than a dedicated changelog entry for this package specifically, but it does move the published npm package back in sync with in-repo work like the May 2026 SDK bump and the June 2026 dependency-security hardening commit.

Downloads have roughly doubled since this review’s May 2026 low. This review previously reported ~72K weekly downloads as of May 2026. Checking npm’s official download-stats API directly as of this update, the most recent full week (Aug 3–9, 2026) shows ~134K weekly downloads — with an even sharper single-week spike (~211K) in the week the new release shipped. Whether that’s driven by the release itself, broader MCP adoption, or CI/cache re-pulls tied to the version bump isn’t something npm’s public stats can distinguish, but the “declining, stagnant” framing from earlier in the year no longer matches the data.

Memory leak fix still unmerged — now over 6 months. PR #3321 (opened February 11, 2026), which proposes a configurable max-history limit and a clearHistory() method, remains open, with a review from June 13, 2026 the last visible activity. In sessions running 6-8+ hours, RAM can reportedly hit 10GB+ per the PR’s own description. For long-running agent workflows, this remains an unresolved production risk, and the age of the open PR (6+ months, unmerged despite passing tests) is itself a maintenance-pace signal.

Anthropic still recommends extended thinking over the think tool. Their December 2025 update stated: “We recommend using [extended thinking] instead of a dedicated think tool in most cases.” The think tool (and by extension, Sequential Thinking) remains recommended only for complex tool chains, policy-heavy environments, and sequential multi-step decisions.

Prior updates (March–April 2026): Tool annotations added (PR #3534), better type coercion for LLM-sent parameters (PR #3533), repo began moving to Apache 2.0 for new contributions (legacy code remains MIT). Documentation expanded April 8 with practical usage examples and MCP host integration guidance. PR #4005 — still open as of this update — proposed ANSI rendering fixes for box-drawing bugs in diagnostic output. Thought count constraint request closed as “not planned” on April 20.

What It Does

The server exposes exactly one tool:

sequential_thinking — Process a single thought in a sequence. The agent calls this tool repeatedly, once per thought step, building up a chain of reasoning.

Required parameters:

  • thought (string) — The content of the current thinking step
  • thoughtNumber (integer) — Current position in the sequence (1, 2, 3…)
  • totalThoughts (integer) — Estimated total steps needed (can be adjusted dynamically)
  • nextThoughtNeeded (boolean) — Whether another step follows

Optional parameters for advanced reasoning:

  • isRevision (boolean) — Marks this thought as a revision of earlier reasoning
  • revisesThought (integer) — Which earlier thought is being reconsidered
  • branchFromThought (integer) — Starting point for an alternative reasoning path
  • branchId (string) — Identifier for the alternative branch
  • needsMoreThoughts (boolean) — Signals that the initial estimate was too low

The server tracks all thoughts, revisions, and branches in memory. When the agent sets nextThoughtNeeded to false, the server returns a summary of the complete reasoning chain.

Setup

For Claude Desktop:

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

Docker:

{
  "mcpServers": {
    "sequential-thinking": {
      "command": "docker",
      "args": ["run", "--rm", "-i", "mcp/sequentialthinking"]
    }
  }
}

Optional environment variables:

  • DISABLE_THOUGHT_LOGGING — Set to true to suppress thought logging to stderr (source)

There is no environment variable to cap the total number of thoughts — see “What Doesn’t Work Well” below.

Requirements: Node.js 18+ or Docker. No API keys, no accounts, no external services.

Setup difficulty: Very easy. One line in your MCP config. No configuration needed beyond the optional environment variables.

What Works Well

The branching and revision model is genuinely elegant. Unlike simple chain-of-thought prompting, the server tracks branching and revision as first-class concepts. An agent can explore one approach for five steps, realize it’s wrong, revise step 3, or branch from step 2 into an entirely different line of reasoning. The server maintains the full tree of thoughts — main line, branches, and revisions — giving you a complete record of how the agent reasoned through the problem.

Dynamic thought adjustment prevents premature stopping. The totalThoughts parameter is an estimate, not a limit. If the agent realizes mid-reasoning that a problem is more complex than expected, it can increase the count or set needsMoreThoughts to true. This prevents the common problem where an agent commits to “I’ll solve this in 5 steps” and then rushes through an inadequate answer. There’s no built-in ceiling on the other end, though — see “What Doesn’t Work Well” for why that cuts both ways.

The reasoning trace is visible and auditable. Every thought, revision, and branch is tracked and returned. For debugging agent behavior — understanding why an agent made a particular decision — this is valuable. You can see exactly where reasoning went wrong, which branches were explored, and what was revised. This matters for complex planning tasks where the final answer alone isn’t enough.

Zero-dependency simplicity. No API keys, no accounts, no cloud services, no persistent storage. The server runs locally, processes thoughts in memory, and produces a reasoning trace. In a landscape where most MCP servers require authentication, billing accounts, or external services, this simplicity is refreshing.

Still maintained in the official monorepo. Unlike Puppeteer and SQLite (moved to servers-archived), Sequential Thinking remains in the active modelcontextprotocol/servers repo (~89,500 stars). It received two fixes in March 2026 (type coercion, tool annotations), a docs expansion in April, and has an active rendering fix PR. New contributions are now licensed Apache 2.0 (legacy code remains MIT). Version 2026.7.4 (published July 4, 2026) is the latest npm release.

What Doesn’t Work Well

Anthropic now explicitly recommends against it for most use cases. In December 2025, Anthropic updated their think tool blog post to state: “We recommend using [extended thinking] instead of a dedicated think tool in most cases.” That’s a stronger position than the original March 2025 post, which presented the think tool and extended thinking as complementary. Downloads dipped after that update, then rebounded through 2026 — weekly downloads are now roughly double the low this review reported in May. The sequential thinking server was pioneering in late 2024; in 2026, its creators are steering users elsewhere even as usage keeps growing.

Memory leak in long-running sessions. PR #3321 (opened February 2026, still open as of this update) documents that thoughtHistory and branches arrays grow without bound. In sessions running 6-8+ hours, RAM consumption can reportedly hit 10GB+ per the PR description. A fix proposing configurable limits and a clearHistory() method has passed its tests but remains unmerged more than 6 months later. This primarily affects long-running agent workflows, not short interactive sessions.

Every thought step is a separate tool call. A 10-step reasoning chain means 10 tool calls. Each call carries serialization overhead, schema validation, and round-trip latency versus letting the model reason silently within extended thinking. For agents paying per token, that per-call overhead adds up, though the actual size of the effect depends on the host, model, and task — we could not find a primary source quantifying it for this server specifically, so we’re not attaching a number to it.

LLMs struggle with the type constraints. The thoughtNumber and totalThoughts parameters require integers, but LLMs frequently send strings like "1" instead of 1. This caused enough validation failures (#2598 — closed via improved parameter descriptions, #2905 — closed as duplicate) that the team had to add string-to-number coercion. The tool description itself has been flagged as too long for OpenAI models (2,780 characters vs. 1,024-character limit — still open). When the tool is hard for its target users (LLMs) to use correctly, that’s a fundamental design friction.

Agents underutilize the advanced features. Community analysis (#2332 — closed after fork implemented fixes) found that AI systems use the tool effectively for linear step-by-step reasoning but rarely use isRevision, branchFromThought, or branchId. The elegant branching model exists in theory; in practice, agents mostly just count from 1 to N linearly. The features that differentiate this from simple chain-of-thought prompting are the same features that agents don’t use.

Session stickiness in Claude Code. Users reported (#713 — closed April 2025) that once sequential thinking is invoked in a Claude Code session, the agent continues using it for every subsequent action — even when it’s unnecessary. You end up with 8-step reasoning chains for simple tasks that should take one step. Clearing the context is the only workaround.

No persistence of reasoning chains. Thoughts exist only in server memory for the duration of the session. Once the server stops, all reasoning traces are gone. If you want to review or compare reasoning across sessions, you need to capture the output yourself. For a tool whose main value is making reasoning visible, the inability to save that reasoning is a gap.

The totalThoughts parameter is uncontrollable, period. A user tried command-line arguments and environment variables to cap the server at 5 thoughts and got 11 anyway; the request to add a real constraint mechanism was closed April 2026 as “not planned”. There is no shipped environment variable or config option that limits thought count — checking the current source, the only environment variable the server reads at all is DISABLE_THOUGHT_LOGGING. (An earlier version of this review claimed a MAX_TOTAL_THOUGHTS variable existed as a workaround; we could not find it in the source or docs and have removed that claim.) By default an agent can generate dozens of thought steps, consuming tokens and time without constraint, and the maintainers closing the configuration request as “not planned” signals this is by design, not a gap they intend to fill.

Compared to Alternatives

vs. Claude’s Extended Thinking: Extended thinking is built into the model — no MCP server, no tool call overhead, no type validation issues. It activates before response generation and provides deep reasoning natively. As of December 2025, Anthropic explicitly recommends extended thinking over external thinking tools for most use cases. Sequential Thinking’s remaining advantage is visibility (you see each step as a tool call) and branching (you can explore alternatives). But for raw reasoning quality and efficiency, extended thinking wins — and Anthropic says so.

vs. Anthropic’s “Think” Tool Pattern: The think tool is a simpler approach — a tool that accepts a single thought string with no schema, no step counting, no branching. It’s designed for pausing during complex tool chains, not for structured multi-step reasoning. Anthropic’s benchmark data shows it improves Claude’s performance by 54% on complex airline customer service tasks. Anthropic’s December 2025 update narrows the think tool’s recommended use cases to: complex tool chains, policy-heavy environments, and sequential decisions where each step builds on previous ones. For everything else, they now recommend extended thinking.

vs. Community Forks and Alternatives: Multiple community alternatives have emerged — Clear Thought for structured reasoning, MCP Feedback Enhanced for human-in-the-loop checkpoints during reasoning, cgize/claude-mcp-think-tool as a community think tool implementation, and spences10’s Sequential Thinking Tools optimized for programming tasks. FradSer’s multi-agent version passes each thought through six specialized agents (factual, emotional, critical, optimistic, creative, meta-cognitive) plus a synthesis step for deeper analysis; its own README states this “consumes significantly more tokens than a single-agent tool — roughly 5-10x more per sequentialthinking call.” These forks address real gaps but fragment the ecosystem.

vs. Our Memory MCP Server review: Both are official reference servers from the modelcontextprotocol/servers monorepo. Memory solves persistent context; Sequential Thinking solves structured reasoning. Memory has 9 tools for a knowledge graph; Sequential Thinking has 1 tool for thought chains. Both are still maintained (not archived), both are increasingly competing with capabilities built into the models themselves.

Who Should Use This

Yes, use it if:

  • You need an auditable reasoning trace — understanding how an agent reached a conclusion, not just what it concluded
  • You’re building agent workflows where reasoning visibility matters for debugging or compliance
  • You want to experiment with branching and revision in agent reasoning
  • Your MCP client doesn’t support extended thinking (some clients only support tool calls)
  • You’re teaching or demonstrating structured reasoning concepts

Don’t use it if:

  • You’re using a model with built-in extended thinking or reasoning capabilities (you probably don’t need this)
  • Token cost matters — each thought step is a separate tool call with overhead
  • You need persistent reasoning traces (nothing is saved between sessions)
  • You want agents to actually use branching and revision (they mostly don’t)
  • You’re using Claude Code (session stickiness will frustrate you)
3 / 5 — Pioneering concept, still fighting its own design
The Sequential Thinking MCP server introduced an important idea: making AI reasoning structured, visible, and controllable. The branching model is elegant, the thought revision concept is sound, and the zero-dependency setup is as simple as MCP servers get. The picture on maintenance pace and adoption has actually improved since this review’s May 2026 update: a new npm release (v2026.7.4) shipped July 4, 2026 after a 6.5-month gap, and weekly downloads have roughly doubled to ~134K. But the deeper issues haven’t moved. The memory leak fix has sat unmerged for over 6 months. The thought count constraint request was closed as “not planned” — there is no way to cap runaway thought chains. Agents still rarely use the branching and revision features that justify this over simpler approaches, and Anthropic itself still recommends extended thinking over a dedicated think tool for most cases. It’s still maintained — it hasn’t been archived like Puppeteer or SQLite, and it’s clearly still used at real volume — but the combination of an unmerged 6-month-old memory fix, no thought-count ceiling, and its own maintainer’s stated preference for extended thinking keeps this a niche pick rather than a default one. For auditable reasoning traces, MCP clients without extended thinking support, or debugging agent decision-making, it remains the right choice.

ChatForest does not test MCP servers hands-on. Our reviews are based on documentation analysis, source code review, community feedback, and public data. Learn more about our methodology.

This review was last updated on 2026-08-14 using Claude Sonnet 5 (Anthropic).