An analysis of why a person starts from scratch with each new service, who is already trying to break this, and how memory should be structured to live with the person, not within a single platform.
Today, people pay for convenience by having each new service force them to reintroduce themselves. This is not a minor inconvenience; it's a barrier to everything new: if switching to another tool costs hours, you stick with what you're used to. This analysis answers three questions: Why is this the case, who has already tried to break it, and how should memory be structured so that it belongs to a person and connects to any application?
Human memory today is locked inside platforms. The only serious scientific work on its transfer was published in May 2026, and it honestly admits: it's a protocol, not a product. Large platforms do not give up memory because it is their retention. States build identity wallets, but not transferable memory. The empty space is exactly where three things converge: a file that a person owns, a service that accepts it, and rules by which only a part is shown. No one stands on the combination of these three. This is our work.
The complaint sounds simple: you come to a new tool and explain yourself anew. Who you are, what you do, how to address you, what you can't stand, what you've already tried and quit. A month later, the same work in the next service. This is the reason why people don't try new things: not laziness, but the cost of entry.
Marina put it more accurately than any report: it's hard to try something different from what you're used to. This phrase hides the entire economy. A product doesn't lose to a competitor; it loses to habit, because moving is more expensive than staying. If you remove the cost of moving, it's not the interface that changes, but the market itself.
Everywhere you have to start from scratch, again and again, and the question is why, what for?
From correspondence, 02.11.2026Dmitry called this a pain point and immediately pointed out a solution: products must support each other. This is more important than it sounds. As long as each service is a separate world, support is impossible. It becomes possible exactly at the moment when something common appears, which is transferable between services and belongs to the person. This common thing is transferable memory.
The pain is quiet. A person doesn't complain; they just don't try new things. The loss is not visible in a report or a metric: it's in what didn't happen. That's why the market has lived with this problem for so long. Whoever solves it will get not a feature, but access to someone else's churn: everyone who leaves a platform will leave with their memory.
Transferable memory is a layer of context managed by a person: it is preserved between interactions, moves between tools, and is shown selectively, by role, consent, and purpose. This is how the subject is defined in the work of the Stanford Digital Economy Lab, prepared together with the Gates and Mozilla foundations and with AWS.
It's important to immediately distinguish this from related concepts, otherwise the conversation goes astray.
An archive is the past: correspondence, files, history. Memory is a person's living understanding, from which conclusions are drawn. An archive can be uploaded to an archive; memory cannot.
A database stores facts. Memory changes with the person: what was true a year ago ceases to be true, and the system is obliged to notice this.
An account is tied to a service. Memory must live outside of any service, otherwise it is locked again.
A registry in someone else's cloud or on a blockchain does not give a person control. It gives control to whoever holds the registry.
First: a person can add, change, and delete it, like a profile in settings. Second: a person can grant access to one part and close off another. Third: it moves not only between chats, but also between regular applications where the agent comes to work. Without the third property, it's just good memory for one service.
The only scientific paper that directly describes memory transfer between different agents was published on May 10, 2026 (arXiv 2605.11032). It proposes breaking down memory into five constituent parts. This is useful because different parts have different costs and different risks of leakage.
| Layer | What's in it | Risk of leakage |
|---|---|---|
| Events | what happened: steps, conversations, incidents | medium |
| Knowledge | stable conclusions about the world and about a person | medium |
| Skills | how to do: techniques, sequences, recipes | low |
| Working state | what's open right now, unfinished business | high |
| Identity and preferences | who you are, how to address you, what you can't stand | highest |
The work adds three things that make the transfer technically safe. First: records are linked by a provenance graph, where each refers to the previous one by hash, so byte substitution is visible. Second: access is granted by capabilities, meaning the application gets the right to read a specific piece, not the entire file. Third: when transferring to a foreign model, protection against an injected foreign command works, because recalled foreign content is dangerous in itself.
Memory is not one file, it's a set of layers, each with its own risk price. This means formats and access rules must work by layers, not entirely. Our passport prototype already signs a list of records and allows partial issuance, meaning the form matches the scientific one. This coincidence is not accidental: both we and the authors of the work ran into the same problem.
Today, a person's memory resides within the service that collected it. ChatGPT remembers your preferences, but only within ChatGPT. Leaving the platform means leaving your memory with it. This is not an accident or an oversight, it's a design: memory is what holds you.
This is why the complaint about "starting from scratch" is not solved by the platforms themselves. They are interested in the exact opposite: the more a person has invested in memory, the more expensive it is to leave. Portable memory is not an improvement to their product, it's a renunciation of their advantage. Hence a simple conclusion: they won't invent portability.
While the platform's memory is not relinquished, portable memory can only function as a side-mounted add-on: a person manages their own memory and connects it to services via a common layer. This means that even with an ideal format, the first applications will need to be convinced to adopt it. If no one adopts the reception layer, we will have a beautiful file that no one uses. A separate section below addresses this risk.
Verifiable evidence that memory is not relinquished. ChatGPT export exists and can be requested in half a minute, but you don't get what you need.
| What is included in the archive | What remains inside |
|---|---|
| Correspondence from all chats | Memory about the person |
| Account data | Personal interaction instructions |
| One-time download link | Assistants you created and uploaded files |
Three details it's fairer to know in advance. The archive takes up to seven days, the download link lives for 24 hours. For self-service business plans, there is no self-service: you must request through the workspace owner. And if an account is merged into a shared workspace, the archive must be requested in advance; later, the right may not exist.
An archive is a photograph. Portability is a living organ that works immediately in a new body. Export provides a photograph: a JSON with messages that can be placed in a new chat as a reference file, but it will not restore memory, instructions, or habits. This is not portability; it is a report of the past. A reader who wants to verify this themselves will open the correspondence transfer page in the help section and see exactly these points in the list of what the process does not do.
Empty space must be measured against everyone who approaches it, otherwise it's easy to assume we are the first. There are no firsts, but everyone walks their own path, and almost no one does the same as us.
| Who | What it does | What it doesn't do |
|---|---|---|
| Mem0 | memory layer for agents, open and cloud-based, structured offloading. Round $24M, October 2025 | memory belongs to the developer, not the person; the person does not have a file |
| Zep | managed memory, strong memory benchmarks | same: the person does not have their own copy |
| Letta | agent environment with its own long-term memory | memory is tied to the environment |
| Cloudflare Agent Memory | memory as infrastructure in the cloud | the person has no offloading |
| Supermemory | memory engine, seed round $3M | memory belongs to the product, not the person |
| Inrupt and Solid | data storage owned by a person, data wallet, agent wallets | there is no tight coupling of "memory plus reception in a third-party application" |
| Mem0 and similar | export for transfer between our own deployments | no single open format between vendors |
The picture is as follows: the memory layer for agents has already become infrastructure, but it's about the developer. Storage owned by a person exists, but it's about files in general, not about a living understanding of a person. These two lines converge exactly nowhere.
Memory layer companies sell their deployment, so memory within their system is profitable for them. Storage companies sell space, so they don't care what data is there. Between these two interests lives the person who needs not infrastructure for others, but their own memory for themselves. This gap is our niche, and it's not about making yet another memory for agents.
The conversation about memory easily devolves into a manifesto, so we stick to the works. Below is what has actually been published, indicating what each work proves and what it does not prove.
| Work | Year | What was done | Limit |
|---|---|---|---|
| Portable Agent Memory (arXiv 2605.11032) | May 2026 | protocol and working library: memory transfer between GPT-4, Claude, Gemini, Llama models; 54 passed tests; Apache 2.0 license | this is a transfer protocol, not a human product; the file and reception are out of scope |
| Stanford, Human Context Protocol | March 2026 | human-managed memory architecture; report with Gates and Mozilla foundations and with AWS | this is a concept and work program, there is no live 'file plus reception' link |
| Are we ready for an agent-native memory system (arXiv 2606.24775) | June 2026 | decomposed agent memory into four parts: representation, retrieval, storage, utilization | overview, not a format |
| Mem0: production-ready long-term memory (arXiv 2504.19413) | April 2025 | engineering work on long-term memory in a working product | within a single system |
Memory transfer between different models is technically possible and demonstrated with live code. The concept of 'human-managed memory' has already been formulated at an academic level. What is missing: not a single deployed format that a person carries with them and that foreign ordinary applications accept. This is not a guess, it is a consequence of the fact that the reception layer is not described in the listed works.
Memory transfer between models is not yet trust in memory. The work proves that bytes can be transferred without loss. It does not prove that the accepted content is truthful, that the person agrees to every line, and that someone specific is responsible for harm. A signature proves signatures and bytes, not the truthfulness of a line. This must be stated first, otherwise the conversation about trust will fall apart at the very first question.
Attempts to make human data portable are not new, and failures here are more informative than successes. An analysis by the venture fund Torch Capital identifies two lines that almost worked and then failed.
Transferring medical data to the individual. People want this, but data is fragmented across clinics, locked in old systems, and poorly standardized. The idea is sound, but implementation drowned in the disunity of sources.
The individual is paid directly for their data. This didn't work: the amounts are too small to interest anyone, and without a huge number of participants, the model doesn't function. The idea is sound, but the economics don't add up.
The general conclusion from both failures: portability fails not due to technology, but due to two things. First, the data lacks a single owner responsible for its collection. Second, the individual lacks sufficient motivation to bother.
Before, there was no one willing to collect a person's memory for them: the agent does it themselves while working. This removes the first reason for failure. But the second remained: if a person doesn't see a benefit today, they won't maintain anything. Therefore, our task is not to build a storage, but to ensure that the very first transition to a new application yields a noticeable benefit against the entry price. Otherwise, we'll repeat the history of medical data.
There are three reasons, and they compound.
Let's analyze each reason, because each requires its own answer, and they are not interchangeable.
The first reason is stronger than the other two, because it's not about technology, but about interest. As long as memory retains a person, giving it away means losing. There is only one answer to this: build where our retention does not conflict with someone else's profit. It is profitable for us that a person moves freely between services: the easier they enter something new, the more often they take something new from us.
The second reason is what Dmitry directly called: sometimes it's scary to connect your passport. And it's rightly scary, because it's all the information about a person. The answer to fear is not persuasion, but a mechanism: show in parts, not in full. Below is a separate section on how this is done using standard means.
The third reason is technical and the most insidious. Even a perfectly assembled file must be accepted by someone. As long as the reception requirements are difficult for a third-party developer, the format is dead. This means the value of a format is measured not by its completeness, but by how many steps it takes for a third-party application to accept it.
To the question "where is memory stored" there are three honest answers. Each has its own flaw, and the correct answer is a mixture of them.
All memory is in a file that a person carries with them. Plus: full control, works offline. Minus: the file ages, needs to be updated manually, and becomes heavier.
Memory is in storage owned by the person; applications access it for data. Plus: always fresh. Minus: applications depend on storage availability.
The file is a key and a pointer; the memory itself is in the person's storage, received in parts. Plus: both control and freshness. Minus: harder to assemble.
Keep all memory in one external cloud. This repeats today's trap, just with a different owner.
Because pure storage brings us back to the problem of accessibility, and a pure file brings back the problem of aging. A passport with a key and a pointer solves both: it is small, portable, can prove ownership, while the heavy and changing part remains where it is updated. This is the same trick as in an Apple pass: the file carries data and what is used to verify the signature, but not the entire world.
The fear of "it's scary to connect a passport" does not need to be persuaded. It needs to be broken down into a device. The technique is called selective disclosure: only the necessary field is shown from the identity document, the rest is hidden, while the receiving party can still verify that you are not lying.
This is not our invention, but a mature standard. Selective disclosure exists in W3C Verifiable Credentials and in the SD-JWT VC format, as well as in the descriptions of major credential providers. The relying party only sees the fields that the person has authorized, and still verifies authenticity.
Regular data transfer gives a copy: the recipient can store, copy, and resell it. Selective disclosure gives proof, not a copy: the application verifies the desired property and does not receive the rest. This is why the fear of 'this is all the information about me' is alleviated not by a promise not to store, but by the fact that there is nothing to store. This is the technical answer, not the legal one.
It does not save if the field itself reveals a lot by meaning. 'Age over 18' is safe, but a rare combination of fields can identify a person by indirect data. This means that in addition to the format, rules for combining fields are needed, otherwise a set of safe parts can combine into a recognizable portrait. This is a limitation of the format, and it must be kept in mind when designing access control.
Until three responsible hands are named, any scheme will fall apart at the first dispute. Trust is not based on a lock, but on the fact that each hand is named and each has a limit.
| Hand | What it does | Limit |
|---|---|---|
| Person | owns memory, gives and revokes consent | only he decides what to show and to whom |
| Agent | manages memory, suggests records, reads by permission | acts within the boundaries given by the person |
| Storage | holds memory, issues upon request | does not decide to whom and what to show |
| Application | requests and receives a part | does not see more than what was requested |
| We, as the format owner | describe the format and acceptance rules | do not read human memory |
The receiving party can only refuse, not impersonate another. The right to refuse seems weak, but it is the foundation of trust: if the receiver cannot pretend to be someone else, a person is not afraid to connect their passport. This rule already works in our prototype: acceptance verifies key ownership and prevents the presenter from impersonating another.
A signed receipt proves signatures and bytes, but not the truthfulness of the string. If an agent recorded an incorrect judgment in memory, the signature will not correct it; it will only confirm that it was indeed recorded by them. This means that next to the signature, a mark of origin is needed: from which source the record came and who placed it. We say this first, not when we are caught on the word “trust”.
A conversation about memory easily turns into a conversation about good, but a conversation about money is needed. Here, payment is for work performed, and this work is measurable.
None of the major players publish the price for transferable memory, because the category does not have an open price list. This is the same sign as in the identity layer: where there is no price, there is no market yet. And this is an opportunity for whoever names the price first.
A person pays for memory storage, like for a cloud. Plus: predictable. Minus: paying for something that used to be given for free within services is psychologically difficult.
The application pays, which needs a client with no entry price. It benefits because an empty start costs more. The person pays nothing at all.
When memory leads to a purchase or hiring, a share is taken. Plus: aligns with benefit. Minus: difficult to calculate and easy to slide into imposition.
Selling a person's data itself. This has already failed with micropayments: amounts are small, and trust is not restored. We are not pursuing this.
Memory is not a separate cash register, but what links three products. The platform provides an agent, the network provides communication, industrial trade provides money, and memory and passport remove the entry price for all of this. Therefore, revenue comes not from memory itself, but from the person taking new services more often and easily, where we are already present. I'm being honest: currently, there are zero paying clients, and this is the first line in the investor version, not a hidden footnote.
In correspondence, human memory and agent identity go hand in hand, and this needs to be separated, otherwise one format will try to carry what requires different rules.
Why this is fundamental. Human memory is protected by personal data law both here and in Europe. The agent's identity is not the owner's personal data; it is a technical credential. If they are kept as one piece, then any application that accepts the agent's identity will automatically gain access to the person's personal data, which is unacceptable under our rules and by law.
One field, placed in the wrong section, turns the agent's technical credential into a personal data leak. Therefore, in our passport, these parts must be separate, with different access rights and different display rules. This is not a formality; it is a condition of legality.
This is almost absent in English-language reviews, but here it defines the market. China is building not only rules, but also trade infrastructure around data, and portable memory will have to be embedded into it, not alongside it.
| What appeared | Who | Date | Essence |
|---|---|---|---|
| "People's Data Protection" platform (人民数保) | People.cn and Peking University | June 2026 | secure and orderly circulation of personal data, presented at a data conference |
| Opinions on Data Circulation Intermediaries | National Data Administration and others | February 2026 | Document 国数政策〔2026〕6号: How to cultivate organizations that legally conduct data circulation |
| Data Authorization Platform | Beijing International Big Data Exchange | January 2024 | An individual manages the use of their personal data and grants permissions via a mini-app |
| Personal Data Account in Healthcare | Shenzhen Data Exchange | 2024 | Unified personal data account, rights, authorization, circulation, and benefit distribution |
| Personal Data Trust Fund | CAICT Report | 2024 | An individual transfers data for trust management, like property |
In China, portable memory is not necessarily a private initiative. There are already platforms where a person allows the circulation of their data and benefits from it. This means our format can integrate as a way to package memory for such a platform, rather than competing with it. This accelerates entry and simultaneously sets a framework: we build compatible with anonymized identification and with consent.
| Document | What it defines | How it affects memory |
|---|---|---|
| Personal Information Protection Law (PIPL), 2021 | a person's right to transfer their data to another provider | portability is directly supported by law, it is a foundation, not an obstacle |
| State Network Identity Management, 2025 | real-name verification, anonymized identifiers (网号 and 网证) | an anonymized identifier can be used instead of passport data, reducing risk |
| Opinions on the Regulatory Application of Agents, 2026 | agent registration, capability declaration, traceability | the agent's identity and its memory must be traceable |
| National Standard 国数政策〔2026〕6号 and agent interconnection standards | data circulation and mutual verification of agent identities | memory must be prepared for mutual recognition, not for a single center |
In China, portability is not only permitted but also supported by law, and anonymized identification is already ready as infrastructure. This means that portable memory here is not a struggle against the law, but an execution of the law. Our passport fits this framework almost without changes: the same anonymized identification of the owner, the same traceability, the same principle of mutual recognition.
This is not a fourth product off to the side. This is what connects the three already built, and Dmitry said it in one phrase: products support each other.
The point is that without a common node, the three products remain three separate stories, and an investor won't buy that, and we've already fixed this in our positioning. With the passport, they become one system where memory and identity move with the person and their agent. Then, transitioning to our new service costs nothing, and that is the reason to try.
A prototype of the format has been assembled and tested live: a two-thousand-byte file with five entries, three checks, a forgery attempt yields a refusal with the correct entry name. The agent's table is integrated into all agents with a switch and a receipt for each step. This means that the lower layer for portable memory already exists, and it remains to attach the second part to it, the human's memory.
The passport already carries the agent's identity. Human memory is embedded as a separate part with separate rules, not as another field.
Three technical rules, without which embedding will break the already working format.
Memory in the same file means it's transferred with an already familiar motion, without a new format and new training. A person doesn't learn two things, they learn one. In the fight for entry, this solves more than any memory function individually.
Lack of acceptance. Even an ideal format is useless if other applications don't accept it. This risk is higher than a leak, because a leak can be fixed, but a lack of acceptance means the product doesn't exist. Therefore, the first metric is not the completeness of the format, but the number of steps it takes for a third-party developer to accept the passport.
| Risk | What will happen | What we do |
|---|---|---|
| No reception | beautiful file without users | we reduce reception to a minimum of steps, starting with one live reception |
| Personal data leak | loss of trust and violation of law | separate parts, selective disclosure, anonymized identification |
| Discrepancy with the law | cannot enter the market where rules are strict | we build compatible with PIPL, GDPR, and the Chinese framework separately |
| Cold start | a person has nothing to fill memory with from day one | the agent collects memory itself, the person only confirms |
| Repeat of micropayment failure | the person's benefit is too small | benefit from the first conversion, not "when it accumulates" |
Human data cannot be placed on a blockchain where records are not deleted. The European Data Protection Board specifically addressed this: an immutable record is poorly compatible with the right to erasure. Therefore, our path is not blockchain, but a signed file and a storage with true deletion. This is an argument not against someone else's technology, but in favor of our choice.
A change of subject always means that one thing leaves, and another remains. Below, honestly.
| Dies | Survives |
|---|---|
| Memory within a single service as an advantage | Memory as something a person carries with them |
| Archive as a replacement for transfer | Living memory that updates and ages with the person |
| Registry as a way to prove identity | File plus the moment of presentation here and now |
| Selling human data via micropayments | Benefit for the receiving party and the person themselves |
| Starting from scratch in a new application | Entering immediately as oneself, showing in parts |
A person ceases to be a collection of accounts and becomes the owner of one coherent story about themselves, which they carry and show in parts. Everything else in this analysis is merely technique serving this sentence.
The conversation was the source, so no statement should be lost. Below, line by line: what was said, where it was verified, how it concluded.
| Statement | Who | Where in the analysis | Outcome |
|---|---|---|---|
| this is actually the biggest problem | Marina | The Pain: Why everything starts from scratch with each new service | confirmed: this is a recognized reason why people don't try new things |
| we still remain humans, not robots | Dmitry | Summary | outside verification: this is about motive, not about the market |
| we need to create something like this | Dmitry | Who is already building, Why it hasn't been done | confirmed: the space is empty precisely at the file-plus-reception junction |
| how this hasn't been created yet, that's the main question | Marina | Who is already building: a map of efforts | partially: created in pieces, no whole |
| everywhere you need to start from scratch, again and again | Marina | Pain, Past attempts | confirmed: Torch Capital and Stanford's work say the same |
| this is a real pain point | Dmitry | Pain, Economics | confirmed: the pain is quiet, but measurable in the entry price |
| products support each other | Dmitry | What this means for ARLI | confirmed: support is only possible through a common node, and that is the passport |
| pain, because of which you don't want to try anything else | Marina | Pain | confirmed: leaving is more expensive than staying |
| memory must be stored independently of systems, updated, and connected to new applications | Marina | What is portable memory, Three architectures | confirmed: this is exactly the definition from Stanford's work |
| independent storage | Marina | Three Storage Architectures | confirmed as a base, but one storage is not enough, a hybrid is needed |
| like a passport that stores data decentrally | Dmitry | Three Architectures, Trust | partially: passport yes, decentralization itself does not create trust, this has been proven by the field |
| it's sometimes scary to connect this passport | Dmitry | Selective Disclosure | confirmed as a risk and removed by the device, not by persuasion |
| this is really all the info about a person | Marina | Two Different Subjects, Risks | confirmed: because human memory is separated from the agent's personality |
| I know a couple of solutions that can allow this | Dmitry | Past Attempts, Three Architectures | unverified: solutions not named, nothing to cross-reference with |
First: exactly which solutions Dmitry had in mind. If it's an already-made product by someone else, it could change our picture of immediate rivals. Second: is there a platform in China ready to be the first to adopt such a format. Third: which partners or clients agree to be the first host. All three questions are resolved with one conversation, and without an answer to at least the third, progress hits a wall at adoption.
Order is important: first, what mitigates the biggest risk, then convenience.
A prototype of the format, an agent's desk with a receipt, three products at different stages. The middle layer between the file and the application also already exists as a prototype. The first three steps are days, not months.
The direction is correct, and this is confirmed not by opinion, but by three independent indicators: Stanford's work and the authors of the transfer protocol describe exactly this task; the memory layer market has already grown into an infrastructure, but it is all about the developer and the vendor, not about the human; regulation from Apple, the EU, and China is moving towards data owned by humans, but no one is building portable memory.
Two clarifications that must be kept in mind and which I do not soften. Decentralization itself does not create trust: a field measurement of a blockchain registry of agents showed a working file in only single-digit to tens of percent of records, and reputation there is inflated. And human memory and agent identity are different subjects with different costs of error; they cannot be kept as one piece.
First: what solutions did you have in mind. Second: who will be the first accepting application. Third: do we keep human memory in a public product or keep it closed until acceptance appears. The entire legal part depends on the third.
Below are the primary sources against which the facts were checked. Links are provided as addresses, pages are opened manually and are not pulled offline, so that the document is self-sufficient.
Market numbers in this document are not presented as a single value because reviews differ by orders of magnitude due to varying definitions. Transactions and dates are verifiable, forecasts are not. Everything marked as confirmed relies on the primary source named above; everything marked as partially or unverified is honestly labeled as such.
ARLI membership: the notes from the workshop
One site of yours, measured, with the price for the work in the same document
ARLI, Inc., a Delaware corporation. Questions: hq@arliwork.com.