MCP Shrimp Task Manager — Summary

MCP Shrimp Task Manager (cjo4m06/mcp-shrimp-task-manager) is an MCP server that transforms natural language task requests into structured development tasks with dependency tracking, chain-of-thought reflection, and iterative refinement. It is focused on AI Agents (Claude Code, Cursor, RooCode, Windsurf) and provides 16 MCP tools covering task planning, execution, decomposition, verification, reflection, and research. A optional React-based Task Viewer web UI runs at localhost:5173 for human visibility. Template-driven prompts in src/prompts/templates_en/ allow full customization of agent behavior. The framework emphasizes "chain-of-thought, reflection, and style consistency" — the process_thought tool requires the AI to articulate reasoning before acting. Tasks persist in a JSON file across sessions.

Differs from seeds: closest to taskmaster-ai (MCP server, task decomposition, dependency tracking, JSON persistence, Cursor primary) but Shrimp adds chain-of-thought enforcement via process_thought tool, a reflect_task quality review step, customizable prompt templates, a built-in web UI, and an optional sub-agent assignment system per task.

MCP Shrimp Task Manager — Origin and Philosophy

Origin

Author: cjo4m06. 2,103 stars, 251 forks. MIT license. JavaScript (Node.js). Created April 2025, last push August 2025. Multi-language documentation (10 languages). 18 contributors. Listed on Smithery.ai marketplace.

Philosophy

From README:

"Shrimp Task Manager is a task tool built for AI Agents, emphasizing chain-of-thought, reflection, and style consistency. It converts natural language into structured dev tasks with dependency tracking and iterative refinement, enabling agent-like developer behavior in reasoning AI systems."

Key Philosophical Positions

1. Chain-of-thought before action: process_thought tool forces explicit reasoning articulation. The agent must think before implementing.

2. Reflection as quality gate: reflect_task reviews and improves the approach before marking complete. Not just "done" — "reviewed and done."

3. Style consistency via project rules: init_project_rules creates project-specific coding standards that all tasks follow. The agent learns the project's conventions.

4. Structured task decomposition over ad-hoc planning: complex tasks are always broken into atomic, testable units with explicit dependencies before any implementation begins.

5. Research before planning: research_mode enables systematic exploration of technologies/solutions BEFORE creating a plan — preventing mid-implementation pivots.

Agent System (v1 feature)

Specialized AI agents can be assigned to specific tasks via .claude/agents/ directory. The Task Viewer shows agent assignment dropdowns. Agents bring domain expertise (react-components.md, database-specialist.md) to appropriate tasks.

MCP Shrimp Task Manager — Architecture

Distribution

Clone + npm build:

git clone https://github.com/cjo4m06/mcp-shrimp-task-manager.git
cd mcp-shrimp-task-manager
npm install && npm run build

Or via Smithery.ai marketplace.

Required Runtime

• Node.js 18+
• npm/yarn
• MCP-compatible AI client (Claude Code, Cursor, Cline, Claude Desktop, etc.)

Configuration (.mcp.json)

{
  "mcpServers": {
    "shrimp-task-manager": {
      "command": "node",
      "args": ["/path/to/dist/index.js"],
      "env": {
        "DATA_DIR": "/path/to/shrimp_data",
        "TEMPLATES_USE": "en",
        "ENABLE_GUI": "false"
      }
    }
  }
}

Directory Structure

cjo4m06/mcp-shrimp-task-manager/
├── src/
│   ├── index.ts               # MCP server entry point
│   ├── models/                # Task, dependency models
│   ├── tools/                 # MCP tool handlers
│   │   ├── task/              # Task CRUD tools
│   │   ├── project/           # Project rules tools
│   │   ├── research/          # Research mode tool
│   │   └── thought/           # process_thought tool
│   ├── prompts/               # Template system
│   │   ├── templates_en/      # English prompt templates (16 files)
│   │   ├── templates_zh/      # Chinese prompt templates
│   │   ├── generators/        # TypeScript generators per tool
│   │   └── loader.ts          # Template loader
│   └── public/                # Web GUI static files
├── tools/
│   └── task-viewer/           # React Task Viewer app
│       ├── src/               # React components
│       └── package.json       # port 5173
├── .claude/
│   └── settings.local.json    # Claude Code MCP config
├── shrimp-rules.en.md         # English project rules template
├── shrimp-rules.md            # Chinese project rules template
└── smithery.yaml              # Smithery marketplace config

Target AI Tools

Claude Code (primary), Cursor, RooCode, Windsurf, Cline (VSCode), Claude Desktop. Any MCP-compatible client.

MCP Shrimp Task Manager — Components

MCP Tools (16 total)

Task Management

Advanced Task Operations

Task Memory & History

Project Management

Thought Processing

Template System (src/prompts/templates_en/)

16 customizable template files (one per tool):

• analyzeTask, clearAllTasks, deleteTask, executeTask, getTaskDetail
• initProjectRules, listTasks, planTask, processThought, queryTask
• reflectTask, researchMode, splitTasks, toolsDescription, updateTaskContent, verifyTask

Web UI (Task Viewer)

React app in tools/task-viewer/. Port 5173. Features:

• Task table (sortable by status, agent, date, name, dependencies)
• Color-coded status badges
• Agent assignment dropdown + AI bulk assignment (GPT-4)
• Robot emoji (🤖) copy-task-instruction-to-clipboard
• Multi-profile support
• Dependency navigation (click-to-navigate)
• Lightweight web GUI (lightweight, ENABLE_GUI=true)

Claude Code Settings

.claude/settings.local.json — MCP server config for Claude Code.

MCP Shrimp Task Manager — Uniqueness and Positioning

Differs from Seeds

Closest to taskmaster-ai (MCP server, task decomposition, dependency tracking, JSON persistence, multi-AI-client) but Shrimp adds several elements absent in taskmaster:

1. process_thought MCP tool: enforces chain-of-thought via a dedicated MCP tool call — the agent MUST articulate reasoning through a structured tool before acting. taskmaster has no equivalent.

2. reflect_task quality review: a reflection step after execution that reviews and improves the approach. taskmaster has analyze-complexity but no post-execution reflection gate.

3. Customizable prompt templates: src/prompts/templates_en/ allows full customization of every tool's behavior per project. taskmaster uses hardcoded prompts.

4. Built-in React Task Viewer: taskmaster-ai has a UI via the task-viewer npm package. Shrimp's Task Viewer is bundled in the repo with drag-and-drop, agent assignment, and GPT-4 bulk assignment.

5. Sub-agent assignment system: tasks can be assigned to specialized Claude Code agents (persona files). The Task Viewer's 🤖 copy feature generates the exact command to dispatch a specialized agent to a task. taskmaster has no agent specialization.

6. research_mode tool: systematic technology exploration before planning. taskmaster has no pre-planning research tool.

Positioning

Shrimp targets developers who want rigorous, reflection-driven task execution with visible reasoning. The chain-of-thought + reflection philosophy makes it suitable for complex, multi-step projects where understanding WHY the agent made decisions matters as much as the outcome.

Observable Failure Modes

1. Prompt template coupling: customized templates in templates_en/ must be maintained alongside server updates — template schema changes can break customizations.
2. GPT-4 bulk assignment: the AI-powered agent assignment feature requires an OpenAI API key and network access — a surprising external dependency in what is otherwise a local MCP server.
3. DATA_DIR misconfiguration: tasks.json path is configured via env var — wrong path means agents start fresh each session.
4. Last push August 2025: ~9 months since last commit as of May 2026 — possible maintenance stagnation.