Claude Code Desktop: Support multiple persistent inline annotations on a Claude response before sending

Nobody has claimed this yet.

### Preflight Checklist

- [x] I have searched [existing requests](https://github.com/anthropics/claude-code/issues?q=is%3Aissue%20label%3Aenhancement) and this feature hasn't been requested yet
- [x] This is a single feature request (not multiple features)

### Problem Statement

Claude Code Desktop already handles one in-progress reply/comment quite well.

If I select a fragment of Claude's response and start writing a comment, the editor remains available while I interact with other parts of the app. I can click outside it, inspect other content, copy something, or even switch chats and come back later without losing what I was writing.

That is a useful interaction model because writing feedback is often part of the thinking process rather than simply typing a statement that I already have fully formed.

The limitation is that this model currently works for only one in-progress comment at a time.

When reading a long Claude response, I often discover several independent questions, objections, or observations about different parts of the same answer.

For example, I may have:

a question about paragraph A;
an objection to an assumption in paragraph B;
a clarification request about paragraph C.

I usually discover these points while reading. I do not necessarily have all of them fully formulated before I start interacting with the response.

With the current UI, I can start working on A, but if I want to preserve B and C as well, I have no equivalent place to put them. I either have to send A and start a new conversational turn immediately, remember B and C while discussing A, write them somewhere outside Claude, or manually construct a message containing several copied quotes.

This creates unnecessary cognitive overhead.

Once I start discussing A, that discussion may take several turns. During that time I still have to remember that I originally wanted to return to B and C. Those unfinished thoughts are no longer represented by the interface.

This is especially limiting when working with an AI agent because a Claude response is often more than a normal chat message. It can be a substantial structured artifact containing multiple assumptions, implementation decisions, explanations, and conclusions that I want to inspect independently.

The important mental model is that I am reviewing and reasoning over the response while I read it. My questions emerge during that process.

Claude Code already supports this reasoning process well for one unfinished comment. I would like that same model to scale from one comment to multiple comments.

### Proposed Solution

Allow multiple fragments of the same Claude response to each have their own persistent inline annotation/comment before anything is sent.

The existing behavior of the comment editor should be preserved: an unfinished annotation should remain safe while I interact with the rest of Claude Code.

For example, I should be able to:

Select a fragment in paragraph A and start writing comment A.
Continue reading the response without sending it.
Select a different fragment in paragraph B and create comment B.
Add comment C to another fragment.
Move between A, B, and C and refine them independently.
Inspect other parts of the response, copy context, or even temporarily switch elsewhere in Claude Code while those comments remain preserved.
Submit the annotations together when I am ready to continue the conversation.

Each annotation should stay associated with the exact fragment that triggered it.

Conceptually, the final user turn could contain:

Fragment A → comment/question A
Fragment B → comment/question B
Fragment C → comment/question C

The comments do not all need to remain visually expanded at once. They could collapse into compact annotations while preserving their contents.

The key distinction should be between editing state and persistence. A comment does not need to remain visually open in order to remain part of the pending response.

The resulting mental model would be:

read → notice something → annotate it → continue reading → notice something else → annotate it → reconsider earlier thoughts → revise them → send when ready

rather than:

read → choose one issue → immediately continue the conversation about it → remember all remaining issues yourself

This would make the interaction feel much closer to reviewing a document while retaining the benefits of a conversational agent.

### Alternative Solutions

The current workflow has several workarounds, but each has significant drawbacks.

I can manually copy several fragments into the main composer and write a question below each quote. This works, but it is cumbersome and duplicates information that the UI already knows: which piece of Claude's response each question refers to.

I can also keep Notes or another editor open and record B and C there while discussing A. That solves the memory problem, but it means I cannot work entirely inside Claude Code and have to manually maintain external state for the conversation.

Another option is to discuss A first and return to B and C later. The problem is that I have to keep B and C in working memory throughout the entire discussion around A, and they are easy to forget.

Forking the conversation is also a possible alternative, but I do not think it solves the same problem.

A, B, and C may initially appear independent, but their discussions can later interact. An answer to B may change how I think about A. If A and B are already in separate branches, I then have to manually transfer relevant context from one fork to another.

Forking is useful when I intentionally want independent explorations. It should not be required simply because I discovered several questions while reading one response.

The previous Reply behavior was somewhat closer to the desired workflow because several selected fragments could accumulate before sending. However, those fragments shared one general composer rather than allowing an independent comment to be attached to each selection.

The desired model combines the useful properties of both approaches:

multiple selections + an independent persistent comment for each selection + one final submission.

### Priority

High - Significant impact on productivity

### Feature Category

Other

### Use Case Example

Claude gives me a detailed implementation proposal.

While reading the first section, I notice an architectural assumption I want to challenge. I select that sentence and start writing:

> Why does this service need to own this state?

I am not ready to send it yet because I want to understand the rest of the proposal first.

I continue reading.

A few paragraphs later, Claude describes a concurrency strategy and I realize I have another question:

> What happens if two workers reach this operation at the same time?

I want to attach that question to this second fragment without sending the first comment.

I then reach a third part of the answer that provides additional context. That context changes how I think about my first question, so I return to annotation A and refine it.

At this point I have three thoughts attached to three different parts of the same Claude response.

I can see them, revisit them, and continue reasoning without having to remember them externally.

When I am satisfied, I submit them together.

Claude receives all three questions in the same conversational context. If the answer to question B is relevant to question A, that relationship can naturally remain part of the same discussion.

If I later decide that one particular topic deserves an independent exploration, I can explicitly fork it at that point.

### Additional Context

This request is related to several existing discussions, but focuses specifically on extending the current Claude Code Desktop Reply/comment interaction.

#70628 requested the Desktop Reply interaction for selected text. The current Desktop implementation now provides a useful persistent editor for a single selected fragment.

#64207 proposed inline annotations and deferred batch replies to multiple parts of Claude output and is conceptually very close to this request, but was focused on the TUI and is no longer active.

#80374 also explores multi-selection / batch-reply behavior in the TUI.

The request here is specifically about the Desktop interaction that now exists: the persistence model for one comment is already good; it should scale to multiple independent comments on the same response.

This is not primarily a request for chat branching. Branching and annotations solve different problems.

Annotations are useful when several thoughts originate from the same response and should remain in shared conversational context. Branching is useful when the user intentionally wants to separate a topic into an independent exploration.

A useful analogy is document review software such as Google Docs or code-review tools: the user can externalize thoughts exactly where they arise instead of keeping an unresolved list of questions in working memory.

For an AI agent this interaction is particularly useful because a single agent response may be a large structured artifact containing many independently discussable points.

The UI should help preserve the questions that emerge while the user is reading and reasoning over that artifact.

The issue names the Desktop Reply/comment interaction but no implementation files or tests. Start by reviewing the existing single-fragment Desktop behavior and related issues #70628, #64207, and #80374; done means multiple comments remain attached to separate fragments, can be revised independently, and submit together.

Written by the indexing model from the issue text.