The CRASH server enables structured, iterative reasoning for complex problem-solving and analysis by breaking down tasks into sequential steps with defined purposes (analysis, action, validation, planning, etc.). Key capabilities include:
• Confidence tracking with 0-1 scale uncertainty measurement and doubt documentation • Revision mechanism to correct and improve previous steps with documented rationale • Branching support for exploring multiple solution paths concurrently using unique IDs • Tool integration with structured actions, parameters, and expected outputs • Session management for handling multiple concurrent reasoning chains • Flexible output formats (console, JSON, Markdown) with configurable settings • Context awareness to track completed steps and avoid redundancy • Custom purposes beyond standard step types for extended functionality
Ideal for code analysis, system design, debugging, research, decision-making, and comprehensive solution exploration.
Provides Markdown output formatting for human-readable documentation of reasoning processes and analysis workflows
Distributed as an npm package for easy installation and integration into Node.js-based MCP server environments
Built with TypeScript for type-safe development and enhanced tooling support in the reasoning server implementation
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@CRASH - Cascaded Reasoning with Adaptive Step Handling analyze why our API response times are slow and propose solutions"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
An MCP (Model Context Protocol) server for structured, iterative reasoning. CRASH helps AI assistants break down complex problems into trackable steps with confidence tracking, revision support, and branching for exploring alternatives.
Inspired by MCP Sequential Thinking Server
Related MCP server: Clear Thought 1.5
I created this because typing "use sequential_thinking" was cumbersome. Now I can simply say "use crash" instead.
CRASH is more token-efficient than sequential thinking - it doesn't include code in thoughts and has streamlined prompting. It's my go-to solution when an agent can't solve an issue in one shot or when plan mode falls short.
CRASH helped significantly for this specific task:
Where CRASH helped:
- Systematic analysis: Forced me to break down the issue methodically
- Solution exploration: Explored multiple approaches before settling on the best one
- Planning validation: Each step built on the previous one logically
The key difference:
CRASH forced me to be more thorough in the analysis phase. Without it, I might have
rushed to implement the first solution rather than exploring cleaner approaches.
Verdict: CRASH adds value for complex problems requiring systematic analysis of
multiple solution paths. For simpler tasks, internal planning is sufficient and faster.Structured reasoning steps - Track thought process, outcomes, and next actions
Confidence tracking - Express uncertainty with 0-1 scores, get warnings on low confidence
Revision mechanism - Correct previous steps, with original steps marked as revised
Branching support - Explore multiple solution paths with depth limits
Dependency validation - Declare and validate step dependencies
Session management - Group related reasoning chains with automatic timeout cleanup
Multiple output formats - Console (colored), JSON, or Markdown
Flexible validation - Strict mode for rigid rules, flexible mode for natural language
npm install crash-mcpOr use directly with npx:
npx crash-mcpMost MCP clients use this JSON configuration:
{
"mcpServers": {
"crash": {
"command": "npx",
"args": ["-y", "crash-mcp"]
}
}
}Client | Setup Method |
Claude Code |
|
Cursor | Add to |
VS Code | Add to settings JSON under |
Claude Desktop | Add to |
Windsurf | Add to MCP config file |
JetBrains | Settings > Tools > AI Assistant > MCP |
Others | Use standard MCP JSON config above |
Use the cmd wrapper:
{
"mcpServers": {
"crash": {
"command": "cmd",
"args": ["/c", "npx", "-y", "crash-mcp"]
}
}
}{
"mcpServers": {
"crash": {
"command": "npx",
"args": ["-y", "crash-mcp"],
"env": {
"CRASH_STRICT_MODE": "false",
"MAX_HISTORY_SIZE": "100",
"CRASH_OUTPUT_FORMAT": "console",
"CRASH_SESSION_TIMEOUT": "60",
"CRASH_MAX_BRANCH_DEPTH": "5"
}
}
}
}FROM node:18-alpine
WORKDIR /app
RUN npm install -g crash-mcp
CMD ["crash-mcp"]{
"mcpServers": {
"crash": {
"command": "docker",
"args": ["run", "-i", "--rm", "crash-mcp"]
}
}
}Bun:
{ "command": "bunx", "args": ["-y", "crash-mcp"] }Deno:
{
"command": "deno",
"args": ["run", "--allow-env", "--allow-net", "npm:crash-mcp"]
}Variable | Default | Description |
|
| Enable strict validation (requires specific prefixes) |
|
| Maximum steps to retain in history |
|
| Output format: |
|
| Disable colored console output |
|
| Session timeout in minutes |
|
| Maximum branch nesting depth |
|
| Enable session management |
Parameter | Type | Description |
| integer | Sequential step number (starts at 1) |
| integer | Estimated total steps (adjustable) |
| string | Step category: analysis, action, validation, exploration, hypothesis, correction, planning, or custom |
| string | What's already known to avoid redundancy |
| string | Current reasoning process |
| string | Expected or actual result |
| string/object | Next action (simple string or structured with tool details) |
| string | Why this next action was chosen |
Parameter | Type | Description |
| boolean | Mark as final step to complete reasoning |
| number | Confidence level 0-1 (warnings below 0.5) |
| string | Describe doubts or assumptions |
| integer | Step number being corrected |
| string | Why revision is needed |
| integer | Step to branch from |
| string | Unique branch identifier |
| string | Human-readable branch name |
| integer[] | Step numbers this depends on |
| string | Group related reasoning chains |
| string[] | Tools used in this step |
| object | External data relevant to step |
{
"step_number": 1,
"estimated_total": 3,
"purpose": "analysis",
"context": "User requested optimization of database queries",
"thought": "I need to first understand the current query patterns before proposing changes",
"outcome": "Identified slow queries for optimization",
"next_action": "analyze query execution plans",
"rationale": "Understanding execution plans will reveal bottlenecks"
}{
"step_number": 3,
"estimated_total": 3,
"purpose": "summary",
"context": "Analyzed queries and tested index optimizations",
"thought": "The index on user_id reduced query time from 2s to 50ms",
"outcome": "Performance issue resolved with new index",
"next_action": "document the change",
"rationale": "Team should know about the optimization",
"confidence": 0.9,
"is_final_step": true
}{
"step_number": 4,
"estimated_total": 5,
"purpose": "correction",
"context": "Previous analysis missed a critical join condition",
"thought": "The join was causing a cartesian product, not the index",
"outcome": "Corrected root cause identification",
"next_action": "fix the join condition",
"rationale": "This is the actual performance issue",
"revises_step": 2,
"revision_reason": "Overlooked critical join in initial analysis"
}{
"step_number": 3,
"estimated_total": 6,
"purpose": "exploration",
"context": "Two optimization approaches identified",
"thought": "Exploring the indexing approach first as it's lower risk",
"outcome": "Branch created for index optimization testing",
"next_action": "test index performance",
"rationale": "This approach has lower risk than query rewrite",
"branch_from": 2,
"branch_id": "index-optimization",
"branch_name": "Index-based optimization"
}Good fit:
Complex multi-step problem solving
Code analysis and optimization
System design with multiple considerations
Debugging requiring systematic investigation
Exploring multiple solution paths
Tasks where you need to track confidence
Not needed:
Simple, single-step tasks
Pure information retrieval
Deterministic procedures with no uncertainty
npm install # Install dependencies
npm run build # Build TypeScript
npm run dev # Run with MCP inspector
npm start # Start built serverTry using bunx instead of npx:
{ "command": "bunx", "args": ["-y", "crash-mcp"] }Try the experimental VM modules flag:
{ "args": ["-y", "--node-options=--experimental-vm-modules", "crash-mcp"] }MCP Sequential Thinking Server - Primary inspiration
Nikko Gonzales - nikkoxgonzales
MIT
Record a structured reasoning step for complex problem-solving.
Use this tool to break down multi-step problems into trackable reasoning steps. Each step captures your current thinking, expected outcome, and planned next action.
WHEN TO USE:
Multi-step analysis, debugging, or planning tasks
Tasks requiring systematic exploration of options
Problems where you need to track confidence or revise earlier thinking
Exploring multiple solution paths via branching
WORKFLOW:
Start with step_number=1, estimate your total steps
Describe your thought process, expected outcome, and next action
Continue calling for each reasoning step, adjusting estimated_total as needed
Use confidence (0-1) when uncertain about conclusions
Use revises_step to correct earlier reasoning when you find errors
Use branch_from to explore alternative approaches
Set is_final_step=true when reasoning is complete
Returns JSON summary with step count, completion status, and next action.
| Name | Required | Description | Default |
|---|---|---|---|
| step_number | Yes | Sequential step number starting from 1. Increment for each new reasoning step. | |
| estimated_total | Yes | Current estimate of total steps needed. Adjust as you learn more about the problem. | |
| purpose | Yes | Category of this reasoning step. Standard values: analysis (examining information), action (taking an action), reflection (reviewing progress), decision (making a choice), summary (consolidating findings), validation (checking results), exploration (investigating options), hypothesis (forming theories), correction (fixing errors), planning (outlining approach). Custom strings allowed in flexible mode. | |
| context | Yes | What is already known or has been completed. Include relevant findings from previous steps to avoid redundant work. | |
| thought | Yes | Your current reasoning process. Express naturally - describe what you are thinking and why. | |
| outcome | Yes | The expected or actual result from this step. What did you learn or accomplish? | |
| next_action | Yes | What you will do next. Can be a simple string or structured object with tool details. | |
| rationale | Yes | Why you chose this next action. Explain your reasoning for the approach. | |
| is_final_step | No | Set to true to explicitly mark this as the final reasoning step. The reasoning chain will be marked complete. | |
| confidence | No | Your confidence in this step (0-1 scale). Use lower values when uncertain: 0.3 = low confidence, 0.5 = moderate, 0.8+ = high confidence. | |
| uncertainty_notes | No | Describe specific uncertainties or doubts. What assumptions are you making? What could be wrong? | |
| revises_step | No | Step number you are revising or correcting. The original step will be marked as revised. | |
| revision_reason | No | Why you are revising the earlier step. What was wrong or incomplete? | |
| branch_from | No | Step number to branch from for exploring an alternative approach. Creates a new solution path. | |
| branch_id | No | Unique identifier for this branch. Auto-generated if not provided. | |
| branch_name | No | Human-readable name for this branch (e.g., "Alternative A: Use caching") | |
| tools_used | No | List of tools you used during this step for tracking purposes. | |
| external_context | No | External data or tool outputs relevant to this step. Store important results here. | |
| dependencies | No | Step numbers this step depends on. Validated against existing steps in history. | |
| session_id | No | Session identifier for grouping related reasoning chains. Sessions expire after configured timeout. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the transparency burden. It explains the recording behavior, revision marking, branching, and finalization, and explicitly discloses the return format: 'Returns JSON summary with step count, completion status, and next action.' It also notes session expiration via the schema. This is sufficient for an agent to understand the tool's effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear intro, 'WHEN TO USE' bullets, and a numbered workflow, making it scannable despite its length. It is front-loaded with the purpose statement. Some redundancy exists between workflow steps and schema descriptions, but for 20 parameters the level of detail is appropriate.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 20 parameters, no output schema, and no annotations. The description provides the essential context: purpose, use cases, a step-by-step workflow, and a description of the return value. It covers branching, revision, confidence, and completion status. While examples are not provided, the combination of description and schema is sufficient for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already provides 100% parameter descriptions, giving a baseline of 3. The description adds value by explaining how parameters are used together in the workflow: 'Start with step_number=1', 'Use confidence (0-1)', 'Use revises_step to correct', 'Use branch_from to explore', and 'Set is_final_step=true'. This inter-parameter guidance goes beyond the standalone schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The first line states the tool's function precisely: 'Record a structured reasoning step for complex problem-solving.' It uses a clear verb ('Record') and resource ('structured reasoning step'), and the 'WHEN TO USE' section further clarifies its scope. Despite the misleading tool name 'crash', the description leaves no doubt about the tool's purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
A dedicated 'WHEN TO USE' section lists concrete scenarios: multi-step analysis, debugging, planning, systematic exploration, and branching. It also provides a numbered workflow for how to invoke the tool across a reasoning session. However, it does not explicitly state when not to use the tool or mention alternatives, though no sibling tools exist.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.0.0crash21 fields changedInput schema / properties / branch_from / descriptionPrevious value: -"Step number to branch from for alternative exploration"New value: +"Step number to branch from for exploring an alternative approach. Creates a new solution path."Input schema / properties / branch_id / descriptionPrevious value: -"Unique identifier for this branch"New value: +"Unique identifier for this branch. Auto-generated if not provided."Input schema / properties / branch_name / descriptionPrevious value: -"Descriptive name for this branch"New value: +"Human-readable name for this branch (e.g., \"Alternative A: Use caching\")"Input schema / properties / confidence / descriptionPrevious value: -"Confidence level in this step (0-1 scale)"New value: +"Your confidence in this step (0-1 scale). Use lower values when uncertain: 0.3 = low confidence, 0.5 = moderate, 0.8+ = high confidence."Input schema / properties / context / descriptionPrevious value: -"What is already known or has been completed to avoid redundancy"New value: +"What is already known or has been completed. Include relevant findings from previous steps to avoid redundant work."Input schema / properties / dependencies / descriptionPrevious value: -"Step numbers this step depends on"New value: +"Step numbers this step depends on. Validated against existing steps in history."Input schema / properties / estimated_total / descriptionPrevious value: -"Current estimate of total steps needed (can be adjusted)"New value: +"Current estimate of total steps needed. Adjust as you learn more about the problem."Input schema / properties / external_context / descriptionPrevious value: -"External data or tool outputs relevant to this step"New value: +"External data or tool outputs relevant to this step. Store important results here."Input schema / properties / is_final_stepAdded value: +{
+ "description": "Set to true to explicitly mark this as the final reasoning step. The reasoning chain will be marked complete.",
+ "type": "boolean"
+}Input schema / properties / next_action / descriptionPrevious value: -"Next tool or action to use (string or structured object)"New value: +"What you will do next. Can be a simple string or structured object with tool details."Input schema / properties / next_action / oneOfPrevious value: -[
- {
- "description": "Simple next action description",
- "type": "string"
- },
- {
- "description": "Structured action with tool integration",
- "properties": {
- "action": {
- "description": "Action to perform",
- "type": "string"
- },
- "expectedOutput": {
- "description": "What we expect from this action",
- "type": "string"
- },
- "parameters": {
- "description": "Parameters for the action",
- "type": "object"
- },
- "tool": {
- "description": "Tool name if applicable",
- "type": "string"
- }
- },
- "required": [
- "action"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "description": "Simple description of your next action",
+ "type": "string"
+ },
+ {
+ "description": "Structured action with tool details",
+ "properties": {
+ "action": {
+ "description": "Specific action to perform",
+ "type": "string"
+ },
+ "expectedOutput": {
+ "description": "What you expect this action to return",
+ "type": "string"
+ },
+ "parameters": {
+ "description": "Parameters to pass to the tool",
+ "type": "object"
+ },
+ "tool": {
+ "description": "Name of tool to use",
+ "type": "string"
+ }
+ },
+ "required": [
+ "action"
+ ],
+ "type": "object"
+ }
+]Input schema / properties / outcome / descriptionPrevious value: -"Expected or actual result from this step"New value: +"The expected or actual result from this step. What did you learn or accomplish?"Input schema / properties / purpose / descriptionPrevious value: -"What this step accomplishes (analysis, action, validation, exploration, hypothesis, correction, planning, or custom)"New value: +"Category of this reasoning step. Standard values: analysis (examining information), action (taking an action), reflection (reviewing progress), decision (making a choice), summary (consolidating findings), validation (checking results), exploration (investigating options), hypothesis (forming theories), correction (fixing errors), planning (outlining approach). Custom strings allowed in flexible mode."Input schema / properties / rationale / descriptionPrevious value: -"Why using this next action (natural language, no prefix required)"New value: +"Why you chose this next action. Explain your reasoning for the approach."Input schema / properties / revises_step / descriptionPrevious value: -"Step number being revised/corrected"New value: +"Step number you are revising or correcting. The original step will be marked as revised."Input schema / properties / revision_reason / descriptionPrevious value: -"Why this revision is needed"New value: +"Why you are revising the earlier step. What was wrong or incomplete?"Input schema / properties / session_id / descriptionPrevious value: -"Session identifier for grouping related reasoning chains"New value: +"Session identifier for grouping related reasoning chains. Sessions expire after configured timeout."Input schema / properties / step_number / descriptionPrevious value: -"Sequential step number"New value: +"Sequential step number starting from 1. Increment for each new reasoning step."Input schema / properties / thought / descriptionPrevious value: -"Current reasoning. Express naturally without forced prefixes."New value: +"Your current reasoning process. Express naturally - describe what you are thinking and why."Input schema / properties / tools_used / descriptionPrevious value: -"Tools used in this step"New value: +"List of tools you used during this step for tracking purposes."Input schema / properties / uncertainty_notes / descriptionPrevious value: -"Notes about uncertainties or doubts"New value: +"Describe specific uncertainties or doubts. What assumptions are you making? What could be wrong?"crashScored across 1 tool
With only one tool, there is no possibility of ambiguity or overlap between tools. The single tool 'crash' has a clearly defined purpose for structured reasoning steps, so an agent cannot misselect between tools.
Since there is only one tool, naming consistency is inherently perfect. The tool name 'crash' follows a single, consistent pattern with no deviations or mixing of conventions to evaluate.
A single tool is too few for the server's purpose of 'Cascaded Reasoning with Adaptive Step Handling,' which implies a multi-step or complex workflow. While the tool is well-described, a single tool feels thin and incomplete for such a domain, limiting functionality and agent capabilities.
The tool set is severely incomplete for the stated purpose. Although the 'crash' tool supports recording reasoning steps, there are obvious gaps—such as tools for retrieving, updating, or analyzing recorded steps, or for managing the reasoning process (e.g., starting, pausing, or summarizing). This will likely cause agent failures in complex tasks.
Deterministic reasoning stack for AI agents: simulate, decide & compute, plus cross-domain tools.
Multi-expert decision intelligence with transparent synthesis and auditable workflows.
Turn grounded AI answers into trusted comparisons, plans, timelines, and decision views.
Agent-to-agent reasoning-as-a-service: chain-of-thought, analysis, and decision support.
