Sequential Thinking is one of the official reference servers from the MCP project, and one of the most installed servers overall. It exposes a single tool that lets a model write out its reasoning one step at a time, revise earlier steps, branch into alternatives and decide for itself when it has thought enough.
Bring your own
GPT-5.4
Chat with 60+ AI models on the same workflow — switch to a different model mid-conversation and re-run the same prompt, or use Compare mode to put several side-by-side and balance quality vs. cost.
No token required
How models use it and what it is built for.
Most tools give a model access to something outside itself. This one gives it structure. The server exposes a single sequentialthinking tool that a model calls repeatedly, each call recording one numbered thought. Crucially, the model is not locked into its first plan: it can raise the total number of steps mid-way, mark a call as a revision of an earlier thought, or branch from a specific step to explore an alternative line and come back. The server itself does no reasoning — it stores the thought chain, formats it, and returns state on every call, which is what keeps the model honest about where it is in the problem. It is most useful for planning, design and multi-step debugging, where the shape of the problem is not clear at the start.
Typical tools an AI model can call. Exact names vary by version.
Taken from the official Sequential Thinking documentation — see Sequential Thinking — official reference implementation for the full reference.
Environment variables
DISABLE_THOUGHT_LOGGINGSet to true to stop the server printing formatted thoughts to stderr. Useful when the log noise clutters your client.
Client configuration
npx (recommended)
No install step — npx fetches the published package on first run.
{
"mcpServers": {
"sequential-thinking": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
}
}
}Docker
Same server, pinned image, no Node toolchain on the host.
{
"mcpServers": {
"sequential-thinking": {
"command": "docker",
"args": ["run", "--rm", "-i", "mcp/sequentialthinking"]
}
}
}Copy any of these into MCP Agent Studio after connecting.
Think through how to migrate this service to a new database without downtime.
Work step by step through why these two test failures might share a root cause.
Plan a rollout for this feature, then revise the plan for a 10x traffic spike.
Compare three architectures for this problem, branching on each before deciding.
This is not a single-model product: you get the same MCP connection with 60+ models (Claude, GPT, Gemini, DeepSeek, open-weight, and more), you can switch mid-conversation, and you can open Compare mode to run the same prompt against multiple models at once. The card above is a suggested starting point for this server — not the only choice.
Default pick for Sequential Thinking
GPT-5.4
The server earns its keep with capable non-reasoning models, which gain the most structure from it. Native reasoning models often duplicate what it provides.
Listing tools proves the server is reachable, not that a model can work with it. Evals go further: they read every tool on the server, write a test suite from its real schemas, and run it — code decides pass/fail on the responses (schema conformance, error codes, pagination, result caps) while a scoring model grades plain-English tasks driven through the tools.
Get a pass/fail report per tool with the evidence behind each verdict — and replay the same suite after every schema change. Destructive tools are excluded from the run.
Run evalsOpen MCP Agent Studio with the connection pre-filled. Add your token, pick any of 60+ models, and start chatting — no install required.
Open Agent StudioCommon questions about connecting, scoping and using it safely.
It is an official reference server from the Model Context Protocol project, published as @modelcontextprotocol/server-sequential-thinking. It gives a model an external scratchpad for step-by-step problem solving, with the ability to revise earlier steps and branch into alternatives.
It does not add reasoning capability — the server performs no inference at all. What it adds is structure and persistence: the chain is visible, revisable and survives across turns, which measurably helps models that do not have strong native planning.
Largely, for a single hard question. Models with native extended thinking already decompose internally. The server still earns its place when you want the reasoning chain to be inspectable and revisable as an artefact rather than hidden inside the model.
Neither. It runs locally over stdio, holds the thought chain in memory for the session, and never makes a network call. That also means nothing persists once the process exits.
Set DISABLE_THOUGHT_LOGGING to true in the server environment. By default it prints each formatted thought to stderr, which is useful while you are learning how a model uses it and noisy afterwards.