> ## Content Index
> Fetch the complete content index at: https://claudefox.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# Plannotator: review your coding agent's plans, diffs and messages before it acts
- URL: https://claudefox.com/plannotator-review-your-coding-agent-s-plans-diffs-and/
- Published: 2026-11-16T16:52:59.000Z
- Updated: 2026-11-16T16:53:01.000Z
- Description: Plannotator is a local, browser-based review workspace for AI coding agents that lets you annotate plans, diffs and agent messages and send the feedback back to the agent.
- Author: hupicake
- Tags: Tools

backnotprop/plannotator is a local review workspace that sits between you and your coding agent. When the agent drafts a plan, finishes a change, or leaves you a message, Plannotator opens that work in your browser so you can mark it up, ask for changes, and send your notes back for the agent to act on. It supports Claude Code, Codex, OpenCode, Gemini CLI, Copilot CLI, Kiro, Droid, Amp, Pi and DeepSeek Harness, and other agents can reach its Inbox through MCP. This post covers how to install it, what to do first, and where its own docs admit the rough edges.

## Quick facts

- Platform: macOS, Linux, Windows and WSL. Over SSH it moves to port 19432 by itself; in a devcontainer or Docker you set remote mode and forward the port.
- Language: TypeScript; the main package reports version 0.28.66.
- Licence: MIT or Apache 2.0, at your option.
- Latest release: v0.28.66, published November 16, 2026.
- Stars: about 12,400 GitHub stars as of November 17, 2026.
- Minimum versions: the full installer needs git; Gemini CLI needs 0.36.0 or newer, Qwen Code 0.13.0 or newer, Pi 0.79.1 or newer, and the non-blocking Claude Code flow needs Claude Code 2.1.287 or newer.

The newest release, v0.28.66, is mostly about the Inbox: you can archive, snooze or combine several threads at once, tags colour rows, Google Antigravity and Orca can use the Inbox, and replies now reach Codex threads in T3 Code too.

## How to install

Run the installer for your system. It downloads the binary from GitHub Releases and sets up the agents it handles itself (Codex, Gemini CLI, Kiro CLI and Qwen Code), plus the slash commands Claude Code and OpenCode use. A first run in a terminal asks two optional skill questions; scripted runs never ask. Run it again later to update.

```
curl -fsSL https://plannotator.ai/install.sh | bash
```

On Windows, use PowerShell:

```
irm https://plannotator.ai/install.ps1 | iex
```

The minimal flag installs only the binary and does not need git, but it also leaves out every skill, hook and /plannotator-\* command, so skip it if you want the agent workflow below.

```
curl -fsSL https://plannotator.ai/install.sh | bash -s -- --minimal
```

To stay on one release, pass a tag from the releases page, such as v0.28.66:

```
curl -fsSL https://plannotator.ai/install.sh | bash -s -- --version <tag>
```

Then finish the step for your agent. For Claude Code, add the marketplace and install the plugin, then restart Claude Code:

```
/plugin marketplace add backnotprop/plannotator
```

```
/plugin install plannotator@plannotator
```

For Pi, skip the installer and install the extension, which brings plan review and the slash commands but not the plannotator command:

```
pi install npm:@plannotator/pi-extension
```

For OpenCode 1, add the plugin to opencode.json and restart; only the plan agent gets submit\_plan by default. OpenCode 2 uses a different plugins entry, loaded with opencode2 reload, shown in the plugin README.

```
{
  "$schema": "https://opencode.ai/config.json",
  "plugin": ["@plannotator/opencode@latest"]
}
```

Codex, Gemini CLI, Kiro CLI and Qwen Code need nothing more. Copilot CLI, Droid, DeepSeek Harness and Amp each need their own plugin step, listed in the README's install table.

## First setup

Ask your agent for something that needs a plan. On Claude Code, Codex, Gemini CLI, Qwen Code, DeepSeek Harness and OpenCode's plan agent, Plannotator opens in your browser at the plan handoff. Copilot CLI does this only in plan mode, Pi only after pi --plan, and Droid and Amp not at all, since they are commands only. If nothing appears, check that the installer found the agent and that you restarted it.

