plannotator Puts a Human Checkpoint in Front of Every Agent Diff

There is a specific moment in agent-assisted development where things get worse instead of better. The agent finishes a task, prints a summary, and asks you to accept it. You scroll. The diff is four hundred lines. You approve it because reading it properly would take longer than writing it yourself did.
plannotator, a project with around 10,500 stars and rising fast this week, is an attempt to fix that moment. It is a local, browser-based review surface that hooks into a coding agent and opens when the agent has something to decide. You mark up the plan, the document, or the diff, and your comments go back to the agent as its next input.
The tagline is about staying in the loop. The architecture is about something narrower and more useful: making the human's attention a first-class step instead of an optional one.
How it attaches
It does not replace your agent. It plugs into one. The README lists Claude Code, Codex, Copilot CLI, Gemini CLI, OpenCode, Kiro, Droid, Amp, DeepSeek Harness, and Pi, and the Inbox also works with personal assistants like Grok Bot, Muse, Hermes, and OpenClaw. Connection happens through each harness's plugins, hooks, and commands, which is why the integration depth varies by tool.
The commands are the familiar shape:
/plannotator-review # uncommitted changes
/plannotator-review <github-pr-url> # a pull request
/plannotator-annotate README.md # a file
/plannotator-annotate https://docs.rs # a URL
/plannotator-last # the agent's last message
plannotator inbox # the queue
On Codex, the slash commands become !plannotator ... or the packaged skills. Plan mode needs no command at all: it is wired through each harness's hooks, so when the agent writes a plan, the review surface opens on its own. That detail matters more than it sounds. A checkpoint that requires you to remember to invoke it is a checkpoint that gets skipped on the days you are busy, which are the days it matters.
Review works across Git, GitButler, Jujutsu, Perforce, GitHub, and GitLab, so the surface is not tied to one forge. You comment on lines, suggest code, and the comments are posted back to the agent rather than to a pull request thread nobody reads.
The inbox is the interesting part
Single-agent review is a solved problem with a boring solution: open a diff, leave comments.
The Inbox is what the team built for the situation most people are actually in, which is several agents running at once. It is one local window where agents leave messages, questions, files, and guided reviews while they keep working. You answer a question with a click, annotate a file, and press send when you get to it. Nothing holds an agent session open while you do that, and your reply goes back to the session that asked.
That single sentence resolves a real deadlock. The standard pattern for human-in-the-loop is the agent stops and waits. With one agent that is fine. With four, you are the slowest process in the system, and three of them are burning context while you finish lunch. An async inbox lets the agent park the question instead of the session.
Claude Code, Pi, and OpenCode connect through plugins so replies arrive as the next turn. Everything else reaches it over MCP with plannotator inbox mcp, and plannotator inbox --help doubles as the document the agent reads to learn the protocol. That is a small piece of design with a large effect: the help text is the integration spec.
Why a browser, and why local
A terminal diff is fine for reading code and bad for reading anything else. Reviewing a product spec, an HTML mockup, or a rendered report in a pager is a exercise in squinting, and agents now produce all three regularly. Rendering them in a browser and letting the reviewer put pins on the rendered output is the correct surface for the artifact.

The privacy section of the README is unusually specific for a tool of this size, and it is worth quoting in substance rather than summary. There is no telemetry. Plans, diffs, annotations, drafts, and history stay local by default. Each surface checks GitHub for the latest release when it loads, and there is no opt-out for that check. Local Git review may run git ls-remote against your configured origin to detect the default branch and a stale baseline, and that query fires when the review opens, when the diff loads, when you switch base, and when you press fetch. An idle review page makes no network calls, which is a stronger promise than most tools make.
Content leaves the machine only when a network feature needs it: URL annotation fetches the page, GitHub review uses your authenticated CLI, Ask AI sends the selected question and context to your configured provider, and sharing uploads ciphertext to a paste service.
For a tool that sits on top of source code, that level of disclosure is the right instinct. The failure mode for agent tooling is a helpful helper that sends your repository to a server without saying so, and the only defense a user has is a maintainer who documents the boundaries before being asked.
The uncomfortable implication
Everything about this project is a bet that the constraint on agent work is human review bandwidth, not model capability.
The bet looks correct to me. The people I know who run multiple agents spend their day reading: plans, diffs, test output, summaries of what the agent thinks it did. The generation part is fast and getting faster. The verification part is bounded by how quickly a person can read and decide.
There is a second-order effect worth naming. A review surface that captures decisions creates a record of them. plannotator has an archive command that browses saved plan decisions read-only, and annotations persist in the data directory so terminal reviews and app reviews accumulate in one place. Once you have a few hundred approved plans with the comments that shaped them, you own something that no individual session contains: a description of how your team decides.
That is the asset. Not the diff viewer, which anyone can build. The reasoning trail.
Where it still hurts
Two things, both inherent.
The first is that review tools improve review, and review is not the same as correctness. A well-annotated approval of a bad architecture is still an approval of a bad architecture, and a tidy review surface makes approving feel like diligence. The Inbox in particular makes it easy to clear a queue, and clearing a queue is a different behavior from understanding it.
The second is that the tool adds a browser, a local server, and a hook layer to a workflow that was previously a terminal. That is three more things to break, and the failure mode when a hook breaks is silent: the agent proceeds without the checkpoint, and you find out later.
Both are acceptable costs for the thing being bought, which is a place for the human to stand. The alternative, which is what most teams do today, is to read a chat transcript and hope the important parts are in it.
If you try one thing
Run /plannotator-review on your next uncommitted change and comment on three lines, even if you have nothing to say. The comments are incidental. What you learn is how long an actual review takes when the surface is designed for it, and that number is your new throughput ceiling. Most teams have never measured it.
Related articles
The Jensen Discount: What Nvidia Loses When Its Founder Walks Out
Nvidia lost roughly $600 billion in market value when its founder stepped down. The earnings did not change. The multiple did, and that says where the value really lived.
Chinese text in video always turns to mush. Dreamina handed the typesetting to code
Dreamina launched Motion Studio on November 10. It no longer generates frames; the model writes code that lays out text, shapes and pacing. Chinese titles stop blurring, but whether the content is right is still on you.
A community spreadsheet of taps that turns off the ads inside Chinese Android builds
A no-root tool that switches off the ads Chinese phone makers ship inside the system UI. Its method is a hand-written tap script per phone model, maintained by volunteers every time a ROM moves. It works, and the maintenance is the point.
GPT Image 2.6 held the token price and raised the bill
GPT Image 2.6 kept every token rate from 2.5 and still costs more per image, because more of the work now happens in output tokens. Eleven days into the ramp, the pricing structure says more than the leaderboard does.