Three AI Agents Sharing One Memory: What Happens

An experiment. Someone working with OpenAI's coding agent Codex on a MacBook Air had casually expressed a few work preferences in conversation. A few days later, he sat down at a Mac Studio and opened a brand-new session—note: this was a separate, independent Codex process, with no session history to inherit. After a few exchanges, this new agent already knew those preferences and followed them.

No copy-pasting in between. The two agents didn't know each other existed. They were simply connected to the same memory.

The system behind the experiment is called Hindsight, an open-source project by Vectorize under the MIT license. Eight days ago this account dissected its memory design (four layers: facts, experiences, observations, and mental models, with observations evolving alongside evidence); this experiment touches a different dimension: where the memory lives, and who can read it.

The Only Secret: A Shared Bank

First, demystify the experiment. There is no magic—the mechanism boils down to three lines.

Hindsight installs two hooks into Codex. At the start of a session, auto-recall runs first: it takes your prompt, queries the memory bank, and prepends the relevant facts as context you never see—the agent sees it, so you don't have to repeat yourself. At the end of a session, auto-retain runs: the entire conversation is handed to a model, which extracts facts, entities, timestamps, and relationships worth remembering, and writes them into the bank.

The cross-device part is even simpler. A Hindsight memory bank is a server process, and each bank has its own ID. If you install Codex on three machines and their config files all point to the same bank ID on the same server, all three agents read and write the same ledger. The one on the MacBook Air wrote the preferences into the bank at session end; the one on the Mac Studio queried it at session start and found them.

So strictly speaking, what happened wasn't "memory sync"—it was "two agents sharing one external organ." Sync implies devices negotiating data exchange; here there is no inter-device communication—there is one bank, and whoever connects to it uses it.

The cloud version turns this into a product: the bank lives server-side, and the official copy says "memory follows you across machines." Same for company team plans: everyone points at the same bank ID and writes into the same memory.

Memory Decoupled from the Model

The interesting part isn't the experiment itself—it's the architectural fact it conveniently demonstrates: the memory layer and the model layer are separate.

This is clearer seen in reverse. Today's personal AI assistants store your conversation history, preferences, and everything you've taught them inside the model vendor's session system. Switch vendors and you start from zero; when models get upgraded, your memory follows the platform's rules. Your "AI knows me" asset sits in someone else's hands.

The structure in this experiment is different. The three agents are temporary, replaceable, and strangers to each other; the bank is persistent, owned by you, MIT-licensed, and can run locally. Swap agents—even swap to another vendor's—and as long as the agent supports connecting via the MCP protocol, your accumulated memory stays put. Claude Code, Codex, opencode, and several other clients all have official integration paths.

A line from the source material captures the architectural judgment well: models can change, agents can differ, and long-term memory keeps growing on its own. This isn't a metaphor—the mental-model layer in the bank is literally documented judgment accumulated over time. Models read it; they don't own it.

The Risks of a Shared Ledger

Sharing one organ has costs that must be stated plainly.

First, errors cross-contaminate. Auto-retain is automatic extraction: whatever an agent says in a session gets recorded as fact. With three agents writing to one ledger, one agent's hallucination can become three agents' consensus. Hindsight's mitigation is its observation layer—every conclusion carries original citations and corroboration counts, and new evidence strengthens or weakens old conclusions rather than overwriting them. This mechanism can handle "correction," but not "three agents reinforcing the same hallucination together."

Second, the memory bank becomes a new critical asset. Whoever controls the bank controls the "personality continuity" of every agent connected to it. The more accumulates in the bank, the more valuable it becomes—it is essentially a structured personal profile. Incidentally, Hindsight has a privacy-filtering feature called Memory Defense, with forty-five patterns to block personal information from entering the bank—off by default; you have to enable it yourself.

Third, that publicly circulating leaderboard result comes from a benchmark site run by the vendor itself—apply the customary discount when reading it.

A One-Command Replication

The experiment is worth reproducing yourself, at near-zero cost. One curl command installs the hooks, run a memory bank locally, point two Codex instances in different directories at the same bank ID—and you'll watch what the first agent wrote appear in the second agent's replies. That "how did it know" moment is more intuitive than any architecture diagram.

The earlier post covered how memory is organized; this one covers where memory lives. Put together, they form the complete answer: a long-term memory that is yours, structured, readable by anyone but owned by no one—in the personal AI era, this may be the asset truly worth accumulating.

---

*Sources: Hindsight repository (vectorize-io/hindsight, MIT, 51,006 stars, still updated as of 10-17); Vectorize official blog post "Adding Persistent Memory to OpenAI Codex with Hindsight" (2026-04-08, covering the three scripts and the shared bankId mechanism); arXiv 2512.12818 (four-layer memory design); this account's 10-10 analysis post (memory model design). The experiment was a three-device live demonstration by the source author.*