Give Codex judgment,
not just context.
Codex can build anything. Knowing what’s worth building — and what done means — lives outside the repo. Pathmode’s MCP server carries it in: intent specs anchored to real user evidence, constraints that can’t be skipped, and verification against outcomes.
> Calling tool: get_agent_prompt
> Fetching intent spec, evidence, and constitution...
title: "Fix checkout payment timeout"
outcomes: 3 testable conditions
evidence: 3 friction reports, 1 quote, 1 drop-off metric
constitution: 4 mandatory constraints
> Ready. Starting Phase 1: Orient...
Context isn't judgment
Agents already have the repo, the docs, the prompt. What they're missing is the judgment behind them — which user pain matters, what done means, what must not break.
Without Pathmode
- ×Requirements scattered across Notion, Jira, Slack, and your head
- ×Agent sees a prompt — not the user pain behind it
- ×No dependency awareness — new code breaks old flows
- ×Verification is a manual vibe check
- ×"Done" means it compiled, not that it solved the problem
With Pathmode
- Every spec traces to real user friction, quotes, and metrics
- Agent gets objective, outcomes, constraints, and edge cases
- Dependency graph prevents breaking upstream flows
- Phase-gated execution: orient, plan, implement, validate
- AI verification scores your work against the spec
The closed-loop system
Evidence flows in. Code flows out. Verification loops back.
Reviewed evidence
Friction, quotes, metrics a person reviewed and backed
Intent Spec
Objective, outcomes, constraints, edge cases
Codex
Orient → Plan → Implement → Validate
Graded on merge
The merge reads the real diff, grades it against the spec, and flips it to shipped
Codex names the intent on the pull request
The MCP tools teach the agent to name the intent on the branch or in the PR body, so the merge can grade the real diff and flip it to shipped. Any one of these references is enough:
pathmode:<uuid>intent/<uuid>Resolves PAT-<uuid>Closes PAT-<uuid>Fixes PAT-<uuid>Complete workflows, not just tools
Pathmode’s MCP tools give Codex entire execution workflows. One ask orchestrates everything — context, constraints, implementation, and verification.
“Implement my active intent”Implement an intent
Fetches the full spec with evidence and constraints, creates a phase-gated execution plan, implements it, AI-grades the result, and names the intent on the branch so the merge can grade the real diff and flip it to shipped.
“Create an intent from our evidence”Create intent from evidence
Queries the signals captured for a product, looks for recurring friction and high-severity items, and drafts an intent spec from them. The links it creates are general context, not reviewed backing: a person still has to review each signal and use it as backing for an exact claim.
“Review our architectural risks”Review architectural risks
Analyzes your intent graph for circular dependencies, bottlenecks, stalled work, and status mismatches. Suggests concrete actions.
“What should I work on next?”What should I work on next?
Finds the highest-impact approved intent based on the critical path and what it unblocks. One recommendation, with reasoning.
33 tools under the hood
Read, write, analyze, and verify — the full intent lifecycle via MCP.
Read
get_current_intentActive intent with full spec
get_intentSingle intent by ID
get_intent_evidenceDereference repo-safe evidence IDs
propose_spec_changePropose a correction for a person to accept
list_intentsAll intents, filter by status
search_intentsKeyword search across specs
query_evidenceSearch evidence by type, severity, text
list_intent_change_requestsDiscover structured PM requests
get_intent_change_requestRead one exact revision-bound request
Write
create_intentCreate a new intent spec
update_intentUpdate spec content
create_evidenceCapture a signal; it lands Unreviewed
attach_original_requestAttach the ticket you were handed, word for word, so the reviewer sees it beside your reading
link_evidenceAttach evidence to an intent as general context
log_implementation_noteRecord technical decisions
record_implementation_contextHand back what the repo looks like where this lands
record_implementation_findingWrite back what the build contradicted
record_outcome_measurementRecord whether a shipped outcome moved
reject_intent_change_requestReturn an unworkable PM request with a reason
Agents can capture signals. Only a signed-in person can review a signal and turn it into backing for an exact claim. An API key cannot review, attribute, or promote evidence to backing.
Analyze
check_intent_readinessPreflight a spec: six deterministic gates
confirm_intent_dimensionResolve an unconfirmed gate: confirm in your own words, or waive
analyze_intent_graphCritical path, bottlenecks, cycles
get_intent_relationsDependency graph for one intent
get_workspaceStrategy, vision, principles
get_constitutionMandatory constraint rules
get_agent_promptFull execution prompt for an intent
Act
verify_implementationAI-grade work against the spec
update_intent_statusMark verified; PR merges mark shipped
export_contextCLAUDE.md, .cursorrules, intent.md
intent_saveSave spec to intent.md (no API key)
intent_exportExport as agent config or an OpenSpec change (no API key)
intent_importAdopt an existing OpenSpec change as the intent (no API key)
sync_contextRound-trip context into CLAUDE.md
What Codex sees when it calls get_current_intent
{
"title": "Fix checkout payment timeout",
"objective": "Reduce cart abandonment caused by payment step timeouts exceeding 3 seconds",
"problemSeverity": "critical",
"outcomes": [
"Payment completes in under 3 seconds (p95)",
"Users see real-time status during processing",
"Failed payments show actionable error with retry"
],
"constraints": [
"No double-charge on retry",
"Must support iOS Safari 15+",
"Respect existing RBAC permissions"
],
"edgeCases": [
{ "scenario": "Network timeout during payment", "expectedBehavior": "Show retry button, no double-charge" },
{ "scenario": "Unknown provider status", "expectedBehavior": "Hold order, notify user within 30s" }
],
"evidence": [
{ "type": "friction", "severity": "critical", "content": "Payment spinner hangs for 8s with no feedback" },
{ "type": "metric", "content": "42% drop-off rate at payment step" },
{ "type": "quote", "content": "I thought the page was broken so I closed the tab" }
]
}Phase-gated execution
Pathmode doesn’t just hand over a spec. It structures how Codex works through it.
Orient
Read relevant source files. Understand existing patterns and conventions. Identify conflicts between spec and codebase.
Gate — confirm understanding before proceeding
Plan
List every file to change. Map changes to outcomes. Order by dependencies. Every outcome in the spec must be covered.
Implement
Execute in dependency order. Respect all constraints — constitutional rules are non-negotiable. Pause and reassess on unexpected behavior.
Validate
AI-verify against every outcome, constraint, and edge case. Get a pass/fail score with reasoning. Fix failures, re-verify. Stamp the intent on the PR; the merge marks it shipped.
Not just fast. Correct.
Most agents race straight to implementation. They hallucinate forward — writing code before understanding context, skipping verification because nothing told them not to.
Pathmode’s phase-gated prompts force Codex to orient first, plan second, implement third, and validate last. The gates aren’t suggestions — they’re checkpoints baked into the execution prompt.
Agent confirms understanding before writing a single line
Every outcome in the spec maps to a planned change
Constitutional constraints can't be skipped or forgotten
AI verification scores your work, not just a vibe check
Start without signing up
The Intent Compiler works with zero configuration. No API key, no account. Just add the MCP server and describe a problem.
> Help me write an intent spec for our checkout flow
What's broken about it? When you say "checkout flow" — is the whole thing failing, or is there one specific moment where users bail?
> Payment step times out and users get confused
When you say "times out" — is that 5 seconds or 30? And what does the user actually see?
> About 8 seconds, they see a spinner with no feedback
> Using tool: intent_save
Saved intent spec to intent.md
Socratic product thinking
Codex pushes back on vagueness. It asks pointed questions until the spec is specific, testable, and grounded in real user pain. No pleasantries, no hand-waving.
What gets saved
intent.mdStructured spec with YAML frontmatter — objective, outcomes, edge cases, verification
.cursorrulesAgent-directive format for Cursor, Windsurf, and other AI tools
AGENTS.mdAppends a Pathmode section so Codex sees the intent in every conversation
Ready for more? Add an API key to unlock shared evidence with trust tiers, dependency graphs, team workflows, and AI verification. The local spec promotes seamlessly into your Pathmode workspace.
Setup in under 2 minutes
One config file. That’s it.
Solo — no account needed
Intent Compiler + local specs
[mcp_servers.pathmode]
command = "npx"
args = ["@pathmode/mcp-server"]Team — full workspace
Evidence, graphs, governance, verification
[mcp_servers.pathmode]
command = "npx"
args = ["@pathmode/mcp-server"]
env = { PATHMODE_API_KEY = "pm_live_..." }Get your API key from Settings → API Keys in your Pathmode workspace. Leave the key out and the server starts in local mode, reading and writing intent.md in your project. Add --local to force local mode even when a key is set.
Stop pasting specs.
Start shipping intents.
Give Codex judgment, not just context.
No credit card required · Free for solo builders