Do you still need a memory bank for GitHub Copilot?

Short answer

A memory bank is a community pattern, popularized by Cline: a memory-bank/ folder of Markdown files that the agent must reread at the start of every task. GitHub Copilot has official places for each part of that job: instruction files for agreed rules, Copilot Memory for what the agent learns, MCP for external knowledge. A small memory bank still helps for a running work log.

Where the memory bank comes from

The term comes from Cline, an open source coding agent. Its documentation describes a memory-bank/ folder in the project with six core files:

File What goes in it
projectbrief.md Requirements and goals of the project
productContext.md Why the project exists and the user experience it aims for
activeContext.md Current work, recent changes, next steps; updated most often
systemPatterns.md Architecture, design patterns, how components relate
techContext.md Stack, setup, constraints, dependencies
progress.md What works, what is left, known issues

The trick is in the instructions: the agent must read all of these files at the start of every task, and the command “update memory bank” makes it review and rewrite them. Because an agent forgets everything between sessions, the folder is its memory.

Developers copied the pattern to GitHub Copilot by putting the same folder in the repo and adding a line to .github/copilot-instructions.md that says “read memory-bank/ before every task.” That works, but Copilot now has official places for most of what the folder does.

What Copilot offers instead, per job

As of November 2026:

Job of the memory bank Official place in GitHub Copilot Who maintains it
Rules everyone agrees on (stack, conventions, commands) .github/copilot-instructions.md or AGENTS.md in the repo root The team, via pull requests
Rules for part of the code .github/instructions/*.instructions.md with applyTo, for example applyTo: 'tests/**/*.py' The team
Facts the agent discovers while working Copilot Memory, stored by GitHub per repository, checked against the code, expires after 90 days unused Copilot itself, admins can delete
Knowledge outside the repo (docs, tickets, databases) An MCP server, configured per workspace in a .mcp.json you can commit Whoever runs the server
Current task state, what is half done VS Code session memory under /memories/session/ (Local harness, only for the current conversation); a small notes file in the repo for state that must be shared or kept across sessions The developer and the agent

Not every surface reads every file. Per GitHub’s support table, repository-wide instructions work almost everywhere; path-specific instructions work in VS Code, Visual Studio, JetBrains, the cloud agent and Copilot CLI, but not in GitHub.com chat; VS Code chat reads AGENTS.md as its agent file. Prompt files (.prompt.md in .github/prompts) still exist, but VS Code now runs them only in the Local harness, which it plans to remove in February 2027.

The misunderstanding: more context is more memory

A memory bank feels safe because the agent reads everything, every time. But every file is reread on every task, which costs tokens and fills the context window with things that do not matter for this task. A stale line in systemPatterns.md gets repeated forever, because nothing checks it against the code. Copilot Memory addresses the staleness problem: it checks each memory’s citation against the current branch before using it, and lets unused memories expire. What it does not do is guarantee that a memory is applied; GitHub itself advises keeping must-follow rules in custom instructions.

So the practical split:

  1. Agreed and permanent: instruction files, reviewed in pull requests.
  2. Learned along the way: Copilot Memory.
  3. Outside the repo: MCP.
  4. Today’s work: a short progress.md or task notes, if you want them, referenced from your instructions.

What this means for a team

A memory bank in the repo has one real advantage: it is in git, so the whole team sees and reviews it, and it works for any agent that reads Markdown. VS Code’s own local memory files under /memories/ do not have that; they stay on one machine. Copilot Memory is shared, but only inside GitHub Copilot and only per repository. A team that also uses Claude Code or Cursor gets the best result from one shared AGENTS.md; see How to share AI context in a dev team. How Copilot Memory itself works is on Does GitHub Copilot have memory?.

Where Bombos fits

A memory bank is a folder per repo that someone has to keep up to date by hand. Bombos is a plugin that gives Copilot and the team’s other AI tools (Claude Code, Codex, Cursor, ChatGPT, your own agents) one shared memory: learned rules and team knowledge across repositories, plus what already sits in documents and mail, traceable, in the cloud or on your own server. One developer can try it first with their own agents. Background: What is an MCP memory server?.

Related questions

Where do I put a memory bank for Copilot in VS Code?

Most people keep a memory-bank/ folder in the repo and point to it from .github/copilot-instructions.md or AGENTS.md, so the instructions tell Copilot to read it. Copilot does not read a folder with that name on its own.

Is there an MCP server for Copilot memory?

Several community MCP servers offer memory, and VS Code lets you add MCP servers per workspace in a .mcp.json file that you can commit. GitHub's own Copilot Memory does not need MCP; it is built in.

Are VS Code's memory files the same as a memory bank?

No. VS Code's local memory files under /memories/ live on your machine and are not shared project files. A memory bank lives in the repo, so the team can review it in pull requests.

Can Copilot update the memory bank itself?

Yes, if your instructions tell it to and it runs in agent mode with permission to edit files. Review those edits like any other change, because a wrong line gets reread in every later task.

Sources

  1. Cline docs: Memory Bank
  2. VS Code docs: Custom instructions
  3. GitHub Docs: Support for different types of custom instructions
  4. VS Code docs: Use memory with agents
  5. VS Code docs: Add and manage MCP servers
  6. GitHub Docs: About Copilot Memory
The first half hour · free

What does your AI forget?

  1. 01You tell us which AI you use and where it keeps starting over.
  2. 02We show what a shared memory changes there, on your own examples.
  3. 03You keep the plan, with or without Bombos.
Piet Baudoin
Piet BaudoinYou talk to Piet, from the Bombos teamDutch team from Utrecht and Nijmegen · data in Europe
We reply the same working day.