Copilot Memory With MCP: Share Project Context Across AIs
GitHub Copilot has built-in context features, but they do not persist across sessions or share with other AI apps. Connecting an MCP server adds persistent memory for decisions, lessons, and handoffs that every assistant can read.
Updated 4 min read
GitHub Copilot reads the code and files open in your editor during a session, but that context does not carry to the next session and it does not reach another AI app working on the same project. Connecting an MCP server gives Copilot access to a persistent record of project work that survives session ends and model switches.
A tool like fenbs serves as that persistent record. It keeps decisions, rules, lessons, and Where we left off outside any one app, so Copilot can read what was agreed and another assistant can continue from where Copilot stopped.
What Copilot remembers on its own
GitHub Copilot reads the files open in your editor, the repository contents you reference, and the conversation history within the current chat session. In some plans, GitHub Copilot can also read a project's custom instructions from a .github/copilot-instructions.md file. Check GitHub's Copilot documentation (opens in a new tab) for the current capabilities on your plan.
What Copilot does not carry between sessions: the answers it gave in a previous conversation, the decisions the team made during yesterday's coding session, and the lessons learned from a bug that was fixed last week. Each new session starts fresh.
What MCP adds
MCP (Model Context Protocol) is a standard that lets an AI assistant call outside tools during a session. When GitHub Copilot supports MCP, it can call a tool to read a project's context before answering: current tasks, agreed rules, lessons, and the last saved state of the work.
The assistant asks for the context, the MCP server returns it, and the assistant can incorporate that information into the current session. The memory persists because it lives in the MCP server, not in Copilot's conversation history.
This is different from a Copilot memory plugin or extension that modifies Copilot's internal behavior. An MCP connection is an external tool Copilot calls; it does not change how Copilot itself works. See MCP apps for a broader look at what MCP-connected tools can do.
How to check whether Copilot supports MCP
Some AI apps have added in-app memory features that persist within their own ecosystem. Claude Code Projects added shared memory in September 2026; Claude Code reads an AGENTS.md file in the project natively. These are separate from an MCP connection. In-app memory stays within that app's workspace; an external MCP server shares context with any app that connects to the same server.
MCP support in GitHub Copilot is tied to the version of the GitHub Copilot extension in VS Code and the plan you are on. Check GitHub's documentation for the current support status, as this has been evolving.
To test whether MCP is available in your setup: open VS Code with the GitHub Copilot extension installed, open Copilot Chat, and check whether an MCP section appears in Settings or whether the chat panel shows an MCP tools indicator. If you see neither, the extension version you have may not yet include MCP support.
If Copilot does not support MCP in your current setup, the same fenbs project record is available to Claude Code, Claude, Cursor, Codex CLI, Gemini CLI, and Devin Desktop via Integrations. A colleague using Claude can read the same context that Copilot would use.
Give Copilot the project context it needs at the start of each session
With fenbs connected over MCP, ask GitHub Copilot to read the project context before starting. It reads the rules first, then Where we left off, then the current tasks. Before ending the session, ask it to save progress so the next assistant starts from the same point. Create a free account, add your project, and write the first rules that every assistant should read.
Create a free accountFree for one person · No credit card · Works with Claude, ChatGPT, Cursor and more
Shared decisions and lessons across AI apps
The value of an external memory tool grows when more than one AI app uses it. Say your team uses Copilot for day-to-day coding and Claude for writing documentation. If both apps connect to the same fenbs project, a rule set in the morning by a Copilot session is visible to Claude in the afternoon without a manual handoff.
Decisions and rules are the most important shared content. "Do not refactor the payment module until the audit is complete" is a rule that should reach every assistant, regardless of which app is open. Lessons learned are the second most useful: a note explaining why a particular approach caused problems last time prevents the next session from repeating it.
When fenbs is not the right fit
fenbs keeps the work record: projects, tasks, decisions, lessons, and progress. It is not a code index, a vector database, or a way to search your entire codebase semantically. If you need Copilot to search and recall specific code patterns from a large repository, a dedicated code search tool or RAG system (retrieval-augmented generation, a way of searching documents to give the AI more context) is a better fit for that part of the job.
How to do this with fenbs
- Create a free account and add your project. Write the first rules in Decisions and rules: the things every assistant session should know before starting work.
- Go to Integrations and follow the GitHub Copilot guide to connect fenbs over MCP.
- At the start of a Copilot session, ask it to read the project context from fenbs: Rules, Where we left off, and current tasks.
- When you finish for the day, ask Copilot to save progress to fenbs: which tasks moved, what was decided, what is waiting on a person.
- When you switch to another AI app, ask it to read the same fenbs context. It will start from the same state Copilot left.