Review what Codex proposes,
before it builds.
Codex drafts the change from your request and repository. In Pathmode, the product owner reviews its interpretation, sends corrections, and authorizes the revised proposal the engineer will implement.
> Calling tool: get_agent_prompt
> Reading the repository intent and connected review state...
title: "Export all matching customers"
outcomes: All matching pages; active filters preserved
correction: Applied; awaiting the product owner’s review
authorization: Pending for this revision
> Waiting for authorization before implementation.
Connected team workflow · illustrative example
Review what the agent understood.
The request asks for every customer matching the active filters. The proposal exports only the current page. The product owner catches the difference before authorizing the build.
1. The agent proposes
Give Codex the original ticket or brief. Ask it to draft the repository intent with assumptions labeled and attach the original request to the connected proposal.
2. The product owner corrects
Compare the request with “What the agent understood.” Send a correction: export all matching pages while preserving the active filters. Choosing a recommendation prepares a correction; it does not authorize implementation.
3. The revision returns for review
The repository agent applies the correction or reports why it cannot. The product owner inspects the applied change and the rest of the proposal, then authorizes that revision when it is right.
4. The engineer verifies the result
Codex implements from the authorized intent.md and runs the applicable checks. Test a filtered list spanning multiple pages; bring new limitations or contradictory findings back for review.
Connect the repository through repository setup, or invite the teammate who runs the coding agent. Local tools remain usable without an account; shared corrections and signed-in authorization require a connected workspace.
Follow the complete proposal review →Context isn't judgment
Coding agents can ask useful product questions. Pathmode gives the product owner a shared place to compare the proposal with the request and settle the decisions that govern the build.
Questions for your current workflow
- ?Can the product owner find the original request?
- ?Can they inspect the proposed behavior before the build?
- ?How does a correction reach the repository agent?
- ?Which revision did the product owner authorize?
- ?How is the result checked against the agreement?
Review in Pathmode
- Original request attached beside the proposal
- Proposed behaviors available for inspection and correction
- Corrections returned to the repository agent
- Signed-in authorization of the proposal revision
- Implementation checks and findings tied to the intent
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>Workflows that carry the agreed decision
Pathmode’s MCP tools give Codex entire execution workflows. Execution still depends on readiness, resolved corrections, and any required human authorization.
“Implement my active intent”Implement an intent
Reads the repository intent and connected review state, checks readiness and authorization, and resolves open corrections before implementing. The agent runs verification and links the intent to the pull request for diff-based review.
“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
Implementation review checks the result against the intent
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? Use repository setup to adopt a local intent into the selected workspace. Connected tools add shared evidence, corrections, revision authorization, and implementation findings.
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.
Review the proposal. Then build.
Review what Codex proposes, then authorize the revision to build.
No credit card required · Free for solo builders