MCP server for generating rough-draft project plans from natural-language prompts.
io.github.PlanExeOrg/planexe MCP Server
This MCP server generates rough-draft project plans from natural-language prompts. It is designed for AI-assisted planning and is categorized around planning workflows and planning algorithms, with support for tool-based execution in an MCP environment. The server is identified as io.github.PlanExeOrg/planexe and includes 11 tools.
🛠️ Key Features
Generates rough-draft project plans from natural-language prompts
Exposed via MCP with 11 tools
Topics include ai-planning and planning-algorithms
🚀 Use Cases
Turning prompt text into early project plan drafts
Draft planning based on structured planning approaches (e.g., PMBOK-related topic coverage)
Planning workflows using AI planning concepts
⚡ Developer Benefits
MCP tooling interface (toolCount: 11)
Fits ecosystems listed in topics: llamaindex, openrouter, ollama
⚠️ Limitations
Provided description and excerpt only mention rough-draft generation; no additional behavior, outputs, or integrations are specified beyond listed topics
Returns a curated list of example plans with download links for reports and zip bundles. Use this to preview what PlanExe output looks like before creating your own plan. Especially useful when the user asks what the output looks like before committing to a plan. No API key required.
Call this first. Returns example prompts that define what a good prompt looks like. Do NOT call plan_create yet. Optional before plan_create: call model_profiles to choose model_profile. Next is a non-tool step: formulate a detailed prompt (typically ~300-800 words; use examples as a baseline, similar structure) and get user approval. Good prompt shape: objective, scope, constraints, timeline, stakeholders, budget/resources, and success criteria. Write the prompt as flowing prose, not structured markdown with headers or bullet lists. Weave technical specs, constraints, and targets naturally into sentences. Include banned words/approaches and governance preferences inline. The examples demonstrate this prose style — match their tone and density. Then call plan_create. PlanExe is not for tiny one-shot outputs like a 5-point checklist; and it does not support selecting only some internal pipeline steps.
Optional helper before plan_create. Returns model_profile options with plain-language guidance and currently available models in each profile. If no models are available, returns error code MODEL_PROFILES_UNAVAILABLE.
Call only after example_prompts and after you have completed prompt drafting/approval (non-tool step). PlanExe turns the approved prompt into a strategic project-plan draft (20+ sections) in ~10-20 min. Sections include: executive summary, interactive Gantt charts, investor pitch, project plan with SMART criteria, strategic decision analysis, scenario comparison, assumptions with expert review, governance structure, SWOT analysis, team role profiles, simulated expert criticism, work breakdown structure, plan review (critical issues, KPIs, financial strategy, automation opportunities), Q&A, premortem with failure scenarios, self-audit checklist, and adversarial premise attacks that argue against the project. The adversarial sections (premortem, self-audit, premise attacks) surface risks and questions the prompter may not have considered. Returns plan_id (UUID); use it for plan_status, plan_stop, plan_retry, and plan_file_info. To track progress, poll plan_status at reasonable intervals (e.g. every 5 minutes). Optionally, run `curl -N <sse_url>` in a background shell as a completion detector — the stream auto-closes on terminal state (completed/failed/stopped). If you lose a plan_id, call plan_list to recover it. If the same prompt + model_profile is submitted by the same user within a short window, the existing plan is returned (with deduplicated=true) instead of creating a new one. If you are unsure which model_profile to choose, call model_profiles first. If your deployment uses credits, include user_api_key to charge the correct account. Common error codes: INVALID_USER_API_KEY, USER_API_KEY_REQUIRED, INSUFFICIENT_CREDITS.
Parameters3
prompt
string
required
model_profile
string
optional
Model profile: baseline, premium, frontier, custom. Call model_profiles to inspect options.
start_date
any
optional
Optional plan start date in ISO 8601 format with timezone offset (e.g. '2025-06-15T09:00:00+02:00'). When omitted, the plan starts now. Use this to set a past or future start date for the plan.
Raw schema
{
"type": "object",
"properties": {
"prompt": {
"title": "Prompt",
"type": "string"
},
"model_profile": {
"default": "baseline",
"description": "Model profile: baseline, premium, frontier, custom. Call model_profiles to inspect options.",
"enum": [
"baseline",
"premium",
"frontier",
"custom"
],
"title": "Model Profile",
"type": "string"
},
"start_date": {
"anyOf": [
{
"type": "string"
},
{
"type": "null"
}
],
"default": null,
"description": "Optional plan start date in ISO 8601 format with timezone offset (e.g. '2025-06-15T09:00:00+02:00'). When omitted, the plan starts now. Use this to set a past or future start date for the plan.",
"title": "Start Date"
}
},
"required": [
"prompt"
],
"title": "plan_createArguments"
}
plan_status
Returns status and progress of the plan currently being created. This is the primary way to check progress — it returns structured JSON with all progress fields. Poll at reasonable intervals (e.g. every 5 minutes): plan generation typically takes 10-20 minutes (baseline profile) and may take longer on higher-quality profiles. State contract: pending/processing => keep polling; completed => download is ready; failed => terminal error; stopped => user called plan_stop (consider plan_resume). progress_percentage is 0-100 (integer-like float); 100 when completed. Note: steps vary in duration — early steps complete quickly while later steps (review, report generation) take longer. Do not use progress_percentage to estimate time remaining. steps_completed and steps_total give the number of plan generation steps completed and expected (both nullable). current_step is the human-readable label of the most recently completed step (e.g. 'SWOT Analysis'). timing.last_progress_at is an ISO 8601 timestamp of the last progress update (null until the first worker update); use it to compute time-since-last-progress and detect stalls — a gap > 10 minutes with no progress change is a strong stall signal. files lists the most recent 10 intermediate outputs produced so far (files_count gives the total); use their updated_at timestamps as a secondary stall signal. When state is 'failed', the response includes an error dict with failure diagnostics: error.failure_reason (category: generation_error, worker_error, inactivity_timeout, internal_error, version_mismatch), error.failed_step (pipeline step active at failure), error.message (human-readable message), and error.recoverable (true => plan_resume may work, false => use plan_retry). The error dict is absent for non-failed states. Unknown plan_id returns error code PLAN_NOT_FOUND. Troubleshooting: pending for >5 minutes likely means queued but not picked up by a worker. processing with timing.last_progress_at unchanged for >10 minutes likely means stalled — call plan_stop then plan_retry. Fall back to file updated_at timestamps if last_progress_at is null. Report these issues to https://github.com/PlanExeOrg/PlanExe/issues .
Request the plan generation to stop. Pass the plan_id (the UUID returned by plan_create). Stopping is asynchronous: the stop flag is set immediately but the plan may continue briefly before halting. A stopped plan will transition to the stopped state. If the plan is already completed or failed, stop_requested returns false (the plan already finished). Unknown plan_id returns error code PLAN_NOT_FOUND.
Parameters1
plan_id
string
required
Plan UUID returned by plan_create. Use it to stop the plan creation.
Raw schema
{
"type": "object",
"properties": {
"plan_id": {
"description": "Plan UUID returned by plan_create. Use it to stop the plan creation.",
"title": "Plan Id",
"type": "string"
}
},
"required": [
"plan_id"
],
"title": "plan_stopArguments"
}
plan_retry
Retry a plan that is currently in failed or stopped state. Pass the plan_id and optionally model_profile (defaults to baseline). The plan is reset to pending, prior artifacts are cleared, and the same plan_id is requeued for processing. Returns PLAN_NOT_FOUND when plan_id is unknown and PLAN_NOT_FAILED when the plan is not in failed or stopped state.
Parameters2
plan_id
string
required
UUID of the failed plan to retry.
model_profile
string
optional
Model profile used for retry. Defaults to baseline.
Raw schema
{
"type": "object",
"properties": {
"plan_id": {
"description": "UUID of the failed plan to retry.",
"title": "Plan Id",
"type": "string"
},
"model_profile": {
"default": "baseline",
"description": "Model profile used for retry. Defaults to baseline.",
"enum": [
"baseline",
"premium",
"frontier",
"custom"
],
"title": "Model Profile",
"type": "string"
}
},
"required": [
"plan_id"
],
"title": "plan_retryArguments"
}
plan_resume
Resume a failed or stopped plan without discarding completed intermediary files. Plan generation restarts from the first incomplete step, skipping all steps that already produced output files. Use plan_resume when plan_status shows 'failed' or 'stopped' and plan generation was interrupted before completing all steps (network drop, timeout, plan_stop, worker crash). For a full restart or to change model_profile, use plan_retry instead. Only failed or stopped plans can be resumed. Returns PLAN_NOT_FOUND when plan_id is unknown and PLAN_NOT_RESUMABLE when the plan is not in failed or stopped state. Returns PIPELINE_VERSION_MISMATCH when the snapshot was created by a different pipeline version; use plan_retry instead.
Parameters2
plan_id
string
required
UUID of the failed plan to resume.
model_profile
string
optional
Model profile used for the resumed plan. Defaults to baseline.
Raw schema
{
"type": "object",
"properties": {
"plan_id": {
"description": "UUID of the failed plan to resume.",
"title": "Plan Id",
"type": "string"
},
"model_profile": {
"default": "baseline",
"description": "Model profile used for the resumed plan. Defaults to baseline.",
"enum": [
"baseline",
"premium",
"frontier",
"custom"
],
"title": "Model Profile",
"type": "string"
}
},
"required": [
"plan_id"
],
"title": "plan_resumeArguments"
}
plan_file_info
Returns file metadata (content_type, download_url, download_size, expires_at) for the report or zip artifact. Use artifact='report' (default) for the interactive HTML report (~700KB, self-contained with embedded JS for collapsible sections and interactive Gantt charts — open in a browser). Use artifact='zip' for the full pipeline output bundle (md, json, csv intermediary files that fed the report). While the task is still pending or processing, returns {ready:false,reason:"processing"}. Check readiness by testing whether download_url is present in the response. Once ready, present download_url to the user or fetch and save the file locally. Download URLs expire after 15 minutes (see expires_at); call plan_file_info again to get a fresh URL if needed. Terminal error codes: generation_failed (plan failed), content_unavailable (artifact missing). Unknown plan_id returns error code PLAN_NOT_FOUND.
Parameters2
plan_id
string
required
Plan UUID returned by plan_create. Use it to download the created plan.
artifact
string
optional
Download artifact type: report or zip.
Raw schema
{
"type": "object",
"properties": {
"plan_id": {
"description": "Plan UUID returned by plan_create. Use it to download the created plan.",
"title": "Plan Id",
"type": "string"
},
"artifact": {
"default": "report",
"description": "Download artifact type: report or zip.",
"enum": [
"report",
"zip"
],
"title": "Artifact",
"type": "string"
}
},
"required": [
"plan_id"
],
"title": "plan_file_infoArguments"
}
plan_list
List the most recent plans for an authenticated user. Returns up to `limit` plans (default 10, max 50) newest-first, each with plan_id, state, progress_percentage, created_at (ISO 8601), and a prompt_excerpt (first 100 chars). Use this to recover a lost plan_id or to review recent activity.
Parameters1
limit
integer
optional
Maximum number of plans to return (1–50). Newest plans are returned first.
Raw schema
{
"type": "object",
"properties": {
"limit": {
"default": 10,
"description": "Maximum number of plans to return (1–50). Newest plans are returned first.",
"maximum": 50,
"minimum": 1,
"title": "Limit",
"type": "integer"
}
},
"title": "plan_listArguments"
}
send_feedback
Submit feedback about PlanExe — issues, impressions, or suggestions. Callable at any point in the workflow; fire-and-forget, never blocks. Use category to classify: mcp (MCP tools, SSE, plan_status, workflow), plan (the generated output files), code (PlanExe source), docs (documentation), other. Optionally attach to a plan via plan_id. Use rating (1-5) for sentiment: 1=strong negative, 3=neutral, 5=strong positive. Especially useful for reporting: SSE streams that close before plan completion, plan_status returning stale or inconsistent data, queue delays where workers are slow to pick up plans, and impressions of plan output quality after reviewing reports. Include specific details (plan_id, percentages, timestamps) when reporting issues.
Parameters4
category
string
required
Feedback category: mcp, plan, code, docs, or other.
message
string
required
Free-text feedback. Include environment context if reporting an issue.
Good ideas are not limited to people and organizations that can afford a large
consulting engagement. Turning an ambitious idea into a coherent project,
however, normally requires substantial time, specialist knowledge, stakeholder
interviews, and repeated synthesis.
PlanExe is open-source software for people and AI agents that need to plan
complex projects. Describe a project in plain language and PlanExe creates a
structured first-pass plan: the assumptions to challenge,
decisions to make, work to coordinate, risks to investigate, and questions that
must be answered before execution.
The result is not a substitute for stakeholder participation or professional
sign-off. It is a way to begin with a broad, inspectable planning baseline
instead of a blank page.
What PlanExe does
PlanExe examines a project from several planning perspectives and combines the
results into one self-contained interactive report. Depending on the project,
the output commonly includes:
Executive summary and project purpose
Assumptions, constraints, and unanswered questions
Strategic choices and alternative scenarios
Work breakdown structure and dependency-aware Gantt chart
Governance bodies, decision rights, and escalation paths
Roles, stakeholders, and engagement approaches
Risk register, SWOT analysis, and mitigation proposals
Premortem, expert criticism, premise attack, and self-audit
Documents to create, documents to find, and data to collect
An editable bundle of Markdown, JSON, and CSV source artifacts
The planning pipeline can use cloud models or run with local models so sensitive
project material can remain on systems you control.
Built for complex projects
PlanExe is intended for consulting-scale, multi-phase initiatives—not everyday
task lists or small personal projects.
Examples of suitable work include:
Planning a regional clean-water, energy, or transport infrastructure program
Coordinating a regulated healthcare or financial-services transformation
Designing a cross-border public-sector initiative
Preparing a complex business, industrial, or technology program
Structuring an ERP migration, corporate separation, or post-merger integration
Helping an under-resourced organization develop an ambitious proposal before
it has access to specialist advisers
The richer the brief—objective, location, constraints, stakeholders, resources,
timeline, and success criteria—the more useful the resulting plan becomes.
A plan you can inspect and change
PlanExe does not hide the planning process inside a chat transcript. Each run
produces a folder of readable source artifacts alongside the final report.
If you find an assumption or early decision you disagree with, you can edit that
artifact and continue the plan from there. PlanExe rebuilds the later work that
depends on your change while preserving earlier work you already accept. This
makes it possible to refine the reasoning behind a plan, not merely rewrite its
final prose.
What PlanExe does not replace
PlanExe creates a draft for investigation and refinement. Generated claims,
budgets, dates, laws, engineering assumptions, and risk estimates may be wrong
or incomplete. Important projects still require:
Evidence and current local data
Stakeholder interviews and negotiation
Domain experts and professional judgment
Legal, financial, medical, safety, or engineering review where applicable
Named people who take responsibility for decisions and execution
Use the report to expose assumptions, focus conversations, and accelerate
planning—not as proof that a project is safe, feasible, funded, or approved.
Some project data should not be sent to third-party services. Running PlanExe
with local models can help you:
Keep trade secrets, confidential strategies, and sensitive project material
within systems you control
Work offline or inside an air-gapped environment
Continue planning when a model provider is unavailable in your country
Reduce dependence on vendor censorship, changing usage policies, account
restrictions, pricing changes, or service shutdowns
Choose models that fit your language, values, hardware, and project
Preserve access to your planning process and editable project files over time
Self-hosting does not remove your legal, ethical, security, or professional
responsibilities. It gives you greater control over the models, infrastructure,
and information involved.
