Who Owns Agent Memory? The Shift From Agent-Centric to Human-Centric Design
A 2026 arXiv paper reframes agent memory as an asset the human or organization must own, not something a vendor platform controls — here's what that shift means in practice.
Who owns the memory an AI agent accumulates over months of conversations, tool calls, and task history — the agent, the platform that hosts it, or the human and organization that built it? The question sounds abstract until a team tries to switch model providers, respond to a data deletion request, or migrate off a managed agent platform and discovers the memory doesn't come with them. A 2026 arXiv paper puts a name to the shift underway: moving agent memory design from agent-centric to human-centric.
The Agent-Centric Default
Most agent memory today is agent-centric by default, not by malice. It's the path of least resistance. A framework or hosted platform stores conversation history, embeddings, and derived facts in whatever internal format serves its own retrieval pipeline best. The schema is optimized for the agent's next inference call, not for a human auditor or a future migration. Export, if it exists at all, is a secondary feature added after the core product ships.
This isn't specific to any one vendor. It's a structural property of building memory as an internal implementation detail of an agent runtime rather than as a standalone asset. The agent works well. The memory works for the agent. Whether the memory works for the organization that depends on it — six months later, under a different model provider, or under a compliance audit — is a separate question that agent-centric design doesn't answer by default.
What "Memory as Asset" Means
The paper "Memory as Asset: From Agent-centric to Human-centric Memory Management" (arXiv:2603.14212) frames this directly: agent memory should be governed the way any organizational asset is governed, with ownership, inspection rights, and portability treated as first-class design requirements rather than implementation details left to whichever vendor happens to host the agent.
The shift the paper describes is a shift in obligation. Under an agent-centric model, memory exists to serve the agent's internal operation, and portability is an afterthought if it's addressed at all. Under a human-centric model, memory is treated as belonging to the human, developer, or organization that generated it — independent of any single agent, model, or vendor. The agent is a consumer of the memory, not its owner.
The practical test this framing implies is simple: can the memory be exported, audited, deleted, or moved to a different provider without loss, and without requiring the original vendor's cooperation? If the answer involves a support ticket, a rate-limited export API, or doesn't exist at all, the memory is agent-centric regardless of what the product page says.
Why Ownership Becomes a Practical Problem, Not a Philosophical One
This distinction stops being academic the moment an organization depends on accumulated agent memory for more than a demo. Three situations surface it fast.
- Vendor lock-in. Memory that lives only inside a proprietary hosted database ties the agent's institutional knowledge to that vendor's roadmap, pricing, and uptime. Switching agent platforms means starting the memory from zero, or negotiating a migration that the vendor has no strong incentive to make easy.
- Compliance and data residency. Regulated industries increasingly need to say precisely where memory data lives, who can access it, and how it's deleted on request. That's straightforward when memory is a file or a self-hosted database under direct control. It's harder when memory sits inside a third party's managed infrastructure and export or deletion depends on that vendor's internal tooling and support process.
- Model and framework switching. Agent teams change models and frameworks more often now than they did two years ago — a new model ships, a framework's pricing changes, a better retrieval approach emerges. Memory accumulated over months of production use is often more valuable than any single model choice. Agent-centric memory ties that accumulated value to the platform it was built on; human-centric memory keeps it available across whichever model or framework comes next.
None of these are hypothetical edge cases. They're the ordinary lifecycle of a production agent system: it gets audited, it gets migrated, it outlives the tool it was originally built with.
What Human-Centric Memory Looks Like in Practice
Applying the paper's framing to actual system design, a few properties recur: the data format is inspectable without special tooling, export doesn't require vendor cooperation, and the memory isn't cryptographically or structurally tied to one agent runtime.
Feather DB is one concrete example of this design choice, described here factually rather than as a pitch. Feather DB stores the entire memory store — vectors, metadata, everything — as a single, portable .feather file. There's no server-side proprietary format to export from, because there's no export step: the file is the data. A developer can copy it, put it in version control, back it up, inspect it directly, or move it to a different machine or a different agent framework, the same way they'd handle any other file on disk. Feather Core, the underlying engine, is MIT-licensed and self-hosted, which removes the vendor-cooperation dependency entirely — there's no support ticket required to get the data out, because the data was never inside someone else's boundary in the first place.
This isn't the only way to build human-centric memory. A self-hosted Postgres instance with a documented schema and a straightforward export path satisfies the same ownership test. The common thread across approaches that pass the test is that the human or organization can act on the memory unilaterally — inspect it, move it, delete it — without asking permission from the system that originally wrote it.
What This Means for Teams Building Agents Now
The paper's contribution isn't a new algorithm or benchmark. It's a governance framing that's easy to skip when a team is optimizing for time-to-demo. Evaluating a memory layer on retrieval accuracy alone misses the ownership question entirely — a system can retrieve relevant context flawlessly and still leave an organization with no way to get that context out if the vendor relationship ends.
A useful practical check before adopting any memory layer, hosted or self-hosted: ask what happens to the accumulated memory the day the vendor relationship ends, the model provider changes, or a regulator asks for a full export. If the answer requires the vendor's active participation, the memory is agent-centric. If the organization can act on it alone, it's human-centric. That one question, applied early, avoids a much more expensive migration conversation later.
Frequently Asked Questions
What does "agent-centric" versus "human-centric" memory actually mean?
Agent-centric memory is designed primarily to serve the agent's or platform's internal retrieval pipeline, with portability and export as secondary concerns. Human-centric memory treats the data as an asset the human, developer, or organization owns and controls independently of any specific agent, model, or vendor — with inspection, export, and deletion as first-class requirements, per the framing in arXiv:2603.14212.
Why does memory ownership matter for compliance and data residency?
Regulated teams frequently need to answer precisely where data lives, who can access it, and how it's deleted on request. That's straightforward to demonstrate when memory is a file or self-hosted database under direct control. It's harder to demonstrate quickly when the memory lives inside a third-party managed platform and every export or deletion request depends on that vendor's internal process and cooperation.
Does memory portability actually prevent vendor lock-in?
Portability reduces lock-in risk but doesn't eliminate switching costs entirely — there's still integration work involved in moving to a new framework. What portability changes is whether the accumulated memory itself is a sunk cost tied to one vendor, or an asset that carries forward regardless of which agent platform or model is in use.
Does using a single-file database format solve the ownership problem by itself?
A portable file format removes the technical export barrier — there's no proprietary schema to migrate out of, and no vendor cooperation required to read or move the data. It doesn't automatically solve governance questions like access control or retention policy; those still need to be designed. But it removes the most common practical blocker: not knowing whether the data can be extracted at all.
If you're evaluating how portable your agent's memory actually is, Feather DB is free to try and open for inspection from the first file it writes.