Project summary

Agent memory is fragmenting into per-vendor silos with incompatible on-disk schemas and no sanctioned cross-agent read/write path. This leads to accumulated user context raising switching contexts and barriers to market entry, reduces long-run innovation, and increases risks from how user context is used when vendor lock-in is stronger.

Our prototype can already normalize session history across twelve-plus coding agents into a single searchable index exposed over MCP and using ACP, demonstrating that interoperable memory is technically tractable and offers more innovative markets, with less lock-in. The aim is to make a user's memory a portable asset they control rather than a moat each vendor holds, with resulting dangers to privacy, market competition, innovation, and standards (quality).

Concretely, this grant allows us to the prototype (which today reads each agent's history and pools it into one searchable place) and turns it into a dependable, well-tested version that other developers can build on; it writes that approach down as a shared specification in two parts, a common on-disk format for how memory is stored and a defined way for tools to search and retrieve it; and it brings the relevant builders together to agree on that specification and move it toward a formal standard at the IETF.

What are this project's goals? How will you achieve them?

The ultimate goal is to advance memory standards and a reference implementation through the IETF, the Agentic AI Foundation, and our colleagues at MCP, Block, and elsewhere. Concretely, based on our prototype above, which integrates with ACP and MCP protocols, the below is this specification and approach written out from the github repo using Claude:

1) Harden the reference implementation. Each agent writes its history in its own on-disk format: JSONL files, SQLite databases, VS Code blob stores, Markdown logs, so the first job is the normalization layer, the code that reads every one of these and converts it into a single common shape. We will stabilize that layer and pin down a canonical session-and-turn record: one data structure that represents a single conversation turn regardless of which agent produced it. It carries the role (user, agent, or tool), the content parts (the text and any structured blocks), the tool-call and tool-result blocks (the function an agent invoked and what came back), timestamps, session and thread identifiers (so individual turns regroup into the conversations they belong to), the project or working-directory binding (which codebase the session was about), the source-agent provenance (which agent it came from), and a content hash: a fingerprint that lets us recognize the same turn seen through two different agents and avoid counting it twice. We then add a conformance suite: automated tests that replay frozen sample copies of each agent's real stores against its parser, so that when a vendor changes its format the test fails loudly instead of silently dropping history. Codex and Goose coverage is partial today for exactly this reason.

2) Draft the interoperability spec in two layers. The first layer is an at-rest format: how memory is written to disk that is vendor-neutral (tied to no single agent), append-friendly (new turns can be added without rewriting the file), and carries a stable scheme for giving each record a durable identity and detecting duplicates. The second layer is the query-and-sync surface: how a tool or agent asks for memory and keeps copies consistent across stores. That means, first, formalizing the MCP tool contract: specifying exactly what search_memory and get_session accept and return, including paging through large result sets, filtering by role (for instance, returning only the user's turns), and time windows (only turns since a given point). And second, specifying how that surface composes with ACP's own session/list and session/load calls, including a proposed capability flag that lets an agent advertise it can serve its complete history rather than the short recent slice its adapter exposes today. We publish the result as an RFC-style Internet-Draft on the IETF datatracker — a written specification backed by running code, which is how the IETF expects proposals to arrive.

3) Sketch the write path and permission model. The prototype only reads memory today. The harder step is letting agents write into a shared, user-controlled store and read one another's memory, which immediately raises the question of who may read or write what, and on whose consent. The design has to bound the interaction hazards this opens up: the prototype already guards against one of them: the fan-out where the server spawns an agent that spawns the server again in an unbounded loop, blocked by the ACP_MEMORY_DISABLE_RECURSION flag; and a cross-agent read/write path widens that surface. We seed adoption through a working session with the Goose team (whose agent is ACP-native) and the Agentic AI Foundation, aiming for agreement on the record format and a shared conformance profile.

How will this funding be used?

Of a $30,000 grant: roughly $22,000 covers about three months of part-time engineering work concentrated on the normalization-and-conformance layer (the canonical record schema, the per-backend parser test suite, and the at-rest format); and the remainder covers overhead and fringe benefits (through Code for Science and Society). Additional funding above this then: helps cover iterations and improvements through community feedback and the standardization working session (~$10,000); and additional funding would then support integrating the specification into public technical standards work (~$20,000). Partial funding still ships the hardened implementation and the draft spec; the full amount adds the iterative development work and the advocacy & standards / adoption work through partner institutions.

Who is on your team? What's your track record on similar projects?

The project is led by the AI Disclosures Project, co-directed by Ilan Strauss (economist, UCL Institute for Innovation and Public Purpose and the University of Johannesburg) and Tim O'Reilly (O'Reilly Media), with Sruly Rosenblat as the engineer who built and maintains the prototype: twelve-plus agent backends, an FTS5 index, and the MCP tool surface, in working code. We are fiscally hosted by Code for Science & Society, a 501(c)(3). Adjacent track record includes initial writing on open-protocols and memory walled garden, a 2025 convening on missing mechanisms for the human-plus-AI economy in Bellagio, Italy, and ongoing specification work with leading public-interest and open-protocol communities. Our work is covered in the Financial Time, Tech Crunch, AI Frontiers, and peer-reviewed journal publications (Applied Economics Letters, Data & Policy, AI & Ethics - forthcoming).

What are the most likely causes and outcomes if this project fails?

The leading technical risk is schema drift outrunning the parsers: vendors change their stores and quietly break the readers, which is why the conformance suite and pushing the at-rest format for native emission matter more than the parsers themselves.

The leading non-technical risk is that vendors have sufficient lock-in to resist a write path or a full-history capability, and no single model or application forces consensus adoption in the market.

Another risk is a premature abstraction: the turn model may not survive richer tool-graph or multimodal sessions, which we mitigate by versioning the record format and keeping the spec minimal.

Even if standardization fails, the grant still leaves three things worth having: a working tool, a specification that shapes whatever standard comes next, and a published argument. Since a local-first, read-side reference implementation remains a usable public good that lowers switching costs for whoever adopts it, the RFC-style note can inform whatever standard does eventually emerge, and the economic write-up advances the policy argument regardless of whether the standards process lands.

How much money have you raised in the last 12 months, and from where?

Several hundred thousand from public-interest, non-profit technology philanthropies. More: https://ai-disclosures.org/