OpenPlanr

What it is

• Skills, not a second model. Every skill runs inside the coding agent you already use. Skills and the openplanr CLI add no model calls or telemetry. The CLI contacts the network only for features you invoke: Linear sync (linear.app), artifact sharing (share.openplanr.dev) and company sign-in (api.openplanr.dev).
• Plans are files. Specifications, user stories, tasks, and provenance live under .planr/ in your repository, reviewed and versioned like code.
• A deterministic CLI. openplanr stores and validates planning files, renders diagrams and reports, installs the skills into each host, diagnoses installations, and syncs with GitHub Issues and Linear.
• One repository, MIT licensed. Three npm packages: openplanr (the CLI and host packages), planr-pipeline (the delivery pipeline), and @openplanr/protocol (schemas and registries).

OpenPlanr is not a hosted project tracker and does not replace your issue tracker. It closes the loop: the agent reads the plan before it changes code, and what it ships flows back as evidence for the next review.

Quick start

npm install -g openplanr

openplanr setup --runtime claude --scope user
# Codex:  openplanr setup --runtime codex --scope user --skill-mode unified-plugin
# Cursor: openplanr setup --runtime cursor --scope project
cd your-project
openplanr init

Restart the coding agent so it loads the new skills, then start with a specification:

/planr:spec "Add passwordless sign-in for existing accounts"     # Claude Code
$planr:spec "Add passwordless sign-in for existing accounts"     # Codex

In Cursor, mention the planr-spec rule in Composer. Follow with plan to decompose the specification into stories and tasks, and ship to implement one task. Plan and ship stay separate steps that you invoke.

Alternatives: npx openplanr@latest setup without a global install, or curl -fsSL https://openplanr.dev/install.sh | sh (irm https://openplanr.dev/install.ps1 | iex on Windows). OpenPlanr requires a supported Node.js version (see package metadata). The getting started guide covers scopes, what setup writes, and how to undo it.

In Claude Code you can install the plugin from the public marketplace instead of running openplanr setup --runtime claude. Several skills call the openplanr CLI, so install it first:

/plugin marketplace add openplanr/marketplace
/plugin install planr@openplanr

How it works

Reasoning stays in the host agent. The CLI never calls a model; it validates what the agent wrote, renders it, and keeps trackers in step.

One feature, end to end

The plan is a file in your repository that you review like code, and the agent reads it before it changes code. ship implements one task at a time, verified and small enough to review as one pull request, and the CLI validates the planning files offline, never by a model.

Capabilities

Plan. Design. Build. Review. Operate. Every step is a skill the agent selects from its description, or that you invoke by name.

Invoke a skill as /planr:<skill> in Claude Code or $planr:<skill> in Codex; in Cursor, mention the planr-<skill> rule. share and connect run only when you invoke them. The skill catalog is generated from the registry and lists every trigger, deferral, and packaged reference.

Diagram engine

planr-diagram turns intent into a canonical semantic document, and the offline engine lays it out deterministically across 39 grammars (architecture, sequence, ER, Gantt, story map, Wardley, and more). Every render produces SVG, PNG, accessible HTML, quality and fidelity reports, and a manifest that binds the set.

openplanr diagram gallery                                          # list grammars
openplanr diagram render ./architecture.planr-diagram.json --json  # render a set
openplanr diagram check ./diagrams/architecture/architecture.manifest.json --json

See authoring and verifying diagrams.

Hosts

Connections

Skills reach chat, project trackers and source control through connectors you add to your host. OpenPlanr bundles no connectors; they and their credentials live in your host. Two optional features need a token: Linear sync (openplanr linear) and company sign-in (openplanr company login). Only when you use them does OpenPlanr store a token, in your OS keychain, or in an encrypted file at ~/.planr/credentials.enc if you set PLANR_CREDENTIAL_FILE_PASSPHRASE. For Linear you can instead set PLANR_LINEAR_TOKEN and nothing is stored. Tokens are sent only to Linear or to the company server you sign in to. openplanr company logout removes company tokens. Run connect to see what is connected and how to add the rest, and share to post an update to chat as a draft you approve. See connections and the per-host connect steps.

openplanr rules generate adds an ## OpenPlanr capabilities section to CLAUDE.md or AGENTS.md so the agent knows every skill and when to reach for it. See the host matrix for what each projection may and may not change.

Architecture

%%{init: {"theme":"base","themeVariables":{"fontFamily":"DM Sans, ui-sans-serif, system-ui, sans-serif","fontSize":"14px","primaryColor":"#5EEAD4","primaryTextColor":"#08080C","primaryBorderColor":"#237A72","secondaryColor":"#F5F7F7","secondaryTextColor":"#08080C","secondaryBorderColor":"#237A72","tertiaryColor":"#F5F7F7","tertiaryTextColor":"#08080C","tertiaryBorderColor":"#237A72","lineColor":"#237A72","textColor":"#08080C","edgeLabelBackground":"#F5F7F7","clusterBkg":"#F5F7F7","clusterBorder":"#237A72","noteBkgColor":"#F5F7F7","noteTextColor":"#08080C","noteBorderColor":"#237A72"}}}%%
flowchart LR
    subgraph sources["Canonical sources"]
        direction TB
        skills["skills/ · agents/"]
        protocol["@openplanr/protocol<br/>schemas · registries"]
    end
    generate(["npm run generate"])
    subgraph packages["Published packages"]
        direction TB
        cli["openplanr<br/>CLI + host packages"]
        pipeline["planr-pipeline<br/>delivery pipeline"]
    end
    subgraph hosts["Installed into hosts"]
        direction TB
        claude["Claude Code plugin"]
        codex["Codex plugin"]
        cursor["Cursor rules"]
    end
    skills --> generate
    protocol --> generate
    generate --> cli
    generate --> pipeline
    protocol --> pipeline
    pipeline -. exact optional dependency .-> cli
    cli --> claude
    cli --> codex
    cli --> cursor

One canonical skill graph is generated into host-native projections; generated files are outputs, never sources. The CLI composes five command groups (foundation, planning, delivery, operations, intelligence) over the Protocol contracts, and internal workspaces (operate, artifact, design, skill-runtime, the dashboard) are projected into the public packages at generation time. See the architecture guide.

Documentation

Use Docs · Getting started · Skill catalog · Connections · CLI reference · Troubleshooting · Diagrams

Contribute Contributing · Architecture · Working from a checkout · Skill authoring · Releasing

Integrate Protocol package · Pipeline package · Host matrix · Skill versioning · Verifying a release

Community and license

Beta: try OpenPlanr on one real feature and tell us what you'd change in the beta discussion.

Ask questions and share what you built in Discussions; report bugs through the issue forms. SUPPORT.md explains what to include. Security reports follow SECURITY.md; participation follows the code of conduct.

OpenPlanr is MIT licensed. The name and logo are covered by the trademark policy; the boundary between this repository and the hosted service is described in COMMERCIAL.md.

Founded and maintained by Asem Abdo (GitHub · LinkedIn).