Plannotator 0.21.0 adds direct file editing, embedded CLI agents, and Bedrock support

• plannotator's 0.21.0 announcement turns Plannotator from an annotation surface into a file editor, adding direct document editing and an embedded CLI agent in the same release.
• The same 0.21.0 feature list also adds Bedrock and Vertex support, which expands the tool beyond whatever local or default model setup existing users were already running.
• In plannotator's code review update, the team also cleaned up Code Review controls and semantic diff panels, which makes the review path part of the release, not just the editing path.
• the launch post says plannotator annotate folder/ now launches a persistent IDE-like experience, and a follow-up reply frames the app as a simple loop of opening folders, commenting on files, editing files, and working beside an agent.
• plannotator's feedback-loop post adds a more unusual detail: reviews and annotations are already stored on disk as JSON, and users can point agents at ~/.plannotator/drafts/ to compound those past judgments into future workflows.

You can see the full shipping list in plannotator's main launch thread, the Code Review cleanup in the semantic diff panel update, and a more interesting longer-term mechanic in the on-disk feedback post. The release pitch is short, but it quietly connects editing, review, agent context-building, cloud backends, and reusable local review history into one loop.

The headline change is direct document editing. Before this, Plannotator's public framing leaned on annotation and review. In 0.21.0, editing files is part of the core workflow.

The launch post groups that with "co-context" via an embedded CLI agent. That pairing matters more than the wording: the app is not only showing files and comments, it is now set up for users to modify files while an agent builds context alongside them.

Plannotator also says HTML files now have first-class support, and any file currently being viewed can be opened in an external app. That makes the editing surface looser than a closed in-app editor.

The most concrete product-shape clue is the command plannotator annotate folder/. According to the launch post, that starts the same persistent experience "the same way you launch any IDE."

In a Chinese reply, plannotator's follow-up reduces the model to four verbs: open a folder, comment on files, edit files, and work with your agent. That is a much clearer description of what Plannotator is becoming than the broader launch copy.

This release also touched the review stack. plannotator's update says Code Review controls and semantic diff panels were cleaned up and moved to a better UX.

That keeps review in the main path instead of letting editing overshadow it. The release now spans two adjacent jobs:

• editing files directly
• reviewing changes with semantic diffs
• building context with an embedded CLI agent
• handing files off to external apps when needed

Bedrock and Vertex support shipped in the same release, per the feature list. The tweet does not spell out provider-level details, but the addition is still notable because it moves Plannotator toward enterprise and managed-cloud model backends instead of a single provider story.

The same post also mentions stronger sharing configs and general UX polish. Those are smaller notes, but paired with Bedrock and Vertex they make 0.21.0 look like a packaging release around a bigger workflow shift.

The most non-obvious detail surfaced outside the main launch thread. According to plannotator's feedback-loop post, annotation and code-review feedback is stored locally under ~/.plannotator/drafts/, with JSON fields for codeAnnotations and annotations.

That means Plannotator is already emitting structured review history that another agent can parse. The suggested flow from that post is straightforward:

1. point an agent at ~/.plannotator/drafts/
2. parse the saved JSON review data
3. use that history to adapt future behavior

That local draft store is the clearest sign in the evidence that Plannotator is trying to become more than a one-off annotation UI.