Persistent Memory For AI Coding Agents Just Went Mainstream

The changelog entry is almost boring.

On October 28, 2026, GitHub announced that Copilot Memory is generally available on paid plans. No keynote.

No waitlist language.

Just a switch you flip. And with that, persistent memory for AI coding agents stopped being a weekend experiment and became shipped product surface.

The run-up happened inside a year. Letta shipped Letta Code in December 2025 as a memory-first coding agent.

Supermemory followed on February 18, 2026.

A Wednesday. With a blueprint for stateful agents and a plugin for Claude Code and OpenCode.

Three vendors, three architectures, one bet: the agent that remembers you wins.

Run a coding agent on anything real and you already know the defect.

Brief it on your conventions, get competent work, close the session. The next one arrives knowing nothing, and you pay for the same onboarding in tokens, every time, forever. The industry has finally agreed that is a bug, not a law of nature.

How Persistent Memory For AI Coding Agents Actually Works

The first industry answer was bigger context windows, and it was the wrong answer.

A window is counter space in a kitchen.

A bigger counter lets you spread out tonight’s mess. And by morning every trace of it is wiped, because a window resets when the session does. It gets refilled at full price on every task. And it weighs last month’s dead end exactly the same as the decision that still stands.

Memory is the drawer where the good knife lives. Selective retention: keep the conventions, keep the architecture calls, keep what already failed, drop the noise.

Watch the vendor claims converge on that exact list. Supermemory says its plugin “remembers your preferences, learns your codebase. And never loses context mid-conversation.” GitHub says “Copilot can remember personal preferences and repository conventions across sessions and clients.” Preferences plus codebase conventions, from opposite ends of the market.

Storage was never the hard part.

Deciding what survives is, and that is where the three approaches genuinely differ.

Three Architectures, One Bet

Supermemory: the plugin

The retrofit. You keep the agent you already run and bolt memory onto it. A plugin for Claude Code and OpenCode that, in the company’s words, “gives your coding agent persistent memory.” Duration is the entire pitch: “The result is an agent you can run for months without starting over.” Of the three, this is the cheapest way to test the idea against a repo you already have.

Letta: the runtime

The rebuild, and the deepest bet in the field.

Letta Code landed in December 2025 as a memory-first coding agent. And Letta bills it as “the #1 model-agnostic open source agent on the leading AI coding benchmark Terminal-Bench.” The runtime combines “git-backed memory, skills, subagents. And deployment that works across every model provider,” and it can orchestrate Claude Code and Codex agents as context-isolated subagents for debugging, review, and implementation work. By August 2026 the Agents SDK stretched the claim to agents that keep identity, memory. And experience across models, machines, and interfaces. An April 2026 app put personalized agents that “learn over time” on your local machine. Memory as the foundation, not the accessory.

GitHub: the platform

The absorption. GitHub describes its intelligence layer as “the context and learning layer sourced from the graph of GitHub data,” built to help agents “remember how you work, keep that guidance current.

And find the code and development history relevant to the next task.” Three capabilities carry it: memory across sessions, “dreaming” to keep the context current. And code search that “reaches beyond your checkout.” The insight worth stealing is that your commit history is the memory substrate, since it is where your code already lives.

My read, priced with the knowledge that I have been wrong about this category before: the plugin is the trial, the runtime is the bet, the platform is the default. And “dreaming” is the tell.

When a company with GitHub’s resources spends one of its three named capabilities on keeping memory current, the hard problem is decay, not storage.

Persistent Memory Risks Nobody Benchmarks

Every sales page in this category stops at “store and retrieve.” The failure modes start after that.

And none of the marketing covers them.

Stale memory leads.

An agent that learned your conventions in February will enforce them in October, after your stack and your priorities have moved on. GitHub giving “dreaming” a name is an admission that memory rots and that keeping it current is real engineering work. Forgetting is a feature, given that an agent remembering everything holds your mistakes with the same fidelity as your best decisions.

Privacy is quieter. “Learns your codebase” means proprietary source flows into a memory store you did not build. And GitHub’s layer is explicitly “sourced from the graph of GitHub data.” Your repository’s history becomes agent context.

Ask where that store lives, who reads it, and what happens to it when you cancel. Letta’s app running “locally on your machine” is the counter-position. And for anyone whose repos are not public, local memory is the only version that requires no trust.

Lock-in is the expensive one.

Memory is the new switching cost: once your conventions and project history live inside one vendor’s memory layer, leaving means starting from zero.

The exact problem you paid to solve. Notice Letta sells the escape hatch hardest, with a model-agnostic agent and an SDK that keeps memory “across models, machines.

And interfaces.” Portability is the pitch precisely where lock-in is the risk.

None of it shows up in the benchmarks. Terminal-Bench ranks how an agent performs coding tasks within a session and says nothing about whether the agent still knows your conventions next Tuesday. “Months without starting over” stays a vendor promise until you verify it on your own repo. The missing cross-session recall benchmark is the loudest silence in the category.

What To Actually Do This Week

1. Start where you already pay. Copilot Memory is generally available on paid plans, so the whole experiment costs one settings screen.
2. Flip it on, then audit what it actually remembered and correct it the same day.
3. Choose memory you can inspect. Letta’s runtime is open source with git-backed memory. So when the agent remembers something wrong, there is a place to look. Memory you cannot read is a liability, not an asset.
4. Run the two-session test before trusting any of them: teach the agent one project convention, end the session, come back the next day, and ask. One convention held across one night is worth more to me than any leaderboard claim. It is the only benchmark shaped like your actual workflow.
5. Keep the delete button within reach.

Memory systems accumulate stale entries fast, and the ones that cannot forget are the ones that fail silently.

The real change here is tenure, not storage. Agents with persistent memory stop being task rentals and start building project knowledge the way a person does, which favors operators who stick with one agent on one codebase long enough for the compounding to show. It also favors operators who prune, since the rot compounds too.

Persistent Memory FAQ

What is persistent memory for AI coding agents?

Retention that survives the session.

The agent keeps your preferences, your repository conventions.

And the decisions that already failed, instead of relearning all of it every time you open a window. A context window is not memory — it resets, and it gets refilled at full price.

Is Copilot Memory free?

No. Per the October 28, 2026 changelog, Copilot Memory is generally available on paid plans. If you already pay, the experiment costs one settings screen.

Does it work across sessions?

That is the claim. GitHub says Copilot “can remember personal preferences and repository conventions across sessions and clients.” Claims are cheap; run the two-session test above and see what survives the night.

Can I self-host persistent memory?

Partially. Letta Code is a memory-first open-source runtime with git-backed memory. And its April 2026 app runs personalized agents “locally on your machine.” Copilot Memory is a platform feature tied to GitHub’s intelligence layer. Supermemory’s route is a plugin for Claude Code and OpenCode rather than a self-hosted stack.

Which one should I try first?

The cheapest test available to you. Paying for Copilot already means the switch is one screen away; wanting memory you can read means starting with the open-source runtime. Persistent memory for AI coding agents is now cheap to try and expensive to ignore.