TL;DR

Plannotator (backnotprop/plannotator) is a local, browser-based review surface for AI coding agents. When Claude Code, Codex, Gemini CLI, OpenCode, Copilot CLI or one of several other agents finishes a plan, Plannotator opens it in your browser. You mark it up like a document, with comments, deletions and labels, and your annotations go back to the agent as structured feedback. The same tool reviews diffs and pull requests, annotates any Markdown, HTML file, folder or URL, and since October 2026 runs an Inbox where several long-running agents leave you questions, prototypes and guided reviews.

Not run by us: our container test lab returned no result today, so nothing in this review comes from running Plannotator ourselves. Everything below is from the project’s README, docs, release notes and public discussion.

Facts as of November 16, 2026:

  • 12,177 GitHub stars and 1,146 forks. The repo was created on December 28, 2025, and gained about 1,700 stars this week on GitHub’s weekly trending list.
  • 105 open issues (issues only; there are 63 more open pull requests).
  • License: MIT or Apache-2.0, your choice (GitHub’s sidebar shows only Apache-2.0). The open-source tool is free; a team product called Workspaces is waitlist-only.
  • Latest release: v0.28.66, published November 16, 2026. The project has shipped 229 releases in under 11 months, often more than one a day.
  • Written in TypeScript and shipped as a Bun-compiled single binary for macOS, Linux and Windows (x64 and arm64).

Verdict: If you approve agent plans by scrolling terminal text and typing “no, change step 3”, Plannotator fixes a real problem with very little setup. Inline annotations on a rendered plan or diff are a better feedback channel than chat. The cautions: an extremely fast release cadence, a default-on anonymous daily ping, a remote mode with no login, and a product that is growing from a focused plan reviewer into a large agent-management app.

Quick Reference

FieldValue
What it isBrowser UI to annotate agent plans, diffs, PRs, docs and HTML, then send the feedback to the agent
Installcurl -fsSL https://plannotator.ai/install.sh | bash (Windows: irm https://plannotator.ai/install.ps1 | iex)
AgentsClaude Code, Codex, Copilot CLI, Gemini CLI, OpenCode, Kiro, Droid, Amp, Pi, DeepSeek Harness, T3 Code
Inbox clientsClaude Code, Pi, OpenCode via plugins; anything else via plannotator inbox mcp
VCSGit, GitButler, Jujutsu, Perforce, GitHub PRs, GitLab MRs
Data~/.plannotator locally; share links encrypted, expire after 7 days
LicenseMIT OR Apache-2.0
Siteplannotator.ai

What Problem Plannotator Solves

Plan mode in Claude Code and similar agents ends with a wall of Markdown in the terminal and a yes/no prompt. If you want changes, you type them as a new chat message, describing in prose which step you mean. Long plans get rubber-stamped.

The author, posting as ramoz in a Show HN on June 11, 2026, explains the origin: “I started this in January as a hook for Claude Code’s plan mode: when it finished planning, instead of approving a wall of text in the terminal, the plan opens in your browser and you could mark it up like a document.” The README’s flow for that original feature:

Agent calls ExitPlanMode
 -> PermissionRequest hook fires
 -> Local server reads plan from hook input
 -> Browser opens with review UI
 -> You annotate and approve/deny
 -> Approve: agent proceeds
 -> Deny: structured feedback sent to agent
 -> Agent revises, plan diff shows what changed

The last line matters. When the agent revises, Plannotator shows a diff between plan versions, so you can check that your comments were acted on instead of re-reading the whole plan.

The Four Things It Does

1. Plan review (automatic)

No command is needed. The installer wires a hook into each agent’s plan mode. For Claude Code without the plugin system, the README gives the manual hook:

{
  "hooks": {
    "PermissionRequest": [
      {
        "matcher": "ExitPlanMode",
        "hooks": [
          { "type": "command", "command": "plannotator", "timeout": 345600 }
        ]
      }
    ]
  }
}

The 345,600-second timeout is four days: the hook is designed to wait for you. On Claude Code 2.1.287 or newer, the README says plan review no longer blocks: Claude ends its turn and your decision arrives later as a message. PLANNOTATOR_CLAUDE_MOD=0 restores the old blocking flow. On Codex, plan review runs through Codex’s experimental Stop hook.

2. Code review

/plannotator-review opens your uncommitted changes in a diff viewer with a file tree. You comment on lines, suggest code, stage or unstage files, and send. Approve sends “LGTM”. The same command takes a GitHub PR or GitLab MR URL:

/plannotator-review                                   # uncommitted changes
/plannotator-review https://github.com/org/repo/pull/123
plannotator review --gitbutler                        # GitButler workspace
plannotator review --patch-file reading.diff          # any unified diff

The README also lists an “Ask AI” panel and AI review agents that post comments to the diff, which you can turn off with PLANNOTATOR_AI=disabled.

3. Annotate anything