- Try the commands yourself: /plannotator-last annotates the agent's last reply, /plannotator-review opens your current diff, and /plannotator-annotate opens a file, folder or URL. In Codex use the $plannotator-\* skills or !plannotator review instead, and in Amp the command palette.
- Some features leave your machine: URL annotation fetches public pages through Jina Reader by default (a Jina API key only raises rate limits), Ask AI sends context to the provider you configure, and sharing sends content out as a link. Notion needs a NOTION\_TOKEN where Plannotator starts and a parent page set in Settings.
- GitHub and GitLab review go through your own authenticated command line tools and remote, so sign in there first if you want to review a pull request or merge request by URL.

In T3 Code, Claude threads get the Inbox through the Claude Code plugin (Plannotator 0.28.65 and Claude Code 2.1.287 or newer). T3 stops an idle Claude after about 30 minutes; to keep replies arriving, sign in once with the MCP URL from T3's Settings → Environments, choosing Supervised or higher, since Read only cannot reply:

```
plannotator t3 login --url <T3 MCP URL>
```

To open the Inbox from a terminal (not available on a Pi-only install):

```
plannotator inbox
```

## What stands out

Plannotator is not a chat window with a comment box. It is built around the moment when an agent hands you something to judge, and it keeps that judgement in a form the agent can act on.

- Plan review happens at the handoff. With Claude Code, a hook on ExitPlanMode opens the plan; with Codex, a Stop hook does the same after a plan turn. Approving sends the agent on, denying returns structured feedback, and a revised plan shows a diff badge for what changed. On Claude Code 2.1.287 or newer, Claude does not wait; your decision arrives later as a message.
- The Inbox is one local window where agents leave messages, questions, files and guided reviews while they keep working. You answer with a click and press Send when ready. Claude Code, Pi and OpenCode connect through plugins and get your reply as their next turn; other agents reach it over MCP, and how replies reach them varies by agent.
- Code review covers uncommitted changes, a GitHub pull request or GitLab merge request by URL, and Git, Jujutsu and Perforce; a GitButler workspace opens with the CLI command plannotator review --gitbutler. You comment on lines, suggest code, stage files, and approving sends an LGTM back.
- You can annotate almost anything the agent produces: markdown, an HTML file (converted by default, or rendered as it is with --render-html), a URL, and the agent's last message. The toolbar offers deletion, comments, preset labels and a looks-good mark, with redline and comment modes and global comments for feedback that belongs to the whole document.
- Privacy is stated plainly. Plannotator collects no usage telemetry, and plans, diffs, annotations, drafts, history and settings stay local by default. Small markdown shares sit unencrypted in a URL fragment; larger markdown and raw HTML shares are encrypted and expire after 7 days. Sharing can be turned off entirely.

## How it was built with Claude

The repository is set up to be worked on with agents, not just by them. CLAUDE.md is a symlink to AGENTS.md, which maps the codebase to focused guides under docs/agent-guides and lists hard rules for anyone changing it. One of those rules records a past failure: an earlier from-scratch rebuild of the document UI broke the app and was reverted, so work that reuses that UI in the commercial Workspaces app must add a seam to the existing UI package instead of rebuilding it. The repository also ships a release skill under .agents/skills/release that its release process follows.

Commit attribution is harder to read. The latest 100 commits, read through the GitHub API, were all authored by Michael Ramos under the backnotprop account, and none carried a Co-Authored-By line. That sample proves nothing about who or what wrote the rest of the history.

**Try it with your AI.** Use this with your own assistant after installing Plannotator, to add the same kind of review step to a repository of yours.

