Summary
ChatGPT conversations are still organized as a mostly linear message stream, while reading, learning, and working with an agent are often tree-shaped. A long answer may contain several ideas that deserve separate follow-up discussions. Today, asking about one paragraph usually moves the conversation to the bottom, opens a separate branch, or leaves the user to copy and paste context manually.
I propose Inline Branch Chat with Selective Context Sharing: a passage-anchored, collapsible conversation thread that stays attached to the part of the response that prompted it, while letting the user decide whether the branch can influence later messages in the main conversation.
A concrete example
Suppose ChatGPT gives a long explanation of Transformer inference, including attention, KV-cache bandwidth, PagedAttention, and quantization. While reading the KV-cache section, I want to ask: “Why is decode often memory-bound?”
The ideal flow would be:
- Select the relevant sentence or paragraph.
- Choose Ask in thread.
- Ask several follow-up questions in an expandable thread at that exact location.
- Collapse the thread and continue reading the original answer without losing my place.
- If the branch produces a useful conclusion, explicitly make that conclusion available to the main conversation.
The main answer remains readable and stable. The local exploration remains attached to its source.
Proposed interaction
1. Selection-anchored threads
A user can select a sentence, paragraph, mathematical derivation, code explanation, tool result, or agent task step and choose Ask in thread. The thread stores its relationship to the parent message and selection range, rather than only storing an untraceable copy of the selected text.
2. Collapsible multi-turn conversation
The follow-up appears inline near the selected passage, or in an attached panel that preserves the same reading position. It can contain multiple turns, be collapsed and reopened, and show a compact label such as “Branch 1 · KV Cache · 4 messages”. Multiple branches can exist under one answer.
3. Parent-context inheritance
A branch should understand why the selected passage appeared. A useful conceptual model is:
`Branch context = relevant parent history + selected passage + branch history`
The implementation can choose how much history to retrieve, but the branch should have a stable parent message, source location, and context snapshot. It should not be treated as an unrelated new chat that happens to contain copied text.
4. Explicit context-sharing controls
The UI state of a branch, its persistence, and its visibility to future model requests should be separate controls. For example:
- Isolated — keep the branch for the user, but do not automatically expose it to later main-thread requests.
- Share summary — make the branch’s conclusion and source available to the main thread without injecting every turn.
- Share full thread — allow the main thread to retrieve the complete branch when relevant.
The default could be Isolated, avoiding accidental context pollution. Collapsing a branch would not delete it or silently change its sharing policy.
5. Non-interruptive agent observation
The same model is useful for Codex and other agent workflows. While an agent is inspecting a repository, running tests, or calling tools, a user may want to ask about an observed step without pausing or redirecting the task:
- Why was this tool called?
- What does this test failure mean?
- Which input shape was expected?
- Is the agent waiting for approval?
A branch could be anchored to an already-visible task step or tool result. By default it would read only permitted, observed state, would not inject a new instruction into the running agent, and would not claim access to hidden chain-of-thought. A user could explicitly share a branch summary at a later safe turn boundary.
Relationship to existing requests and features
I am not claiming that branching or contextual follow-up is a new idea. ChatGPT already has conversation branching, and the Community has several related requests, including:
- Contextual Inline Side-Chats: Multi-Threaded UI for Long Conversations
- Inline Side Notes: Ask About Specific Parts of a Response Without Derailing the Main Chat
- Feature Request: Branching Follow-Up Questions in ChatGPT
The additional value I am trying to specify is one coherent product model that combines passage-level anchoring, an inline collapsible multi-turn thread, parent-context inheritance, user-controlled promotion of branch context, and a non-interruptive mode for visible agent execution state. The goal is to complement existing branching and selected-text follow-ups, not to relabel them as something new.
A staged implementation path
A low-risk rollout could be incremental:
- Inline Thread MVP: selection anchoring, an attached thread surface, expand/collapse, and return to the original reading position.
- Persistent multi-turn context: durable branch identity, parent-message linkage, relevant-history inheritance, and restoration.
- Selective context sharing: isolated, summary-sharing, and full-thread retrieval with source attribution.
- Agent runtime integration: observation of visible tool steps and execution status, with concurrency isolation and explicit sharing at turn boundaries.
Phase 1 would already solve the reading-flow problem and provide a concrete usability test, without requiring a complete rewrite of the conversation system.
I would like to contribute, if a supported path exists
I am not only proposing this interaction as a user. I would genuinely like to help design, prototype, implement, and test it if an appropriate contribution pathway exists. My interests include conversation state management, context engineering, agent interaction systems, interaction prototypes, evaluation, and documentation.
I understand that ChatGPT’s core product is not an ordinary open-source repository, so I do not want to assume that an external PR is possible. Could someone point me to the supported path for a proposal of this kind?
- Is there an official way for an external developer to contribute to the design or implementation of a ChatGPT interaction feature?
- Can an interactive prototype or technical design document be submitted for product-team review?
- Is there a public engineering or design collaboration channel for this type of request?
- If ChatGPT itself does not accept external code contributions, are there related OpenAI projects with a genuinely open contribution process?
- What prototype, usability evidence, or technical analysis would be most useful for a meaningful review?
I would be happy to start with a small, runnable prototype and a clear evaluation plan if that would make the proposal easier to assess.