Skip to main content
Glama
Sign In
morpheus-mcp

morpheus-mcp

by evo-hydra
OverviewSchemaSourceRelated ServersDiscussionsAdmin
Python
Remote

morpheus-mcp

Plan state management and phase gate enforcement for AI dev loops via MCP. Morpheus tracks plan progress, enforces phase gates with evidence requirements, and coordinates task lifecycle across agents.

Part of EvoIntel

Morpheus is one server in a suite designed to work together. Each handles a different concern in the AI development loop:

Server

Role

Morpheus

Plan state & phase gate enforcement (you are here)

Sentinel

Persistent project intelligence — conventions, pitfalls, co-changes

Seraph

Verification intelligence for AI-generated code

Niobe

Runtime intelligence & log analysis

Merovingian

Cross-repo dependency tracking & contract management

Anno

Web content extraction via stealth browser

Each server runs independently, but they reinforce each other. Morpheus orchestrates the dev loop. Sentinel and Seraph provide the intelligence Morpheus gates on. Niobe watches runtime. Merovingian tracks what breaks across repos.

→ github.com/evo-hydra

Related MCP server: task-graph-mcp

Install

pipx install morpheus-mcp

MCP Tools

Tool

Description

morpheus_init

Load a plan file, parse tasks, begin tracking

morpheus_status

Plan progress, task states, active phase

morpheus_advance

Advance a task through a phase gate with evidence

morpheus_close

Mark a plan as completed

Phase Gates

Each phase requires evidence before advancing:

Phase

Required Evidence

CHECK

(none)

CODE

fdmc_preflight with 4 lenses (consistent must include sibling_read)

TEST

build_verified

GRADE

tests_passed

COMMIT

seraph_id (skipped if plan has grade: false)

ADVANCE

knowledge_gate

CLI

morpheus init plans/my-plan.md    # Load a plan
morpheus status                   # Show progress
morpheus advance <task-id> CHECK  # Advance a phase
morpheus close <plan-id>          # Close the plan
morpheus list                     # List all plans

MCP Configuration

Add to your .mcp.json or ~/.claude.json:

{
  "mcpServers": {
    "morpheus": {
      "command": "morpheus-mcp",
      "args": []
    }
  }
}

License

MIT

Available Tools

10 tools
morpheus_advanceA

Advance a task through a phase gate with evidence.

Validates that the evidence satisfies the gate requirements. Returns success with next phase instructions, or rejection with details on what's missing.

Args: task_id: The task ID to advance phase: Phase name: CHECK, CODE, TEST, GRADE, COMMIT, or ADVANCE evidence: JSON string with evidence key-value pairs skip_reason: When provided, fills missing evidence keys to bypass the gate. Use for intentional skips (e.g., "greenfield — no diff for Seraph"). Recorded in evidence for auditability.

Inputs: task_id (required), phase (required), evidence, skip_reason. Returns: result

morpheus_advance_batchA

Advance multiple tasks through phase gates in a single call.

Processes each advance sequentially. Stops at the first failure. Accepts a JSON array of objects with keys: task_id, phase, evidence.

Args: advances: JSON array of {task_id, phase, evidence} objects

Inputs: advances (required). Returns: result

morpheus_closeA

Mark a plan as completed and return final summary.

Args: plan_id: The plan ID to close

Inputs: plan_id (required). Returns: result

morpheus_gate_summaryA

Summarize gate outcomes: how often each gate fired, caught issues, changed code.

Returns lifetime stats across all plans if plan_id is omitted. Use this to identify which gates produce value and which are ceremony.

Args: plan_id: Optional plan ID to scope the summary

Inputs: plan_id. Returns: result

morpheus_initA

Load a plan file into Morpheus and begin tracking state.

Parses the markdown plan file, saves plan and tasks to the store, and returns a summary with task list and IDs.

Args: plan_file: Filesystem path to the plan markdown file

Inputs: plan_file (required). Returns: result

morpheus_oil_changeA