```
First check my setup before changing anything: confirm [my agent, for example Claude
Code] and its version, confirm the plannotator command is installed, and confirm [the
repository I want this for, and its main language]. If anything is missing, stop and
tell me exactly what to install, using only the official installer from the article.

Then, in [that repository], draft an AGENTS.md modelled on Plannotator's AGENTS.md and a
CLAUDE.md that points to it: a short map of the codebase, hard rules for agents working
in it, and a pointer to one focused guide per area, with no feature detail copied into
the map itself. Add one rule recording a past mistake we must not repeat: [describe it
in one sentence].

Next, wire plan review into [my agent] the way Plannotator's installation docs describe
for that agent, for example the ExitPlanMode hook for Claude Code or the Stop hook for
Codex, and tell me if my agent is commands only. Add /plannotator-annotate,
/plannotator-review and /plannotator-last for on-demand use, in the form my agent takes
(the $plannotator-* skills in Codex), and plannotator inbox for the Inbox. Show me every
risky step first and wait for my confirmation before changing any hook, settings file or
agent configuration. Do not install anything from unknown sources, do not touch
credential files, and do not delete anything.
```

## Known limits

- The update check asks GitHub for the newest release at most once every ten minutes, until you turn it off in Settings or with PLANNOTATOR\_UPDATE\_CHECK=0.
- When remote mode is on, the server accepts connections on all interfaces and asks for no login, so anyone who can reach the port can use it; keep the port closed to networks you do not trust.
- Open-source link sharing is moving to deprecated support in favour of hosted Workspaces, and no removal date has been announced.
- Anyone with a complete share link can read it, since large shares carry their decryption key in the link.
- Security fixes are provided only for the latest released version; older releases are not supported.
- Codex hooks are experimental, and the Codex flow is currently macOS, Linux and WSL only. Droid is commands only, with no plan interception yet, and Amp is commands only too.
- The installer resolves the latest release through the GitHub API, which allows only 60 anonymous requests an hour from one IP address, so installs on a shared IP can fail; a token raises that limit.
- The release SBOM is a release-wide inventory of locked build inputs, not an exact per-binary runtime inventory.
- Qwen Code still asks for one more confirmation in the terminal after you approve a plan in Plannotator.

## Problems and feedback

Report bugs and request features in the repository's issue tracker on GitHub. Contributions go in as a fork and a pull request, and are dual-licensed under the same terms unless stated otherwise. Keep a suspected vulnerability off the public tracker: use GitHub's private vulnerability reporting form for the repository instead, and keep it private until a fix or a coordinated plan exists.

Source: [Plannotator repository](https://github.com/backnotprop/plannotator?ref=claudefox.com), [Plannotator README](https://github.com/backnotprop/plannotator/blob/main/README.md?ref=claudefox.com), [Plannotator v0.28.66 release](https://github.com/backnotprop/plannotator/releases/tag/v0.28.66?ref=claudefox.com), [Plannotator installation docs](https://github.com/backnotprop/plannotator/blob/main/apps/marketing/src/content/docs/getting-started/installation.md?ref=claudefox.com), [Plannotator quickstart docs](https://github.com/backnotprop/plannotator/blob/main/apps/marketing/src/content/docs/getting-started/quickstart.md?ref=claudefox.com), [Plannotator AGENTS.md](https://github.com/backnotprop/plannotator/blob/main/AGENTS.md?ref=claudefox.com), [Plannotator package.json](https://github.com/backnotprop/plannotator/blob/main/package.json?ref=claudefox.com), [Plannotator security policy](https://github.com/backnotprop/plannotator/blob/main/SECURITY.md?ref=claudefox.com), [Plannotator contributing guide](https://github.com/backnotprop/plannotator/blob/main/CONTRIBUTING.md?ref=claudefox.com), [Plannotator issues](https://github.com/backnotprop/plannotator/issues?ref=claudefox.com), [Plannotator OpenCode plugin README](https://github.com/backnotprop/plannotator/blob/main/apps/opencode-plugin/README.md?ref=claudefox.com), [Plannotator Pi extension README](https://github.com/backnotprop/plannotator/blob/main/apps/pi-extension/README.md?ref=claudefox.com), [Plannotator sharing guide](https://github.com/backnotprop/plannotator/blob/main/apps/marketing/src/content/docs/guides/sharing-and-collaboration.md?ref=claudefox.com), [Plannotator privacy policy](https://plannotator.ai/privacy?ref=claudefox.com)

This story first appeared in the [claudefox daily briefing for November 16, 2026](https://claudefox.com/daily-2026-11-16/).