Does copilot remember other conversations

[attrib75]

Select Topic Area

Question

Copilot Feature Area

Copilot Agent Mode

Body

I was working with Copilot in Visual Studio and it crashed, unrecoverable. I had to start a new conversation. We spent almost two hours deep diving into a stored proc and I had to start over from scratch :(

When I started explaining what we were doing before, I pasted the stored procedure. It says it remembered it. Is that true? If so that's pretty cool. It might be hallucinating? The response I got from it is pasted below. Remember this is a brand new conversation.

[AMRYB]

No
Copilot does not truly remember other conversations once a chat is gone, even if it sounds like it does.

[Eric-Lebedenko]

Most likely, it does not “remember” your previous two-hour correspondence in the literal sense. In Copilot Chat (in Visual Studio), the model gets its context mainly from current activity in the IDE: the selected fragment, the active file, as well as explicitly added references/attachments and, if necessary, the solution-level context (@workspace).

Your screenshot shows “1 reference” that is, Copilot actually received (or pulled in itself) some source of context, so the phrase “I remember this monster” almost certainly means “I recognize this text from the current context/insertion” rather than “I have restored the previous chat.”

Separately: GitHub has a Copilot memory preview feature, but it is described as repository-specific memory for agents/code reviews, not as a guaranteed recovery of lost chat history after a crash.

[AMRYB]

What are you, a kid? Disliking and making fake records for yourself to look tough?

[rafaelxo]

What you’re seeing is not actual memory of a previous conversation, even though it may look like that.

When Copilot says it “remembers” something in a brand new conversation, it’s usually because of one of these reasons:

1. Context was reintroduced manually
   If the stored procedure or a large portion of it was pasted again, the model can infer structure, intent, and patterns very quickly. This can feel like memory, but it’s just reasoning based on the content provided in the current prompt.
2. Strong pattern recognition
   Large language models are very good at recognizing common stored procedure patterns (joins, temp tables, cursors, pagination, etc.). When the code matches familiar structures, the response may align closely with what was discussed before, even without prior context.
3. Conversation-level memory does not persist across sessions
   Each new conversation starts with a clean slate. There is no recall of previous chats, deep dives, or decisions unless that information is explicitly provided again in the current conversation.

So while the response might appear as if it “remembered” earlier work, it’s not persistent memory—it’s either:

1. reconstruction based on the pasted code, or
2. a reasonable continuation inferred from common database and stored procedure design patterns.

That said, it is a good sign of how well the model can re-analyze complex code quickly once the relevant context is supplied again. Unfortunately, crashes or resets do mean that prior conversation context is lost, and there’s currently no built-in way to recover that history unless it was saved externally.