Verified MCP server: Sequential Thinking
The short answer
Last verified 2026-08-03
The Sequential Thinking MCP server gives an AI assistant a place to think in numbered, revisable steps instead of answering in one pass. It is the reference reasoning server of the Model Context Protocol project, it runs on your own Mac over stdio, and it needs no account, no API key, and no sign-up of any kind. It is also unusually narrow: one tool, nothing fetched from anywhere, nothing stored for you. We did not take the README's word for any of that. We ran the server, spoke the protocol to it, enumerated that single tool, and then called it for real; it answered with the thought counter it keeps, so this page carries a full verification. The README turns out to be wrong about the tool's own name, which we proved with a call that failed, and both the working name and the exact errors are below. [1][5][3][6]
Verification
Method
We spawned the server with npx over stdio in a clean environment, with no credentials and no environment variables set, completed the MCP initialize handshake, called tools/list, and then called sequentialthinking for real with one closed thought step. It answered with a successful structured result, thought 1 of 1 and a thought history of one, and printed our thought back inside a box on its log output. So the run counts as a full verification: started, enumerated, and one real tool call that worked. The raw JSON was captured on the wire, and the tool table below is that capture, word for word.
Startup banner
Sequential Thinking MCP Server running on stdio ┌───────────────────────────────────────────────────────────────────────────────────────────────────────────┐ │ 💭 Thought 1/1 │ ├───────────────────────────────────────────────────────────────────────────────────────────────────────────┤ │ Test thought: verify the sequential thinking server responds correctly to a single-step reasoning call. │ └───────────────────────────────────────────────────────────────────────────────────────────────────────────┘
One real tool call
tools/call sequentialthinking {"thought": "Test thought: verify the sequential thinking server responds correctly to a single-step reasoning call.", "nextThoughtNeeded": false, "thoughtNumber": 1, "totalThoughts": 1}{
"thoughtNumber": 1,
"totalThoughts": 1,
"nextThoughtNeeded": false,
"branches": [],
"thoughtHistoryLength": 1
}Real lines from the captured result: enough to prove the call answered.
Tools
The server answered tools/list with 1 tools on 2026-08-03. The names, descriptions and parameters below are its own words, copied from that response and never edited.
| Tool | What it does |
|---|---|
| sequentialthinkingthought*nextThoughtNeededthoughtNumber*totalThoughts*isRevisionrevisesThoughtbranchFromThoughtbranchIdneedsMoreThoughts | A detailed tool for dynamic and reflective problem-solving through thoughts. This tool helps analyze problems through a flexible thinking process that can adapt and evolve. Each thought can build on, question, or revise previous insights as understanding deepens. When to use this tool: - Breaking down complex problems into steps - Planning and design with room for revision - Analysis that might need course correction - Problems where the full scope might not be clear initially - Problems that require a multi-step solution - Tasks that need to maintain context over multiple steps - Situations where irrelevant information needs to be filtered out Key features: - You can adjust total_thoughts up or down as you progress - You can question or revise previous thoughts - You can add more thoughts even after reaching what seemed like the end - You can express uncertainty and explore alternative approaches - Not every thought needs to build linearly - you can branch or backtrack - Generates a solution hypothesis - Verifies the hypothesis based on the Chain of Thought steps - Repeats the process until satisfied - Provides a correct answer Parameters explained: - thought: Your current thinking step, which can include: * Regular analytical steps * Revisions of previous thoughts * Questions about previous decisions * Realizations about needing more analysis * Changes in approach * Hypothesis generation * Hypothesis verification - nextThoughtNeeded: True if you need more thinking, even if at what seemed like the end - thoughtNumber: Current number in sequence (can go beyond initial total if needed) - totalThoughts: Current estimate of thoughts needed (can be adjusted up/down) - isRevision: A boolean indicating if this thought revises previous thinking - revisesThought: If is_revision is true, which thought number is being reconsidered - branchFromThought: If branching, which thought number is the branching point - branchId: Identifier for the current branch (if any) - needsMoreThoughts: If reaching end but realizing more thoughts needed You should: 1. Start with an initial estimate of needed thoughts, but be ready to adjust 2. Feel free to question or revise previous thoughts 3. Don't hesitate to add more thoughts if needed, even at the "end" 4. Express uncertainty when present 5. Mark thoughts that revise previous thinking or branch into new paths 6. Ignore information that is irrelevant to the current step 7. Generate a solution hypothesis when appropriate 8. Verify the hypothesis based on the Chain of Thought steps 9. Repeat the process until satisfied with the solution 10. Provide a single, ideally correct answer as the final output 11. Only set nextThoughtNeeded to false when truly done and a satisfactory answer is reached |
Parameters marked with * are required.
Setup
Copy the block for the app you use. Each one is the configuration this server was verified with.
Open the file ~/Library/Application Support/Claude/claude_desktop_config.json (in Claude Desktop: Settings, then Developer, then Edit Config) and add:
{
"mcpServers": {
"sequential-thinking": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-sequential-thinking"
]
}
}
}That is the whole config: no key, no folder, no account. Quit and reopen Claude Desktop. If you would rather not see the boxed thought log the server prints, add "env": { "DISABLE_THOUGHT_LOGGING": "true" } next to args. [7][5]
One command in your terminal:
claude mcp add sequential-thinking -- npx -y @modelcontextprotocol/server-sequential-thinking
Everything after the double dash is the exact command Claude Code will run. Nothing goes after the package name: this server takes no startup arguments and no environment variables it cannot live without. [8][5]
Add to ~/.cursor/mcp.json for every project, or to .cursor/mcp.json inside one project:
{
"mcpServers": {
"sequential-thinking": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-sequential-thinking"
]
}
}
}Cursor picks the file up on restart. The same optional DISABLE_THOUGHT_LOGGING env block works here too. [9][5]
No JSON file and no terminal. In Routines: Settings, then Assistant, then Connections, then Add MCP Server. Switch the form to Command (stdio) and enter:
Name Sequential Thinking Command npx Arguments -y @modelcontextprotocol/server-sequential-thinking
Leave Environment Variables empty, this server needs none. Click Test Connection first: a working server answers with its tool count, which is one here. [10]
No terminal needed
If you have never opened Terminal and never want to, this is your path. Routines is a Mac app that runs MCP servers for you: fill in three fields once, and this server's tool is available to your AI in chat and in scheduled routines.
01
Download the app from getroutines.ai/download, drag it to Applications, and sign in.
02
Click your account at the bottom of the sidebar and choose Settings. Open the Assistant section, then the Connections tab, scroll to MCP Servers, and click Add MCP Server.
03
Switch the form to Command (stdio): this server is a command your Mac runs, not a web address you connect to.
04
Name: Sequential Thinking. Command: npx. Arguments: -y @modelcontextprotocol/server-sequential-thinking. There is no folder to pick and no key to paste, so those three lines are the entire configuration.
05
Leave Environment Variables empty, this server needs none. Click Test Connection: Routines starts the server and reports how many tools it found, exactly one for this server. Then click Add Server.
06
The tool works in chat right away, and the assistant reaches for it on its own when a question needs several steps. To let a scheduled routine use it, open the routine, find the Tools & connections card, and tick the server under Apps.
Routine ideas
Once the server is connected, a scheduled routine can use its tools while you are away. Copy a prompt, paste it into Routines, and pick a time.
Every Monday at 8:00, draft my plan for the week from my open tasks and notes. Use the sequential thinking tool to work through it step by step, weigh urgent against important, revise at least one of your own steps, and show me the numbered steps above the final plan.
Every Friday at 16:00, take the decisions I flagged this week. For each one, reason through the trade-offs step by step with the sequential thinking tool, then give me one recommendation per decision with the numbered steps that led to it.
Every weekday at 7:30, review what failed or looked wrong overnight. Use the sequential thinking tool to work through the likely causes one step at a time, rank them from most to least likely, and put the ranking in the report instead of a single guess.
Troubleshooting
Real errors captured during the verification run, printed exactly as the server returned them.
What you see
MCP error -32602: Input validation error: Invalid arguments for tool sequentialthinking: Invalid input: expected string, received undefined at thought
The fix
Three fields are required on every call: thought, thoughtNumber and totalThoughts. We triggered this on purpose by leaving thought out. Nothing is broken on your side: the rejection came back as an ordinary error reply from the running server rather than a crash, and assistants usually retry with the full set. If one keeps failing, ask it in plain words to think the problem through in a set number of steps, which hands it the two numbers it needs.
What you see
MCP error -32602: Input validation error: Invalid arguments for tool sequentialthinking: Invalid input: expected number, received NaN at thoughtNumber
The fix
thoughtNumber and totalThoughts are counts, not words. We triggered this by sending the word one where a count belongs, and the refusal came back as an ordinary error reply rather than a crash. Numeric text is a softer case, and here we are reading the package rather than quoting a run of it: its published validation schema coerces these two fields, so a quoted "3" is read as the number 3 and only genuinely non-numeric text is refused. Restating the request usually gets the assistant to send digits.
What you see
MCP error -32602: Tool sequential_thinking not found
The fix
This is the one real trap on this page. The server registers exactly one tool and spells it sequentialthinking, as a single word, but its own README documents sequential_thinking with an underscore. We called the documented name on purpose and got the line above. Use the name in the table above, which is the live tools/list capture, and ignore the underscore wherever you meet it.
The fix
We started the server with a flag it does not know, --not-a-real-flag, expecting a refusal. There was none: it ignored the flag, printed its usual banner, completed the handshake and answered a real tool call as normal. That cuts both ways. This server takes no startup arguments, so nothing you add after the package name changes what it does, and a mistyped extra line in your config will look like it is working rather than telling you it is wrong.
The fix
The npx command belongs to Node.js. If Node is not installed on your Mac, every client on this page fails at the spawn step before the server can say anything. Install Node from nodejs.org, restart your MCP client, and try again.
FAQ
It is the reference reasoning server of the Model Context Protocol project. Instead of connecting your AI to a system that holds data, it hands the assistant a structured scratchpad: one tool call per thought, numbered, with room to revise an earlier thought or branch into a different line of attack and come back. The server keeps the running count and hands it back with every call, so a long piece of reasoning has a shape you can read instead of one paragraph of conclusion. It runs as a local process on your Mac and talks to your AI app over stdio. [5]
Exactly one, called sequentialthinking. It takes the thought itself plus the bookkeeping around it, thoughtNumber and totalThoughts, and optional fields for revising an earlier thought (isRevision, revisesThought), branching off one (branchFromThought, branchId) and asking for more steps than first planned (needsMoreThoughts). One tool is the design, not an omission: this is a thinking scaffold rather than an integration. The table above is the live tools/list output, word for word, and the name in it carries no underscore even though the README writes sequential_thinking. That mismatch is not just our reading of it: an open pull request against the repository asks for the README to be corrected to the registered name. [5][6]
It is the mildest kind of server in this directory: no credential to leak, nothing of yours to reach, and no service of its own to call. The tool marks itself read only, non destructive and closed world in the annotations we captured on the wire, and our real call came back with nothing but a counter and an empty branch list. The one thing worth knowing is that it prints every thought it is handed into its own log output, in a box, which is exactly how our test thought ended up in the startup banner above. Set the optional DISABLE_THOUGHT_LOGGING variable to true if that output goes somewhere you would rather it did not. [5]
No. There is nothing to sign up for and no credential to paste: we started it with a completely clean environment and it came straight up and answered a real call. The single environment variable it reads, DISABLE_THOUGHT_LOGGING, is optional and only silences the printed thought log. The npx command downloads the package from the public npm registry on first run, so the very first start needs an internet connection; after that the package is cached on your Mac. [1][5]
No. In Routines you fill three fields in Settings and click Test Connection; the walkthrough above shows every click. Claude Desktop needs a small JSON file edited once. Only Claude Code is terminal-first by nature. [10][7]
It is published by the Model Context Protocol organization out of the shared modelcontextprotocol/servers repository, which holds dozens of reference servers; sequential thinking is one folder inside it, so that repository's 89,161 stars belong to the whole collection and not to this server alone. The two version numbers are both real and we captured both: the npm release pipeline stamps a date-based version at publish time, so the registry says 2026.7.4, while the running server self-reports sequential-thinking-server 0.2.0 over MCP. Same code, two numbering schemes. [1][3]
Any MCP client that can launch a local stdio server: Claude Desktop, Claude Code, Cursor, and Routines all can, and the exact config for each is above. The server itself is the same in every client; only the place you paste the config differs. It keeps its thought history inside the running process, which is why our fresh run reported a thought history of one, so each client that starts it begins its own count from zero. [7][8][9][10]
Sources
Anything on this page we did not observe in the run is linked here, with the date we read it. The run itself is the receipt for the rest.
[1]
Latest version 2026.7.4, published 2026-07-04. Ships the bin mcp-server-sequential-thinking and names modelcontextprotocol/servers as its repository.
[2]
[3]
89,161 stars, 11,369 forks and a push dated 2026-08-03 at access time, per the GitHub API. Those figures cover the whole monorepo of reference servers, not this server on its own.
[4]
The project states it is transitioning from the MIT License to Apache-2.0, which is why npm reports SEE LICENSE IN LICENSE and GitHub reports NOASSERTION rather than one clean license name.
[5]
Documents the thought, revision and branching fields, the npx stdio config block for Claude Desktop, and the optional DISABLE_THOUGHT_LOGGING variable. Also the source of the naming error: it writes sequential_thinking, while the running server registers sequentialthinking.
[6]
Open pull request confirming the README documents sequential_thinking while index.ts registers the tool as sequentialthinking, the same mismatch our tools/list capture shows.
[7]
The official Claude Desktop quickstart and the shape of claude_desktop_config.json.
[8]
[9]
[10]
How Routines runs one-click OAuth connectors and any MCP server.
This page describes Sequential Thinking as it behaved in one dated run on one Mac. Versions move: if something here no longer matches what you see, the capture date at the top says how old the reading is.
Behind this directory
Routines, the app behind this directory, runs MCP servers like this one without a terminal: see how connectors work. Your notes stay markdown files on your Mac, there is no cloud bill, and it works offline. Download Routines