Review what Codex proposes,
before it builds.
Codex drafts the change from your request and repository. Your team reviews and approves the revised proposal in Pathmode, then keeps the decision and its reason available for later coding sessions. Teammates who never run Codex can question the proposed behavior and request changes from their browser.
> Calling tool: get_agent_prompt
> Reading the repository intent and connected review state...
title: "Cancel plan without ending paid access"
outcomes: Access continues through the paid period; ends at period close
correction: Applied; awaiting the product manager’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 a Cancel plan button. The proposal ends access immediately. The product manager settles the access timing 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 manager corrects
Compare the request with “What the agent understood.” Record the decision to keep access active through the period the customer already paid for. 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 manager 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 cancellation with time left in the paid period and at period close; 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 →Ready to try it? Set up reviews for your coding agent →
A later coding session
Give Codex the reason behind the decision.
Maria approved keeping paid access until the period ends. When Sam brings a related request to Codex, the connected agent can read that earlier decision and its reason before proposing the change.
The earlier approval covers the cancellation revision. A new cleanup proposal still needs its own review and approval.
Follow the complete review →- Maria’s earlier decision
- Keep access through the paid period.
- Why
- The customer has already paid for access through that date.
- Sam’s new request
- “Clean up canceled accounts.”
- Codex uses the decision
- “I’ll keep accounts with paid access until their billing period ends, following Maria’s decision.”
Context isn't judgment
Coding agents can ask useful product questions. Pathmode gives the product manager 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 manager 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 manager 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
From team review to the next request
Agree on the behavior, build from the approved revision, and keep the reason available when related work comes up.
Review together
Compare the request and proposal; settle the open choices
Approve the revision
The responsible person approves the revised intent.md
Codex
Build from the approved intent beside the code
Keep the reasoning
Saved decisions and open findings inform later connected work
Codex names the intent on the pull request
With GitHub connected, linking the pull request lets Pathmode review the diff before merge and check the merged changes afterwards. Both checks are advisory. Include any one of these references on the branch or in the PR body:
pathmode:<uuid>intent/<uuid>Resolves PAT-<uuid>Closes PAT-<uuid>Fixes PAT-<uuid>Workflows that carry the agreed decision
Example requests for connected coding sessions. Codex uses Pathmode tools to read the review state and return changes for a person to approve.
“Draft this change for team review”Bring the proposal to the team
Start with the request and repository. Attach the original request, propose the behavior, and leave unresolved product choices open for the team.
“Apply the team’s correction”Return the revision for approval
Read the correction against the revision it refers to. Apply it or explain the conflict, then return the updated proposal for the responsible reviewer to approve.
“Implement my approved intent”Build from the agreed decision
Check readiness, authorization, and open corrections before implementing. Run the applicable checks and link the intent to the pull request for advisory diff review.
“Read the earlier decision before proposing this change”Use the reasoning in related work
Read the relevant intent, its saved decisions, and open implementation findings. Use that context to prepare the new proposal and bring conflicts back to the team. Earlier approval does not authorize the new work.
35 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
get_review_feedbackRead the reviewer’s written requests and follow-ups
respond_review_feedbackExplain how the revised proposal answers them
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)
answer_product_choiceRecord a person's answer to a product choice, marked unverified (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
Abbreviated connected response from get_current_intent
{
"title": "Fix checkout payment timeout",
"objective": "Reduce cart abandonment caused by payment step timeouts exceeding 3 seconds",
"problemSeverity": "critical",
"outcomes": [
{ "id": "outcome-payment-time", "text": "Payment completes in under 3 seconds (p95)" },
{ "id": "outcome-payment-status", "text": "Users see real-time status during processing" },
{ "id": "outcome-payment-retry", "text": "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" }
],
"evidenceSummary": {
"citedCount": 3,
"linkedCount": 3,
"anchoredSections": 0
}
}The default response includes an evidence summary. Pass include_evidence: true to include cited evidence grouped as backing, unreviewed, or assumption, with counts for each tier. Citation counts alone do not establish reviewed backing. For implementation, start from the repository’s intent.md: get_current_intent selects across the connected workspace.
A workflow with review checkpoints
Pathmode instructs Codex to orient, plan, implement, and validate against the agreed spec.
Orient
Read relevant source files. Understand existing patterns and conventions. Identify conflicts between spec and codebase.
Review checkpoint — 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 the intent’s constraints and the enforcement level of each constitutional rule. 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.
Instructions and authorization
The workflow asks the agent to inspect the repository, map changes to outcomes, and run verification. Following those instructions still depends on the agent.
In connected mode, the server checks readiness, open corrections, and required authorization before returning an execution prompt. An agent-originated repository proposal requires a signed-in person to authorize that exact revision. These checks govern access to the execution prompt; they do not control every action the coding agent takes.
Ask the agent to confirm its understanding before implementation
Plan changes against each outcome in the spec
Include constitutional rules and their enforcement levels
Review the implementation against the intent and run its checks
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.
Install locally, then connect your team
One config file to start locally. Adopt your repository intent when you’re ready for team review.
Solo — no account needed
Intent Compiler + local specs
[mcp_servers.pathmode]
command = "npx"
args = ["@pathmode/mcp-server"]Workspace API access
For tools that need a workspace without adopting a local intent
[mcp_servers.pathmode]
command = "npx"
args = ["@pathmode/mcp-server"]
env = { PATHMODE_API_KEY = "pm_live_..." }Connect a repository intent for team review
Once you have saved intent.md, run this command from its repository. Open the printed link, enter the code, and approve the workspace and product in your browser. Adoption binds the repository intent to that workspace and configures its credentials; adding an API key alone does not establish that binding.
npx @pathmode/mcp-server@latest adoptIf the command reports AUTHORIZATION_PENDING, run it again after browser approval. Restart or reconnect your MCP client after adoption, then ask the agent to attach the original request and share the proposal’s review link.
Ask the agent to run npx @pathmode/mcp-server@latest watch-review in the background to receive review changes. Use --build when you asked it to implement, or --no-build for a proposal only. After applying answers, restart the listener without either flag. Implementation still requires authorization of the revised proposal and a successful execution-readiness check.
Get your API key from Settings → API Keys in your Pathmode workspace. With no configured or saved API key, 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.
Review together.
Keep the reasoning for later.
Review what Codex proposes, approve the revised plan, and carry your team’s decisions into the work that follows.
No credit card required · Free for solo builders