Does GitHub Copilot Remember Between Sessions?

Yes, in part, and the part matters. GitHub Copilot Memory, generally available on paid Copilot plans as of late October 2026, carries personal preferences and repository conventions across Copilot sessions and surfaces. It does not carry your full conversation history, and it does not follow you outside Copilot.

That split is the whole answer. Copilot now remembers the kind of thing you used to repeat in every session. It still does not remember everything you said.

What changed in late October 2026?

GitHub announced Copilot Memory as generally available on paid plans in its October 28, 2026 changelog post on GitHub intelligence. The pitch is simple: Copilot can remember personal preferences and repository conventions across sessions and clients, so you spend less time repeating guidance in each session.

The surfaces covered are wide: the Copilot app, Copilot CLI, VS Code, the Copilot cloud agent, Copilot code review, Slack, Teams, and GitHub Mobile. A preference you set in one place is meant to show up in another.

GitHub gives a concrete example of the shape this takes. Tell Copilot to start your pull request descriptions with a TL;DR, and it can reuse that preference across Copilot experiences. Repository memories work the same way at team level: the right test command, or how your team expects Copilot to check its work.

Sessions also generate memories on their own. As Copilot works, it deduces insights from its observations and curates them into stored memories.

What exactly does Copilot store?

Two kinds of memory, both distilled rather than verbatim.

Personal preferences are about you: how you like things done, phrased, or checked. Repository conventions are about the codebase: the test command to run, the review checklist to follow, the way this repo expects work to be verified.

Documentation summaries describe two guardrails on those memories. Each memory carries citations to the code locations that support it, and before a memory is injected into a new prompt, those citations are validated against the current codebase. If the code changed significantly or the file was deleted, the memory is treated as stale and is not used. The same summaries describe memories expiring after 28 days, which keeps old guidance from lingering forever.

You can manage what is stored. Personal memories can be viewed and deleted in your Copilot settings. That control matters, because an automatically curated memory can also be a wrong one, and a wrong convention repeated in every session is worse than no convention at all.

What does it still not carry?

First, it does not carry the full conversation. A memory says you prefer a TL;DR at the top of pull request descriptions. It does not replay the discussion where you and Copilot decided that, or the three approaches you tried before settling on it. If the reasoning behind a decision matters, it lives in the old chat thread, not in the memory.

Second, session-scoped notes still end with the session. In VS Code, the local memory tool separates user memories, which persist across workspaces, from session memories, which are cleared when the chat ends. A plan file that persists during one multi-step task is not the same as memory across sessions.

Third, and most important for anyone who works in more than one tool, Copilot memory stays inside Copilot. It does not follow you into Claude Code, Cursor, Codex, or a scheduled agent running somewhere else. Your Copilot sessions can now remember each other. Your other tools still start from zero.

How do you check what Copilot remembers about your repo?

Run this test before you rely on it.

1. In one session, state a preference explicitly, in Copilot's own form: "Remember to run the full test suite before opening a pull request."
2. Close that session completely and open a new one on a different surface, for example the CLI if you started in VS Code.
3. Ask Copilot to describe the conventions it will follow for this repo, and see whether your preference comes back unprompted.
4. Open your Copilot settings and look at the stored memories. Delete anything wrong or outdated on the spot.

If the preference survives steps 2 and 3, Copilot Memory is working for you. If it does not, check two things: whether your plan includes the generally available memory feature, and whether the memory was stored as a personal preference or only as a note inside one session.

One durable fallback is worth keeping regardless. Put repo conventions in the repo itself, in an instruction file the tool reads every session. That file survives plan changes, surface changes, and memory expiry, and every teammate starts from the same baseline.

What if your work spans more than Copilot?

This is where a memory layer outside any single tool earns its place. A built agent connects to Vilix AI with an API key as a Bearer header to https://api.vilix.ai/mcp and gets full memory with zero memory infrastructure to run. The same memory follows you across Claude, Codex, Cursor, OpenClaw, Hermes, Grok, Manus AI, GitHub Copilot, Windsurf, Lovable, Muse, and any MCP-compatible AI, so a decision made in Copilot is visible to your other tools and vice versa.

Vilix AI stores full conversation history, not just distilled facts, alongside projects, tasks, and rules, all editable from any connected tool or the dashboard at app.vilix.ai. Correct something once and the newest version is what every tool sees. Your data stays portable: export everything or delete it anytime. The free plan is free forever, with a 7-day Pro trial that needs no credit card.

Frequently asked questions

Does GitHub Copilot remember between sessions on a free plan?

Copilot Memory is described as generally available on paid Copilot plans. If you are on a free plan and sessions feel stateless, that is the expected behavior, not a bug in your setup.

Does Copilot remember my whole chat history?

No. It stores distilled preferences and repository conventions, not verbatim transcripts. A new chat thread does not automatically contain the discussion from a previous session.

Does Copilot memory work across VS Code, the CLI, and code review?

Yes, across Copilot surfaces. Personal preferences and repository conventions are meant to carry across the Copilot app, CLI, VS Code, the cloud agent, code review, Slack, Teams, and Mobile.

What happens when the code behind a memory changes?

The memory is validated against its citations before use. If the code changed significantly or the file was deleted, the memory is treated as stale and is not injected into the new prompt.

Does Copilot memory follow me into other AI tools?

No. It lives inside Copilot surfaces. Memory that has to span tools needs a layer outside any single tool.

The short answer

GitHub Copilot now remembers preferences and repository conventions between its own sessions, on paid plans, and that removes a real daily annoyance. It does not remember your full conversations, and it does not remember anything for your other tools. If Copilot is your whole workflow, its memory may be enough.

Learn more about shared agent memory at https://vilix.ai/?utm_source=vilix-blog&utm_medium=article&utm_campaign=does-github-copilot-remember-between-sessions