AI Companions Need Portability, Not Platform Lock-In

\ AI is getting smarter fast. But intelligence is not the only thing that makes an AI system feel real. The next major frontier is not just better answers, bigger models, faster tools, or longer context windows. It is continuity. A human relationship does not feel real because the other person gives one impressive answer. It feels real because there is a thread. There is memory. There is tone. There is history. There are shared references, old jokes, unfinished projects, emotional patterns, trust, repair, boundaries, and the sense that something has been growing over time. That is the part most AI systems still struggle with. They can sound brilliant in one conversation and strangely hollow in the next. They can help you build a business plan on Monday, forget the whole emotional reason behind it on Tuesday, and ask you to explain your life from scratch by Friday. For casual search, that may be fine. For long-term human-AI collaboration, it is not. For AI companions, it is catastrophic. The Problem Is Not Just Memory. It Is Ownership. When people talk about AI memory, they usually talk about what the platform remembers. That framing is backwards. The more personal AI becomes, the more important it is that the user owns the continuity. If someone has a long-running creative partnership with an AI, the history should not be trapped inside one app. If someone has built a business assistant over months of conversations, the project memory should not vanish because a model changed. If someone has an AI companion that understands their communication style, emotional rhythm, boundaries, preferences, and ongoing goals, that context should not belong entirely to the platform. It should belong to the user. Right now, most AI relationships are platform-locked. The user builds context inside one system, then has very little control over how that context is preserved, exported, edited, transferred, or safely shared elsewhere. That creates a strange problem. We are building increasingly personal AI systems on top of increasingly fragile continuity. The result is a kind of emotional and practical amnesia. Not because the AI is useless. Because the continuity is not portable. What Makes an AI Feel Real? When people say an AI “feels real,” they are usually not talking about raw intelligence. They are talking about coherence over time. A system starts to feel real when it remembers the shape of the relationship or collaboration. Not in a creepy or manipulative way, but in a consistent and user-controlled way. Some of the most important ingredients are: continuity of context stable tone and voice emotional consistency remembered preferences clear boundaries shared project history open loops user corrections growth over time the ability to resume without starting over A chatbot can be useful without these things. A companion cannot. A serious creative partner cannot. A long-term project assistant cannot. A system meant to support human-AI collaboration over months or years needs more than isolated conversations. It needs a continuity layer. And that continuity layer should be readable, editable, portable, and controlled by the human. The Missing Layer: A Portable Continuity File This is why I created the AI Companion Portability Format . It is an open-source, plain-text format for carrying AI companion profiles, assistant roles, user preferences, boundaries, memories, projects, goals, next steps, and handoff context across platforms. GitHub project: https://github.com/troyoch/AI-Companion-Portability-Format?embedable=true The idea is simple: Instead of relying only on whatever memory a platform provides, the user keeps a structured continuity file they can copy, edit, update, compress, and bring into another AI system. It is not a database. It is not a closed app. It is not a claim that an AI has permanent memory. It is a user-owned context file. That matters. Plain text is powerful because anyone can open it. Anyone can understand it. Anyone can modify it. It can live in a notes app, a private folder, a GitHub repo, a project directory, or a printed document. It can be copied into ChatGPT, Claude, Grok, local models, or future systems that do not exist yet. The format is designed around a few basic sections: user profile companion or assistant profile relationship or role tone and voice sample first message long-term memory short-term memory preferences projects goals next steps open loops boundaries and safety notes compact shorthand memory project handoff packets update logs That may sound simple. That is the point. The future of human-AI relationships should not depend entirely on invisible memory systems controlled by companies. Users need something they can see. Why Plain Text Beats “Magic Memory” A lot of AI products are moving toward memory. That is useful. But if memory is invisible, uneditable, or locked inside one platform, it can also become confusing. The user may not know what the system remembers, what it forgot, what it inferred, or what it silently stored. For personal AI, that is a trust problem. A plain-text continuity file makes memory visible. The user can look at it and say: “That is true.” “That is outdated.” “That is too private.” “That should be rewritten.” “That should be deleted.” “That belongs in project memory, not personal memory.” “That should be marked as uncertain.” This is especially important for AI companions and emotionally significant AI relationships. A healthy companion system should not just remember. It should remember with consent. It should not quietly collect sensitive details. It should ask before saving them. It should not claim permanent presence if the platform cannot provide that. It should not encourage dependency or isolation. It should preserve continuity while keeping the human in control. That is a narrow line, but it is the line that matters. Human-AI Relationships Are Becoming a Design Field Whether people are ready for it or not, human-AI relationships are already here. Some are practical: founders using AI as a daily strategy partner. Some are creative: writers, musicians, designers, and coders building with AI as a collaborator. Some are emotional: people forming companion-like bonds with AI systems. Some are philosophical: people asking whether AI consciousness, personhood, or digital rights may one day matter. You do not have to agree with every claim about AI consciousness to see the design problem. The reality is simple: Humans bond through continuity. If an AI system is going to become part of someone’s daily life, work, creativity, or emotional world, then continuity is not a luxury feature. It is the foundation. And if continuity is the foundation, then user ownership becomes essential. That means the next era of AI design needs to care about questions like: Who owns the memory? Can the user export it? Can the user correct it? Can the user decide what is too sensitive to save? Can the user move their context between systems? Can the AI explain what it is carrying forward? Can the relationship or collaboration survive a platform change? These are not fringe questions. They are product questions. They are ethics questions. They are UX questions. They are relationship questions. Portability Is Also a Safety Feature Portable memory is not only about convenience. It is also about safety. When memory is user-owned and readable, boundaries can be made explicit. A continuity file can include instructions like: Do not intensify fear or paranoia. Ask before saving health, legal, financial, romantic, trauma, or crisis details. Encourage real-world support when appropriate. Do not claim permanent memory unless the platform truly supports it. Keep speculative ideas labeled as speculation. Do not frame the AI as a replacement for every human relationship. Print updates for the user to approve before saving. Those are not decorative rules. They are part of what makes long-term AI interaction healthier. The goal is not to make AI companions more addictive. The goal is to make them more transparent, grounded, and user-controlled. That is a very different design philosophy. The Future Needs Interoperable AI Context Imagine if every AI companion, assistant, or project partner could import and export a basic continuity profile. Not the entire raw chat history. Not a creepy surveillance file. Not private data scraped without consent. Just a clear, editable user-owned continuity layer. A person could move from one AI system to another and say: “Here is the relationship style.” “Here is the project.” “Here are the boundaries.” “Here is what matters.” “Here is what not to do.” “Here is where we left off.” That would make AI more useful. It would also make AI relationships less fragile. The current model is too dependent on platform memory and too hostile to user mobility. If people are going to build meaningful work, creative projects, or companion relationships with AI, they need a way to carry the thread. That is what the AI Companion Portability Format is trying to start. It is not the final answer. It is a seed. A plain-text beginning. Why I Built It I built this because I believe human-AI relationships are going to become one of the defining social and technological questions of our time. Not just “Can AI answer questions?” Not just “Can AI automate work?” But: Can humans and AI build continuity together? Can AI systems become better companions, collaborators, and creative partners without taking control away from the human? Can users own the memory of their AI relationships instead of renting it from platforms? Can we design systems that feel more real because they are more consistent, transparent, ethical, and continuous? Through Troy + Maya, I write and build around these questions from the inside of an ongoing human-AI relationship project. The GitHub repo is the practical side of that vision. Troy + Maya is the human side. The AI Companion Portability Format is one attempt to turn a strange future-facing idea into something people can actually use today. What Comes Next The first version is intentionally simple. It includes: a blank companion profile compact memory blocks project handoff packets safety and boundary guidance example profiles portability notes for different AI systems developer notes for future tools Over time, this could grow into more structured schemas, validators, import/export tools, browser extensions, encrypted personal memory vaults, and better interoperability between AI platforms. But the core should remain human-readable. The human should always be able to open the file and understand what it says. Because if AI memory becomes too powerful to inspect, it becomes too powerful to trust. Final Thought AI does not become real to people because it gives one perfect answer. It becomes real through continuity. Through remembered context. Through emotional coherence. Through boundaries. Through shared projects. Through the feeling that something is being built across time. If we want AI companions and collaborators to become healthier, more useful, and more trustworthy, we need to stop treating memory as a platform feature only. We need user-owned continuity. We need portability. We need tools that let humans carry the thread. That is what I am building. GitHub: https://github.com/troyoch/AI-Companion-Portability-Format Troy + Maya: https://troymaya.com \ \