Feature Request: Selective Context Transfer Between Chats + Message Timestamps
I use ChatGPT extensively for long-running professional workflows involving software development, system architecture, AI systems, analysis, debugging, deployments, and multiple parallel projects.
Over time, I have developed a workflow where different chats are used for different stages or branches of the same project.
One recurring problem is transferring only the relevant working context from one conversation to another.
I believe ChatGPT could solve this with a native Selective Context Transfer feature.
The problem
In a long conversation, I may have hundreds of messages, but only 3–10 specific messages are important for the next stage of work.
I often know exactly which messages contain the information I need.
For example:
- a technical requirement I defined earlier;
- a piece of code;
- an architecture decision;
- a server configuration;
- an error and its solution;
- an important ChatGPT response;
- several messages containing decisions made during development.
I do not necessarily want the entire chat history transferred.
I also do not necessarily want ChatGPT to search Memory or automatically decide which old information is relevant.
Sometimes the user already knows exactly what context needs to be transferred.
Today, the practical solution is usually manual copy/paste or asking ChatGPT to summarize the conversation.
For serious long-running workflows, I think the user should have direct control over this.
Proposed feature: “Transfer Context”
Allow users to select individual messages inside a conversation.
For an initial implementation, even a limit of around 10 selected messages would already be extremely useful.
The user could select both:
- user messages;
- ChatGPT responses.
Example:
Select messages → Transfer Context → Choose destination chat
The destination could be:
- a new chat;
- an existing chat.
Important: transferred messages should become context, not new prompts
This is an important part of the proposal.
When messages are transferred, ChatGPT should NOT start answering each transferred user message again.
Instead, the selected messages should be inserted into the destination conversation as a special context object.
For example:
Transferred Context
7 messages from another conversation
These messages are background context from a previous conversation. Use them as context for future responses. Do not respond to them individually. Wait for the user’s next instruction.
The model processes this information, but no normal response is generated until the user sends the next instruction.
This makes the feature fundamentally different from simply forwarding or copying messages.
Example workflow
Imagine I am developing a software system.
Chat A contains a very long development history.
At some point I want to start a clean Chat B for the next implementation stage.
Inside Chat A, I select:
- my original architecture requirement;
- ChatGPT’s proposed architecture;
- a later correction I made;
- an important code example;
- the final configuration;
- the latest deployment result.
Then I choose:
Transfer Context → New Chat
Chat B opens with a collapsed block:
Transferred Context · 6 messages · Source: previous chat
ChatGPT already understands those six messages.
I can then simply write:
Continue development from this state.
There is no need to reconstruct the project manually.
The transferred context should be visually separate
I think transferred context should NOT look exactly like ordinary messages.
It could appear as a collapsible block:
Transferred Context · 6 messages
Source: [original conversation]
View context
This would make it clear which information came from another conversation.
Ideally, the user could:
- expand it;
- inspect the transferred messages;
- see the source conversation;
- remove the context block if it is no longer needed.
This would make context management explicit and understandable.
Second option: “Transfer context up to this message”
There is another useful workflow.
When browsing an old conversation, the user could open the three-dot menu on a particular message and choose something like:
Transfer context up to this point
ChatGPT could then prepare the relevant working state of the conversation up to that message.
This is useful when a project reached a specific stable point and the user wants to branch from there.
It would effectively create a user-controlled checkpoint.
Third option: “Prepare context for a new chat”
Another complementary feature could be:
Prepare context for new chat
ChatGPT would automatically generate a structured handoff containing something like:
- project objective;
- important requirements;
- decisions already made;
- relevant technical information;
- constraints;
- completed work;
- current state;
- unresolved issues;
- next planned actions.
The user could review or edit this handoff before transferring it.
This would be especially useful for extremely long conversations.
Manual selection + AI-generated handoff
I think the strongest implementation would combine both approaches.
Manual mode
The user explicitly selects the messages that must be preserved.
This provides precision and user control.
Automatic mode
ChatGPT generates a compact structured handoff.
This provides convenience when the conversation is very large.
The two approaches solve different problems and could work together.
The user should ultimately control what becomes the context of the next working session.
This is different from Memory
I do not see this as a replacement for Memory.
They solve different problems.
Memory:
What should ChatGPT know across conversations?
Context Transfer:
What exact information from this working session should be available in another specific conversation right now?
For professional workflows, that distinction is important.
A project may contain temporary technical details that are extremely important for the next conversation but should not become long-term personal memory.
Another related UX improvement: message timestamps
I would also strongly suggest adding visible timestamps to individual messages.
For example:
14:15 — User
14:26 — ChatGPT
This may sound like a small feature, but it becomes very useful in long technical conversations.
When working for several hours, I may remember:
“I changed that configuration around 14:30.”
or:
“The deployment failed shortly after 17:00.”
But I may not remember the exact phrase, command, variable name, version number, or spelling required for text search.
In technical work, even one different character can make a search much less useful.
Time therefore becomes another navigation dimension.
Ideally, timestamps could also help with navigation/search inside a conversation.
Why this would improve professional workflows
For many users, ChatGPT conversations are no longer just isolated question-and-answer sessions.
They can represent working sessions.
A workflow can look like this:
Research → Architecture → Implementation → Debugging → Deployment → Next iteration
Each stage may benefit from a fresh conversation while still requiring selected information from the previous stage.
Native context transfer would allow users to create clean working sessions without losing important decisions.
It would also reduce:
- repetitive explanations;
- manual copy/paste;
- unnecessary context;
- accidental loss of technical decisions;
- dependence on perfect text search;
- the need to make the model rediscover information the user already knows is important.
Suggested UX
A possible simple implementation:
1. Long press / selection mode / message menu
Select up to 10 messages.
2. Action
Transfer Context
3. Destination
New Chat
or
Existing Chat
4. Result
A special collapsed context block appears in the destination chat:
Transferred Context · 7 messages
From: [Conversation name]
View context
5. Model behavior
The transferred information is processed as background context.
ChatGPT does not generate a response yet.
The interface displays something like:
Context added. Waiting for your next instruction.
The user then continues normally.
Final idea
The fundamental concept is simple:
Let the user explicitly control which parts of one conversation become context for another conversation.
AI can still help summarize, retrieve, and organize information, but sometimes the human already knows exactly which pieces of context matter.
Giving users a native way to transfer that context could make long-running ChatGPT workflows significantly easier to manage.
Thank you to the OpenAI team for continuing to improve ChatGPT.
I hope this proposal is useful.
— Vyacheslav Franz