Pathmode MCP Server

MCP server that connects Claude Code, Cursor, and AI agents to Pathmode's Intent Layer for structured product specs, dependency graphs, and strategic context.

Collaboration by Pathmode.io API Key active

GitHub Docs npm: @pathmode/mcp-server

Overview

Pathmode's MCP server links AI coding agents (Claude Code, Claude Desktop, Cursor) to the Pathmode Intent Layer, a system for capturing structured product intents, their dependencies, and the strategic context an agent needs to implement them well. It exposes two surfaces: the offline Intent Compiler, which runs a Socratic dialogue with the user to turn fuzzy requirements into a structured intent.md spec, and a set of team-oriented tools that read and write intents, workspace rules, and dependency analyses from a Pathmode workspace.

The team-tier tools let agents pull the current intent, search across all intents, walk the intent dependency graph, identify bottlenecks or circular dependencies, and update status as work progresses. Agents can also fetch workspace context and a "constitution" of governance rules so generated code stays consistent with team standards. Specs export to intent.md, .cursorrules, or CLAUDE.md so the same source of truth works across tools.

Notable points: no signup is required to use the Intent Compiler (it works entirely offline with no data sent to Pathmode), and the package installs via npx with a single config block. Team features require a pm_live_... API key from pathmode.io.

Tools

Tool	Description
`intent_save`	Persist the current intent spec to an intent.md file in the project.
`intent_export`	Export the intent in alternate formats such as .cursorrules or CLAUDE.md for use with other AI tools.
`get_current_intent`	Return the active intent for the current workspace.
`list_intents`	List all intents in the workspace.
`search_intents`	Search intents by keyword or attribute.
`update_intent_status`	Update the status of an intent (e.g. as work progresses through a phase gate).
`log_implementation_note`	Attach an implementation note to an intent for traceability.
`analyze_intent_graph`	Analyze the dependency graph of intents for critical path, bottlenecks, cycles, and stalled work.
`get_intent_relations`	Return upstream and downstream relations for a given intent.
`export_context`	Export strategic context bundled for an AI agent to consume.
`get_agent_prompt`	Return a tailored prompt for the agent based on the current intent and workspace.
`get_workspace`	Return workspace metadata and settings.
`get_constitution`	Return the workspace constitution: governance rules the agent should follow.
`compile-intent`	Prompt that drives the Socratic Intent Compiler dialogue to build a structured spec.
`implement-intent`	Prompt that guides an agent through implementing a given intent.
`review-risks`	Prompt that reviews architectural risks for the current intent or graph.
`what-next`	Prompt that suggests the next highest-priority intent based on dependencies and status.

Setup Guide

Prerequisites

Node.js with npx available
For team features: a Pathmode workspace and API key from pathmode.io Settings (format pm_live_...)
No signup needed for the offline Intent Compiler

Install (no auth, Intent Compiler only)

Add to .claude/settings.json, claude_desktop_config.json, or .cursor/mcp.json:

{
  "mcpServers": {
    "pathmode": {
      "command": "npx",
      "args": ["@pathmode/mcp-server"]
    }
  }
}

Install (team features with API key)

{
  "mcpServers": {
    "pathmode": {
      "command": "npx",
      "args": ["@pathmode/mcp-server"],
      "env": {
        "PATHMODE_API_KEY": "pm_live_..."
      }
    }
  }
}

Local mode

To force local-only operation against an intent.md file in the project, add --local to args:

{
  "command": "npx",
  "args": ["@pathmode/mcp-server", "--local"]
}

The API key can also be configured in ~/.pathmode/config.json instead of the MCP env block.

Use Cases

Turn a vague product idea into a structured intent.md spec through a Socratic dialogue in Claude Code or Cursor, with no signup required.
Pull the current intent and workspace constitution before an agent implements code so generated output respects team governance rules.
Run analyze_intent_graph to surface bottlenecks, circular dependencies, and stalled intents across a multi intent roadmap.
Use what-next to have the agent pick the next highest priority intent based on dependency analysis and current status.
Export the active intent as .cursorrules or CLAUDE.md so the same source of truth drives multiple AI coding tools.

Example Prompts

"Compile an intent for adding SSO to our admin dashboard, then save it as intent.md."
"Analyze the intent graph and tell me which intents are blocking the most downstream work."
"What should I work on next? Use Pathmode to look at dependencies and statuses."
"Show me the upstream and downstream relations for the billing-refactor intent."
"Export the current intent as a .cursorrules file and update its status to in_progress."

Pros

Official package maintained by Pathmode under the pathmodeio GitHub org.
Works offline with no signup for the Intent Compiler, lowering the barrier to trying it.
Covers strategy (graph analysis, governance) on top of plain spec storage, which is unusual for an AI dev tool.
Multi client setup: Claude Code, Claude Desktop, and Cursor all use the same npx command.

Limitations

Dependency graph, governance, and workspace tools require a paid Pathmode API key; only the Intent Compiler is fully free.
Tool input schemas are not exhaustively documented in the README, so exact parameters often have to be discovered at runtime.
Value depends on adopting Pathmode's Intent Layer concept; teams without an intent workflow get limited benefit.

Alternatives

Linear MCP server for issue and project tracking with AI agents.
Notion MCP server for spec and doc storage accessible to agents.
dependency-graph-mcp for a lightweight, self hosted dependency graph for agent task tracking.