/plannotator-annotate README.md                         # a local Markdown file
/plannotator-annotate src/                              # browse a folder
/plannotator-annotate https://docs.rs/…                 # fetch a URL
/plannotator-annotate report.html --render-html         # HTML as-is
/plannotator-last                                       # the agent's last message

/plannotator-last is the most broadly useful of these: it opens the agent’s previous reply as a document so you can mark up a long explanation instead of quoting it back. URL annotation goes through Jina Reader by default (PLANNOTATOR_JINA=0 turns that off). In Codex the slash commands become $plannotator-* skills or !plannotator ….

4. The Inbox (new in October 2026)

The Inbox is a single local window where agents leave you messages while they keep working: questions with options (including pictures as choices), blockers, design docs, prototypes and a “guided review” at the end of a run, where the change is split into sections in reading order with a summary per section. The Inbox page describes the loop in three steps: the agent writes to the Inbox, you answer or annotate, and “it arrives as the session’s next turn”.

plannotator inbox                                          # open it
codex mcp add plannotator-inbox -- plannotator inbox mcp   # connect Codex over MCP

Claude Code, Pi and OpenCode connect through Plannotator’s own plugins and get woken when you send. Every other agent uses the MCP server; the docs list Codex, Cursor, VS Code, Gemini CLI, Zed, Goose, Amp and Cline. Recent releases added personal assistants (Grok Bot, Hermes Agent, OpenClaw, Muse), multi-machine linking over Tailscale, tags, snoozing, bulk actions and a phone layout.

This is a deliberate shift. The README now labels the original plan-mode feature “(Legacy) Plan Mode” and calls the Inbox “the missing review layer between you and multi-agent work”. Some context: in a September 2026 Hacker News thread titled “Plan mode is dead”, a commenter who works on Claude Code wrote that in Claude Code “all plan mode does is add a little reminder to every user message”, which is why a review layer that does not depend on any one agent’s plan mode makes sense.

Installation

The one-line installer downloads the binary from GitHub Releases, detects which agents you have installed, and configures hooks, skills and slash commands for each:

# macOS / Linux / WSL
curl -fsSL https://plannotator.ai/install.sh | bash

# Binary only, no hooks or skills
curl -fsSL https://plannotator.ai/install.sh | bash -s -- --minimal

# Pin a version
curl -fsSL https://plannotator.ai/install.sh | bash -s -- --version vX.Y.Z

Some agents need one more step. Claude Code: /plugin marketplace add backnotprop/plannotator, then /plugin install plannotator@plannotator and a restart. OpenCode: add "plugin": ["@plannotator/opencode@latest"] to opencode.json. Pi skips the installer: pi install npm:@plannotator/pi-extension. Gemini CLI (0.36.0+), Codex and Kiro need nothing extra.

Updating means re-running the installer, which also updates the Claude Code plugin if claude is on your PATH. plannotator uninstall removes the integrations but keeps your plans and history; --purge deletes local data too, after you type purge at a prompt.

Supply chain. For a curl-pipe-to-bash installer, the verification story is better than most. Every release binary has a SHA256 sidecar, SLSA provenance attestations exist from v0.17.2, and current releases attach a CycloneDX SBOM scanned with Grype before publishing. --verify-attestation makes the installer check provenance with gh attestation verify. It is opt-in, so turn it on if you install this on work machines.

Remote, SSH and Containers

Plannotator detects SSH sessions and switches to fixed port 19432. In devcontainers or Docker you set it yourself:

export PLANNOTATOR_REMOTE=1
export PLANNOTATOR_PORT=9999   # forward this port

The README is direct about the risk: “In remote mode the server listens on every interface (0.0.0.0) with no login, so anyone who can reach the port can use it, even when you use an SSH tunnel.” Keep that port off untrusted networks. The Inbox over Tailscale is the safer path; v0.28.65 made it open only for your own Tailscale account.

A Show HN commenter (quinncom) reported running it with Pi inside the nono.sh sandbox by setting PLANNOTATOR_REMOTE=1, allowing ~/.plannotator on the filesystem and opening listen port 19432. That is a useful data point if you sandbox your agents: Plannotator needs a writable data directory and a listening port.

Privacy and Network Behavior

The privacy policy (updated November 9, 2026) is specific:

  • Local by default. Plans, annotations, drafts, history and config live under ~/.plannotator (or PLANNOTATOR_DATA_DIR).
  • Feedback archive on by default. Every plan decision and review submission is saved to ~/.plannotator/feedback/ and nothing prunes it. Records hold your review text and quoted excerpts, not the full diff. PLANNOTATOR_FEEDBACK_HISTORY=0 turns it off.
  • Daily anonymous ping, on by default. Each tool (Inbox, plan, review, annotate, last) sends at most one ping a day to ping.plannotator.ai with version, a coarse “weeks since first use” bucket, the tool name and the favicon setting. No ID, no file names, no content. The app shows no notice about it; the policy explains how to turn it off.
  • Sharing. Small shares live entirely in the URL. Larger ones are encrypted in the browser before upload, the key stays in the URL fragment, and they expire after 7 days. Anyone with the full link can read it. PLANNOTATOR_SHARE=disabled turns sharing off.

