Wire Pathmode Into Your Coding Agent

An engineer pastes a Linear ticket into Cursor: "payment step is slow, fix it." Nine minutes later — a retry loop, clean diff, passing tests, merged. Two days later support is on fire: the retry double-charges customers on timeout. That edge case existed; it just lived in a Slack thread, not the ticket.

The agent didn't lack skill. It lacked the intent — the objective, the "no double-charge on retry" constraint, the verification that would have caught it. The fix isn't a better prompt. It's wiring the agent to the layer that already holds that judgment.

The handoff gap: agents inherit context, not judgment

Pasting a ticket gives the agent context — what's broken. It doesn't give judgment — what it must not break, and how you'll know it worked. Three layers get conflated at the handoff:

• Pathmode = the Why — the intent: objective, evidence, constraints, verification.
• Your coding agent = the How — the code in the repo.
• Linear / Jira = the When — the ticket, the sprint, the status.

The MCP server is the wire between the Why and the How. Context isn't judgment — the wire hands the agent both.

Two ways in: local mode vs. team mode

Start wherever you are:

• Local mode — npx @pathmode/mcp-server --local reads and writes an intent.md in your repo. No signup, no key, fully offline. The Intent Compiler runs here.
• Team mode — a workspace API key syncs to your Pathmode workspace and unlocks evidence, the dependency graph, Constitution rules, and context shared across every agent session.

Same tool names, more capability. If you just want to feel it, start local.

npx @pathmode/mcp-server@latest setup pm_live_...

setup validates your key against your workspace, then auto-detects and writes the MCP config for Claude Code, Claude Desktop, Cursor, and Windsurf at their real config paths. Nothing else to wire by hand.

Prefer to wire it by hand (or run keyless)? A pathmode MCP entry looks like this:

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

For zero-config local mode, drop the env and add "--local" to args. Restart your editor so it picks up the new server.

Don't memorize all twenty. They group by what they do for you:

• Read the intent — get_current_intent, get_agent_prompt, get_constitution, query_evidence
• Build from intent — create_intent, update_intent, link_evidence
• Close the loop — verify_implementation, update_intent_status, log_implementation_note
• See the system — analyze_intent_graph, search_intents

get_agent_prompt takes a mode — draft (critique the spec) or execute (implement it) — and returns the full 8-part spec. For agents that read files instead of MCP, export_context emits claude-md, cursorrules, intent-md, or an outcome-rubric. (Two of the twenty — intent_save and intent_export — power the keyless local compiler, so the count holds even with no API key.) The full per-argument reference lives at /developers — this guide stays a workflow, not an API dump.

npx @pathmode/mcp-server install-skills          # project (.claude/skills/)
npx @pathmode/mcp-server install-skills --global  # global (~/.claude/skills/)

This is a separate command from setup — the server is the wire; the skills are the layer that makes the workflow feel native. Seven ship, in lifecycle order:

setup-pathmode-workflow · compile-intent · grill-intent · verify-intent · split-intent-to-issues · review-against-intent · handoff-intent

They auto-trigger: Claude Code reads each skill's description at session start and runs the match when you say "help me write a spec for checkout" — no slash command to memorize.

Here's the loop the opening incident was missing, using only shipped pieces:

1. "Help me turn this payment ticket into a spec." → compile-intent runs Socratically — it proposes its best guess each turn instead of just interrogating — and drafts the 8-part IntentSpec.
2. grill-intent pressure-tests the weakest claim field by field — and surfaces the "what happens on a timeout retry?" edge case the ticket never mentioned.
3. verify-intent designs the feedback loop — fastest check, manual fallback, production signal, what must not regress — so the spec is agent-ready, not just written.
4. The agent calls get_agent_prompt (execute mode) and receives the 8 parts with Constraints & Constitution merged — so "no double-charge on retry" is in the prompt whether or not this author remembered it.
5. It implements, recording decisions with log_implementation_note.
6. review-against-intent checks the result against the spec, and the verify_implementation tool AI-grades each outcome and constraint.
7. update_intent_status moves it to shipped, and handoff-intent writes the decisions back so the next session inherits them.

That's the close-the-loop the pasted ticket never had.

Why this is a wire, not a wrapper

Your agent stays your agent — Cursor's autocomplete, Claude Code's reasoning, untouched. Pathmode doesn't compile a contract the agent must obey; it hands over judgment under evidence the agent can reason with and push back on.

The anti-pattern is pasting a frozen spec and calling it done — that's how you get the double-charge. The 8-part spec travels with the work because it's wired, not copy-pasted: every session reads the current intent, the merged Constitution, and the verification the team agreed on.

For what the 8 parts mean, see The Anatomy of an Agent-Ready Spec; for the review ritual around them, The Intent Spec as Alignment Artifact.

Common questions

Do I need a Pathmode account? No. Local mode reads an intent.md with no key. A workspace key adds evidence, the dependency graph, and Constitution rules shared across sessions.

Which agents does this work with? The MCP server works with any MCP client — Claude Code, Cursor, Windsurf, Claude Desktop. The skill pack is Claude Code–specific (it installs into .claude/skills/).

Does it change how my agent writes code? No. It changes what your agent knows before it writes — objective, constraints, edge cases, and how to verify. The reasoning is still your tool's.

Is verify-intent a tool or a skill? A skill. It designs the verification loop (the five dimensions) and logs each one — in team mode via log_implementation_note. AI-grading a finished implementation is a separate step: the verify_implementation tool, which the review-against-intent skill drives. There's no standalone verify-intent tool.

For team mode, run setup with your workspace key, then ask your agent to "help me write a spec for [your problem]." For keyless local mode, add the --local config and start from an intent.md — no account required.

Open Pathmode →