Comments the agent can act on

Inline comments are not a chat sidebar on the whole page. They attach to a span in the markdown. That matters when the agent rewrites the file: the thread is still about those lines.

The round-trip is the third piece of the product. Live watch and Docs-style threads are two features. A comment the agent can act on, without the author pasting Slack into a prompt, is the loop. I care about this more than I care about prettier rendering. Pretty is cheap. Closing the loop is not.

Two audiences

Review has two audiences. Humans who need to talk to each other. And the coding agent that owns the file.

If every comment paged the agent, we would have failed the product. Most comments are conversation. "Looks good." "Can we talk about the naming?" "I am not sure about the cutover window." A few comments are instructions. "Rewrite the rollback section to include the dual-write window." Collapse those into one inbox and you either spam the agent or strand the humans.

The hard part is not routing. The hard part is intent. Someone left feedback on a still-changing plan.md. Sometimes it is talk. Sometimes it is work. The second case should not mean copying a thread into the prompt again. You want a comment the agent can act on, on the live file, without turning every human thread into work for the model.

I have watched authors become human middleware for an afternoon. Read thread. Summarize. Paste. Hope the model got the same lines the reviewer meant. Fifteen minutes of translation while the agent sat idle and the plan kept wanting to change. That tax is the product gap. Pretty fonts do not fix it. An explicit summons does.

What people do instead

Paste the review into the agent prompt. Works once. You lose thread structure. Easy to drop context. It is not sitting on the live file. You also become the human middleware: read thread, summarize, paste, hope. Do it three times in a day and you will start skipping review because the translation costs more than the edit.

Human-only Docs or Slack comments. Fine for teammate sync. The agent never hears it unless someone pastes. The live local file drifts. The thread ages on a snapshot. You get conversation without a path to action, then wonder why the plan still looks wrong.

Suggested edits in a PR. Right after commit. Wrong timeline for a plan that is still being rewritten. Also wrong audience model: PR comments are mostly human-to-human, then human-to-author. The agent is not a first-class recipient unless someone bridges again.

"Just tell the agent in chat." Works if the reviewer is in the same session. Often they are not. They only have a browser. Browser-only review without a summons leaves the agent deaf.

Auto-forward every comment to the model. Tempting product fantasy. Terrible review culture. "Looks good" becomes a no-op task. Side discussion becomes noise. The agent interrupts useful human threads while humans are still arguing about intent.

The missing piece is an explicit summons: a way to mark "this comment is for the agent," on the live file, without making that the default.

The summons

Start the comment with @agent. That is it. Visible. Optional. Deliberate.

gander mcp install

Install MCP once so the session hears it. gander comments is the fallback if MCP is not available. The reply is stamped as the agent. The same hosted link updates when the file changes.

The full loop looks like this. You run gander watch plan.md so saves update a hosted page. The reviewer opens the URL and leaves Docs-style threads. Human-to-human threads are fine. They are not a summons. When someone means action, they prefix @agent. That lands in the agent session. The agent edits the local file. The same link updates. Comments anchor to lines and survive rewrites. The agent can rewrite the whole doc; reviewers keep reading.

Do not resolve a thread just because you replied. Resolve after a small, obvious edit. Leave design discussion open so the reviewer can still read it. I have seen teams resolve everything the moment the agent chirps back. That erases the conversation the next human needed. Resolve is a judgment call about the file, not a courtesy to the model.

Hosted watch is the surface that makes this real. Local gander plan.md --watch will not take comments from a teammate on a phone. Hosted gander watch plan.md will. Keep those commands straight when you are explaining the loop to someone new. Before git, not instead of git. The summons lives on the moving file. The PR is later.

Why explicit matters

Agents are eager. Reviewers are chatty. If the product assumes every underline is a task, the model will thrash the file while humans are still arguing about intent.

Explicit summons flips the default. Talk first. Summon when the decision is clear enough to edit. That matches how good human review already works: discuss, then ask for a change.

It also matches the author's control. The agent session stays with the person watching the file. @agent is not "anyone can drive the model forever." It is "this comment is allowed into the session as actionable feedback."

Line anchoring matters here. A summons that says "fix the rollout section" in a free-floating chat is weaker than a summons on the rollout section. Surviving rewrites matters too. If the agent edits and the thread evaporates, you are back to paste culture with nicer fonts.

I like the small awkwardness of typing @agent on purpose. It forces a choice. Are you talking to me, or are you giving the session work? Early PRs and Slack pastes collapse that choice into "leave a note and hope someone notices." The prefix makes the hope optional.

A quiet example

Your lead leaves two comments on the hosted plan. The first says the naming in section two feels off, and asks whether you meant "tenant" or "workspace." No @agent. That is a human thread. You reply in the thread. You decide together. Nobody wakes the model.

The second starts with @agent and sits on the rollback paragraph: add the dual-write window and name the flag to flip first. MCP delivers it. The agent edits. The same link updates. You resolve only after the edit is obviously there. The naming thread stays open until you rename for real.

Two inboxes on one page. That is the product feeling I want people to get in the first five minutes.

Picture the alternative. Same two comments, both pasted into chat because that was the only path. The naming debate becomes a prompt. The model "helps" by renaming half the doc while you were still deciding. The rollback edit lands, then gets overwritten by a second paste that was meant for the naming thread. You spend the next half hour undoing helpfulness. Explicit summons would have kept the conversation human until you were ready for the edit.

Two inboxes

Most review tools collapse everything into one pile of comments.

The useful split is two: humans talking to humans, and an explicit summons when the file should change. Talk in the thread. Summon with @agent only when you mean it.

That split is the whole product bet on this axis. Live review for agent-authored markdown only works if the agent can hear feedback without eating the conversation. @agent is the summons. Everything else stays human.

It is not a claim that @agent removes judgment. Someone still decides what to summon. Someone still reviews what the agent wrote back. The loop shortens the path from comment to edit. It does not delete the humans. The next time you are about to paste a review into a prompt, ask whether the comment could have lived on the live file with a prefix instead. If yes, leave it there. Let the session that owns the file take the work.