Record an oil change (macro-lens health check) for a plan.

Call this after running sentinel_health_check and reviewing the results. Clears any oil_change_due advisory on the plan.

Args: plan_id: The plan ID to record the oil change for health_check_id: The sentinel_health_check result ID commits_since_last: Number of commits since last health check

Inputs: plan_id (required), health_check_id (required), commits_since_last. Returns: result

morpheus_progressA

Log progress for a task without advancing phases.

Purely observational — records a timestamped message for the task. Visible in morpheus_status output for the active task.

Args: task_id: The task ID to log progress for message: Progress message to record

Inputs: task_id (required), message (required). Returns: result

morpheus_reflectA

Record whether a gate caught a real issue or was ceremony.

Call this after each gate fires to build the Reflect dataset. Over time, this data reveals which gates produce value and which burn tokens without changing behavior.

Args: plan_id: The plan ID task_id: The task ID gate: Gate name (e.g., "sibling_read", "fdmc_review", "seraph_assess", "knowledge_gate") caught_issue: True if the gate found something actionable changed_code: True if code was modified because of this gate detail: Brief description of what happened (e.g., "matched singleton pattern from sibling" or "no issues found")

Inputs: plan_id (required), task_id (required), gate (required), caught_issue, +2 more. Returns: result

morpheus_statusA

Get current plan progress, task states, and active phase.

If plan_id is omitted, returns the most recently created plan.

Args: plan_id: Plan ID (optional — defaults to most recent plan)

Inputs: plan_id. Returns: result

morpheus_versionA

Return Morpheus server version, plan schema version, and Python version.

No arguments required. Use for introspection and compatibility checks.

Inputs: no named parameters. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Deploy Server
    Claude Code, inside the Godot 4 editorFlockbay puts an AI agent in the real Godot 4 editor: it writes GDScript, runs your game and fixes what breaks. Free, or bring your own Claude Code or Codex.flockbay.comAd

    TDQS

    A4.3/5.0

    Scored across 10 tools

    Disambiguation5/5

    Each tool has a distinct purpose with clear boundaries: morpheus_advance and morpheus_advance_batch handle phase progression, morpheus_close finalizes plans, morpheus_gate_summary provides analytics, morpheus_init loads plans, morpheus_oil_change records health checks, morpheus_progress logs observations, morpheus_reflect captures gate effectiveness, morpheus_status shows current state, and morpheus_version offers introspection. No tools overlap in functionality.

    Naming Consistency5/5

    All tools follow a consistent 'morpheus_verb' or 'morpheus_verb_noun' pattern with snake_case throughout. The naming is predictable and readable, such as morpheus_advance, morpheus_status, and morpheus_gate_summary, with no deviations in style.

    Tool Count5/5

    With 10 tools, the set is well-scoped for a project management and tracking system. Each tool serves a specific role in the lifecycle of plans and tasks, from initialization to closure and analytics, with no redundant or missing operations.

    Completeness5/5

    The toolset provides complete coverage for the domain of plan and task management: initialization (morpheus_init), progression (morpheus_advance, morpheus_advance_batch), logging (morpheus_progress), health checks (morpheus_oil_change), analytics (morpheus_gate_summary, morpheus_reflect), status monitoring (morpheus_status), closure (morpheus_close), and introspection (morpheus_version). There are no obvious gaps in the workflow.

    Resources

    Related MCP Connectors

    Related MCP Servers

    • taskguard-mcp

      lhao17202-hue
      A
      license
      A
      quality
      D
      maintenance
      Provides AI agents with a lightweight task-management and self-verification layer to define goals, track checkpoints, detect scope drift, and verify completion against explicit done criteria.
      12
      MIT

    • Agent NextUp

      white1024
      A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI agents to maintain project continuity through a file-based state hub with tasks, phases, and handoff snapshots. Provides MCP tools for reading and updating project state, with gatekeeping enforced via real-state evaluation and per-tool authorization.
      3
      MIT

    Appeared in Searches