The ping is benign as described, but a default-on ping with no in-app notice will matter to some teams. Read section 3 of the policy before rolling it out.

Integrations

Approved plans can be saved automatically to Obsidian (with YAML frontmatter, tags and backlinks), Bear or Notion (with NOTION_TOKEN set). A VS Code extension opens plans in editor tabs with gutter annotations. Herdr Annotate and a standalone Plannotator TUI (brew install plannotator/tap/plannotator-tui) bring the document review to the terminal, and terminal reviews land in the same data directory as browser reviews. Plan and annotate views also have an optional Vim control profile.

Community and Maintenance

The project moves fast. v0.28.66 alone, per its release notes, has “100 PRs. 15 of them are from 8 outside contributors”. GitHub’s contributor list shows 192 accounts. Releases arrive almost daily: v0.28.62 through v0.28.66 shipped between November 12 and November 16, 2026.

Reaction outside GitHub is quieter than the star count suggests. The Show HN posts drew few votes (the June 2026 post had 5 points), and most discussion happens on X. The HN comments that exist are positive: one user said they had been using it “since someone of Cloudflare on x mentioned it”. A byteiota write-up from November 15, 2026 calls it “the right size for this problem” because it “doesn’t try to be an IDE, an orchestration platform, or a full agent harness”. That was true of the plan reviewer. With the Inbox, agent launching, routines and pull-request boards, it is becoming a bigger product.

Honest Limitations

  1. Release churn. 229 releases in 11 months means frequent behavior changes. The Claude Code flow alone changed from blocking to asynchronous in a recent version. Pin a version (--version) if you need stability.
  2. Scope creep. The README now covers plan review, code review, annotation, the Inbox, artifacts, routines (off by default), Workspaces and multi-machine linking. If you only want plan review, --minimal plus the Claude Code hook is the smallest setup.
  3. Remote mode has no auth. 0.0.0.0 binding with no login is fine on a laptop and risky on a shared server.
  4. Not every agent gets plan interception. Droid gets commands only. Copilot CLI only in plan mode (Shift+Tab). Codex relies on an experimental hook, and native Windows needs manual setup.
  5. Telemetry and local archives are on by default. Both are documented and can be turned off, but you have to know to look.
  6. Browser round-trips. Every review opens a browser tab. If you live in tmux over SSH, you will want the TUI or Herdr route instead.

Plannotator vs. Alternatives

OptionBest forTrade-off
PlannotatorRich markup of plans, diffs and HTML across many agentsFast-moving, growing scope
Agent’s built-in plan approvalShort plans, zero setupProse-only feedback, easy to rubber-stamp
GitHub/GitLab PR reviewTeam review after code existsNo pre-code plan review; slower loop back to the agent
Elephant-Goldfish ModelSpec-first design with an AI reviewerAgent reviews the plan, not you
WorktrunkRunning agents in parallel worktreesComplements Plannotator; does no reviewing

Plannotator puts the human back in the review step. The Elephant-Goldfish Model puts a fresh-context AI there. The two can be combined.

Who Should Use It

  • Use it if you run Claude Code, Codex, OpenCode or Gemini CLI daily, approve plans you have not fully read, and want to comment on specific lines instead of re-describing them.
  • Use the Inbox if you run several agents for hours and lose their questions in terminal scrollback.
  • Skip it if your plans are short, you never use plan mode, or your environment forbids default-on telemetry and you cannot change install configs.

FAQ

Is Plannotator free?

Yes. The open-source app is free under MIT or Apache-2.0, as of November 16, 2026. A team product, Workspaces, has a waitlist and no published pricing.

Does Plannotator send my code anywhere?

Not by default, according to its privacy policy. Plans, diffs and annotations stay in ~/.plannotator. Network calls happen for features you use: GitHub/GitLab for PR review, Jina Reader for URL annotation, an AI provider for Ask AI, and the share service for links. A daily anonymous usage ping is on by default and can be disabled.

Which coding agents does Plannotator support?

Claude Code, Codex, Copilot CLI, Gemini CLI, OpenCode, Kiro, Droid, Amp, Pi, DeepSeek Harness and T3 Code. The Inbox also accepts any MCP-capable agent through plannotator inbox mcp.

Does it work over SSH or in Docker?

Yes. It switches to port 19432 over SSH, and PLANNOTATOR_REMOTE=1 with PLANNOTATOR_PORT covers containers. In remote mode it listens on all interfaces with no login, so restrict who can reach the port.

How is it different from just reviewing the PR on GitHub?

GitHub review happens after the code exists and the feedback has to be relayed back to the agent. Plannotator reviews the plan before any code is written, and also reviews local diffs, sending your comments straight into the agent session as its next turn.

How do I uninstall it?

Run plannotator uninstall to remove the hooks, skills and binary while keeping local data, or plannotator uninstall --purge to delete local data too.

Sources