Build what's next on GitHub, the place for anyone from anywhere to build anything.
Join us October 28-29 in San Francisco or online for GitHub Universe, our flagship developer event uniting people, agents, and the world's code.
Copilot’s cross-agent memory system lets agents learn and improve across your development workflow, starting with coding agent, CLI, and code review.
Our vision is to evolve GitHub Copilot into an ecosystem of agents that collaborate across the entire development lifecycle from coding and code review to security, debugging, deployment, and maintenance. To unlock the full potential of multi-agent workflows, we need to move beyond isolated interactions—that start from scratch each session—and toward a cumulative knowledge base that grows with every use.
Cross-agent memory allows agents to remember and learn from experiences across your development workflow, without relying on explicit user instructions.
Each interaction teaches Copilot more about your codebase and conventions, making it increasingly effective over time. For example, if Copilot coding agent learns how your repository handles database connections as it’s fixing a security vulnerability, Copilot code review can then use that knowledge to spot inconsistent patterns in future pull requests. Or if Copilot code review notices that certain files must stay synchronized, in the future Copilot coding agent will automatically update them together when generating new code.
Copilot’s new memory system is available in public preview, starting with Copilot coding agent, Copilot CLI, and Copilot code review for all paid Copilot plans, with other agents to follow shortly (learn about how it works in our Docs). It’s off by default and fully opt-in, so you decide when and where Copilot should start learning from your workflows.
You can turn on memory in your GitHub Copilot settings.
Learn how to enable memory in our Docs >
Our agents continuously improve at extracting the context needed for specific tasks. The core challenge for memory systems isn’t about information retrieval, but ensuring that any stored knowledge remains valid as code evolves across branches and time.
In practice, this means a memory system must handle changes to code, abandoned branches, and conflicting observations—all while ensuring that agents only act on information that’s relevant to the current task and code state. For example, a logging convention observed in one branch may later be modified, superseded, or never merged at all.
One option would be to implement an offline curation service to deduplicate, resolve conflicts, track branch status, and expire stale information. At GitHub’s scale, however, such an approach would introduce significant engineering complexity and LLM costs, while still requiring mechanisms to reconcile changes at read time. We started by exploring a simpler, more efficient approach.
Information retrieval is an asymmetrical problem: It’s hard to solve, but easy to verify. By using real-time verification, we gain the power of pre-stored memories while avoiding the risk of outdated or misleading information.
Instead of offline memory curation, we store memories with citations: references to specific code locations that support each fact. When an agent encounters a stored memory, it verifies the citations in real-time, validating that the information is accurate and relevant to the current branch before using it. This verification boils down to a small number of simple read operations, adding no significant latency to agent sessions in our testing.
We implemented memory creation as a tool that agents can invoke when they discover something that’s likely to have actionable implications for future tasks.
How Copilot agents store learnings worth remembering as they carry out their tasks.
Consider this example: While reviewing a pull request from an experienced developer, Copilot code review discovers that API version tracking must stay synchronized across different parts of a codebase. It might encounter these three updates in the same pull request:
In response, Copilot code review can invoke the memory storage tool to create a memory like this:
The result: The next time an agent updates the API version in any of these locations, it will see this memory and realize that it must update the other locations too, preventing a versioning mismatch that could break integrations. Similarly, if an inexperienced developer opens a pull request that updates only one of these locations, Copilot code review will flag the omission and suggest the missing updates, automatically transferring knowledge from a more experienced team member to a newer one. 💥
When an agent starts a new session, we retrieve the most recent memories for the target repository and include them in the prompt. Future implementations will enable additional retrieval techniques, such as a search tool and weighted prioritization.
How Copilot enriches agent prompts with memories from previous tasks.
Before applying any memory, the agent is prompted to verify its accuracy and relevance by checking the cited code locations. If the code contradicts the memory, or if the citations are invalid (e.g. point to nonexistent locations), the agent is encouraged to store a corrected version of the memory reflecting the new evidence. If the citations check out and the memory is deemed useful, the agent is encouraged to store it again in order to refresh its timestamp.
It’s important to note that memories are tightly scoped. Memories for a given repository can only be created in response to actions taken within that repository by contributors with write permissions, and can only be used in tasks on that same repository initiated by users with read permissions. Much like the source code itself, memories about a repository stay within that repository, ensuring privacy and security.
The full power of our memory system emerges as different Copilot agents learn from one another.
Each agent contributes to and benefits from the shared knowledge base, allowing agents to reuse validated repository knowledge across tasks. As additional agents adopt memory—whether for development workflows, debugging, or security analysis—they’ll contribute to and benefit from the same evolving understanding of your codebase.
Our biggest concern was the impact of outdated, incorrect, or even maliciously injected memories. To test the system’s resilience, we deliberately seeded repositories with adversarial memories–facts that contradicted the codebase–with citations pointing to irrelevant or nonexistent code locations.
Across all test cases, agents consistently verified citations, discovered contradictions, and updated incorrect memories. The memory pool self-healed as agents stored corrected versions based on their observations. The citation verification mechanism robustly prevented the risk of misleading memories.
For each repository in our evaluation set, we ran agents on diverse historical tasks (predating our target evaluation tasks) and let them populate the memory database organically, using the “store_memory” tool we provided. To simulate worst-case conditions, we overrepresented memories from branches that were abandoned or closed without merging, ensuring realistically noisy memories.
When we ran Copilot code review on the pull requests in our evaluation set, memory usage led to 3% increase in precision and 4% increase in recall.
The ultimate test of our memory system was its impact on real developers in their everyday workflows. We ran A/B tests on the first two Copilot agents to deploy memory, Copilot code review and Copilot coding agent, measuring the impact on key user metrics.
These results demonstrate that cross-agent memory delivers measurable value to developers in their daily workflows.
We’ve deployed repository-scoped memory storage and usage in Copilot CLI, Copilot coding agent, and Copilot code review on an opt-in basis. We’re listening to user feedback and tracking performance metrics closely as we iterate and prepare for a wider rollout across more Copilot workflows. We’re also exploring a range of approaches to tuning memory generation, curation, prioritization, and usage.
Cross-agent memory reduces the need to re-establish context at the start of each task by allowing validated information to persist across agentic workflows. We’re excited about the possibilities memory will unlock, and we’re just getting started. We look forward to your feedback so we can ensure GitHub Copilot continues to evolve in ways that best support your needs. Happy coding!
Read our Docs to learn how to enable memory in Copilot >
