Plan the work before the agent writes the code.

Throw a prompt at an agent and it guesses. ProPR plans first. You see the exact context it gathered, fix its assumptions, and shape the architecture before you spend a token on implementation. Measure twice, cut once.

Context engine Plan ready

Prompt GitHub Issue Repo To-Do

Context Gathering

Repo Index Screenshots/Files

Preview Cost & Tokens Refine & Chat

Approved PlanLinked GitHub Issues

Planning gathers prompt, issue, repository, file, and screenshot context before ProPR creates the approved plan.

A `--dry-run` for your agent.

The agent writes a spec before it edits a file. You set the change, the context files and the acceptance criteria, and fix a wrong approach while it is still cheap.

The plan follows the work into the PR.One change, 75 seconds, from the first prompt to the merged pull request.

Catch architectural flaws before they become commits.

Repository, branch, requirements, acceptance criteria and chat history sit in front of you before any agent runs.

Reviewing a plan: the payment-and-review step with its requirements and acceptance criteria, beside the assistant chat that reshaped it — Acceptance criteria and the refinement assistant, side by side, before implementation.

From an idea to execution in four steps.

Any model drafts a plan. Checking its assumptions is the real work, and ProPR puts you in charge of it.

A plan request in plain words, couriers losing signal in basements, with a screenshot of the failed upload attached

Start the draft

Start from a prompt, a GitHub issue or a repository todo. Pick the repository and attach screenshots of the bug or feature.

Context Scope at 60%, between Focused, Expanded and Full Scan: a dependency-graph scan with a budget of up to 588k tokens

Preview the context

See which files the planner will read, ranked by relevance, before a token is spent. Widen the Scope from Focused to Full Scan, add the files it missed, and drop the noise.

A generated plan broken into five ordered tasks, each a future GitHub issue, with drag handles to reorder them

Generate and refine

The agent drafts a structured plan. Reorder tasks from the Plan Outline, ask it to split broad tasks, cover missed edge cases or add tests. Every change saves a version you can restore.

The execution mode switch, Execute as Epic PR or Execute as Individual Tasks, above the execution config

Finalize and start

Approve the plan and ProPR creates the GitHub issues. Run them as one Epic PR or as individual tasks, pick the agent per issue, and start. Plan approval is the first of the human checkpoints on every AI-written change.

Context starts before you even type.

ProPR indexes your repository continuously, so the planner already knows your file structure, patterns and dependencies when you ask for a feature.

Indexed repositories with the commit each index was built from and when; Platform infra re-indexing at 64%

Repository indexing

ProPR reads the repository, tracks branches and builds searchable knowledge, so the planner finds the relevant files on its own.

Browsing the courier app's index: the file tree with src/sync open and the summary of uploadQueue.ts

Summaries and browse

Read repository summaries, browse files and chat with the codebase before you turn an idea into a plan.

Two indexed repositories, orders-api and storefront-web, added to a plan as reference only: all implementation stays in the target repository

New repository plans

ProPR plans and implements empty repositories from scratch, with your existing repositories as reference material for the patterns to follow.

Improvement suggestions for the courier app, two selected to turn into a plan or save as to-dos

Improvement signals

The same repository knowledge produces improvement suggestions and todos that become planned changes.

The first plan is a starting point.

ProPR turns your prompt into scope, task boundaries and risks. Scrap it when the premise is wrong. Refine it in chat when it is close.

Generated task breakdown

A large feature request becomes smaller tasks, each with numbered requirements that name files and acceptance criteria. Each task reviews as one focused diff.

One planned task: context, numbered requirements naming the files to touch, and acceptance criteria — One generated task: context, numbered requirements that name files, and acceptance criteria.

Refinement chat

Ask for a simpler plan, different boundaries, more tests or a different architecture. Every refinement returns the complete plan, unchanged tasks included.

Refining a plan in chat: asked to merge payment and review and to ship behind a flag, the assistant changes those steps and leaves the rest alone — Asked to change two steps, the assistant changes those two and keeps the rest.

Refine boldly. ProPR saves every version.

Every generation, refinement and manual edit saves a labelled version. Open Plan history, preview any earlier version and restore it. You lose nothing in either direction.

Plan history: the versions saved before each refinement and the first generation, with a preview and Restore this version — Plan history previews a saved version before you restore it.

Code starts when the plan is solid.

Approval is the handoff. ProPR turns the plan into GitHub issues, assigns the models and starts the isolated execution loop.

Executing a plan as individual tasks: one issue running with its pull request, two waiting, and Queue Remaining to start them in order — Individual tasks or an Epic PR; Queue Remaining chains the rest.

Chained individual tasks

Prefer separate pull requests to main? Turn on Auto-merge if checks pass and Queue Remaining runs the issues in order, each starting when the one ahead finishes. Run ultrafix after PR adds review and fix cycles toward your Min Review Score, within your Max Loops.

Execution settings for every task in the plan: agent and model, Ultrafix with a minimum review score of 8/10 and a loop limit, and auto-merge — A default agent and model, auto-merge, and Ultrafix to a minimum score.

Epic mode (sequential PRs)

Built for a large feature whose tasks build on each other. ProPR runs the issues one at a time, merges each green child PR into a shared Epic branch, and presents the full feature as one Epic PR for review.

Epic mode pipeline

Approved PlanLarge prompt split

Issue 1Merged

Issue 2Auto-merging...

Feature DeliveredReady for review

The executed epic plan MCP Observability Lifecycle and Tooling Capabilities Expansion on integry/propr: 17 completed issues, from #2593 on, each merged through its own pull request by Codex with GPT-5.6 Sol, several after follow-up rounds — Epic mode on ProPR itself: 17 planned issues, 17 merged PRs, one feature in epic PR #2612.

Keep refining in the PR. Once the PRs open, your team refines the code with ordinary GitHub comments through PR fine-tuning.