Your AI's Memory Expires in 30 Days

AI memory has version history now. In Anthropic's Managed Agents memory stores, a developer API currently behind a beta header, every change an agent makes to a memory creates an immutable version with point-in-time recovery. It's a good design, and it's more than most vendors bother with.

Those versions are retained for 30 days. Recent ones are kept regardless of age, so a memory that rarely changes can hold history for longer. The rest "might be deleted." To keep them, you export them through the API before the clock runs out.

I looked at fAI's record of my own work this morning. 14,040 individual capture commits, going back to the day I installed it. The oldest one is still there, and nobody is going to delete it.

fAI is a personal AI workbench that runs under whatever AI coding tools you already use, captures your work as it happens, and keeps what it learns in ordinary git repositories on your machine.

The Memory You Don't Hold

Remembering has stopped being the interesting problem. By early 2026, every major platform ships something that carries context between sessions. That's table stakes now.

The question is who holds it, and on what terms. Anthropic ships both halves of an answer, and neither half is yours to hold.

The versioned half. The memory stores above are real history, but on a clock, in a workspace you reach through an API. There's no dedicated restore endpoint either, so rolling back means fetching the version you want and writing its contents forward yourself. You're renting an audit trail.

The local half. Claude Code, from the same vendor, keeps its memory as plain files on your disk: a CLAUDE.md at project and user scope, plus a per-project memory directory. You can open it and edit it. That's the better instinct, and it's genuinely useful. But ~/.claude isn't a git repository. Check yours. Nothing recorded how those files came to say what they say, so you can read what your AI thinks today with no way to see what it thought last week, or what changed its mind.

One half gives you history you don't keep. The other gives you files with no history to keep.

Nobody is going to forensically trace a single bad suggestion. You correct it and move on. The value of a record shows up later, and in bulk: checking whether what your AI believes about the project is still true, seeing how your conventions actually drifted over a quarter, handing a new agent six months of accumulated context instead of re-explaining it, asking a question of your own work that nobody thought to ask at the time.

All of that needs the record to still be there.

That's the actual gap. Not does it remember. Do you hold the record?

What Owned Context Looks Like

Notice the word we keep avoiding. The terms overlap in practice, so this is our usage rather than a definition: context for the part you hold, memory for the part held about you.

Four properties matter:

Owned. It lives in ~/.fai/ on your machine, not in a table in someone else's cloud.

Portable. The same context feeds every agent you use, over MCP. Claude Code, Cursor, Copilot, Windsurf, Codex, JetBrains AI, and ten more. Sixteen tools, one vault.

Compounding. It gets richer the more you work instead of sitting there.

Git-Backed. Real git underneath. History, diff, provenance.

We've argued the first three already: ownership as economics, portability across tools, and context that compounds into something closer to thinking.

The fourth one we've only ever asserted in passing. Here's the argument.

What Git Log Gives You

Your vault is a git repository. Not "versioned like git," not a database with a history table. Actual git, which means the tools you already know work on it.

It comes in two layers, and the difference is the point.

Two layers of the vault: a handful of synthesis files rewritten every pass, beside 14,040 kept capture commits, with synthesis built from the record

The synthesis is a small set of files kept current so your agents start informed: what the project is, the decisions that still hold, the conventions you actually follow, your own preferences. This is the part you read. It gets rewritten constantly, so you don't hand-edit it. When your AI has something wrong about the project, you correct it in the conversation. fAI captures that correction, and later synthesis carries it forward. A handful of markdown files, not an archive.

The record keeps everything. One commit per capture, and on this machine that's 14,040 of them:

$ git log --oneline -3
1c3d48fa Vault capture [log-reader]: fd50bf47...-claude-session.jsonl
81e87061 Vault capture [log-reader]: fd50bf47...-claude-session.jsonl
138368f8 Vault capture [log-reader]: fd50bf47...-claude-session.jsonl

Captures land on a working branch, accumulate while they're still unsettled, and merge into what's kept once accepted. Nothing gets flattened on the way in. Accepts land as ordinary two-parent merges, so what's kept stays connected to the captures behind it instead of replacing them. Squash those merges and that trail is gone.

Three things fall out of this, and none of them are features we had to build:

History. Every capture is its own commit, timestamped, naming the session it came from. How your context got to be the way it is stays on the record. Permanently, not for 30 days.

Diff. Because each capture is a discrete commit rather than a row that got updated, you can see what a given session actually added. Not where things ended up. What changed.

Provenance. A commit carries content, author, timestamp, and parent, and each capture names its session in the subject line. The record preserves the work your context came out of. Provenance isn't a feature here. It's what a commit is.

The Industry Already Agreed

We settled this argument for code a long time ago. Nobody ships without version control.

Code got versioned because nobody could tell, at the time of writing, what a given line would later have to answer for: a bug six months out, an audit, a rewrite, a question nobody had thought to ask yet. History was worth keeping precisely because its future uses were unknowable.

Accumulated context has that same property and almost none of the same infrastructure. It has never been standard to version what your AI knows about you, which is strange, since that's the part quietly steering everything else.

Git democratized code ownership. fAI does the same for context: everything captured stays, in a format anything can read. Whatever you want to ask of it later, and whatever tools show up to ask with, the material is on your disk waiting.

Own It, Don't Just Trust It

One honest caveat, because local-first gets oversold.

Local storage is not privacy. The moment your context goes into a prompt it travels to whoever runs the model, and a vault on your disk doesn't change that. If you want the prompt itself to stay home you need the model at home too, which is a different post.

Ownership is a different claim, and a simpler one. You can read it, correct what your agents carry forward, roll it back, take it with you, and still have it in a year. When you switch tools it comes along. When you stop paying us, it's still sitting there.

Own the Record

Your AI is going to keep learning things about you. Someone holds that record either way. The question is who, and for how long.

Thirty days is a grace period, not a memory.

On macOS or Linux:

curl -fsSL https://www.fathym.com/fai/install.sh | sh

On Windows:

iwr -useb https://www.fathym.com/fai/install.ps1 | iex

Then run fai in your project, work for a week, and look at what accumulated. Your vault stays in ~/.fai/. Yours to keep.

Build anything with AI. Keep everything. Evolve forever.

Start building - free ->

Read more: See What Your AI Sees ->