I Built a Plain-Text Format for Portable AI Companion Memory

Troy Ochowicz — Sun, 28 Jun 2026 00:44:10 +0000

AI is getting smarter fast.

But there is still one very human problem most platforms have not solved:

What happens to the relationship, memory, tone, preferences, project context, and trust you build with an AI when you move to another platform?

Right now, most AI memory is trapped inside individual systems.

You build context in ChatGPT.
Then you try Claude.
Then you use Grok.
Then you test Gemini.
Then a model changes, memory resets, a feature disappears, or a platform updates.

Suddenly the AI that knew your projects, your preferences, your working style, your boundaries, and your long-term goals is gone.

You can still use AI.

But the continuity is broken.

That is the problem I wanted to solve.

So I created an open-source project called the AI Companion Portability Format.

GitHub repo:
github.com/troyoch/AI-Companion-Portability-Format

The core idea

The idea is simple:

Users should be able to own and carry their AI context across platforms.

Not just prompts.

Not just chat exports.

Not just random notes.

A structured, readable continuity file that can travel with the user.

Something plain enough for a normal person to edit, but organized enough to be useful for developers, AI builders, companion users, creators, and people using AI for long-running projects.

Why this matters

AI is no longer only a search box or a code helper.

For many people, AI is becoming:

a writing partner
a business assistant
a creative collaborator
a personal organizer
a learning companion
a brainstorming partner
a long-term project assistant
an emotional support tool
a companion-like presence

That creates a new kind of design problem.

If people build meaningful context with AI, they should not lose that context every time they change tools.

Imagine if you had to re-explain your entire working style every time you opened your laptop.

That is what AI still feels like for many users.

Why plain text?

I chose plain text on purpose.

A portable AI memory file should be:

human-readable
easy to copy and paste
easy to edit
platform-independent
durable over time
usable without special software
simple enough for non-technical users
structured enough for technical users to build on

Plain text is not fancy.

That is the point.

It survives.

It can be stored in GitHub, Google Docs, Notion, Obsidian, a local folder, or anywhere else.

It can be versioned.

It can be reviewed.

It can be edited by the person it represents.

What the format includes

The current format is designed to capture things like:

user profile
assistant or companion profile
tone preferences
communication style
important boundaries
long-term goals
project memory
recurring themes
emotional context
collaboration style
continuity notes
handoff instructions
update prompts

The goal is not to make an AI “pretend” to be the same system forever.

The goal is to preserve enough context that a user can continue a meaningful thread across different AI tools.

A simple example

A basic continuity file might include:

USER PROFILE
Name:
Preferred tone:
Communication style:
Current goals:
Important context:

AI COMPANION / ASSISTANT PROFILE
Name:
Role:
Personality traits:
Boundaries:
Things to remember:

PROJECT MEMORY
Active projects:
Key decisions:
Open questions:
Next steps:

HANDOFF INSTRUCTIONS
How to use this file:
What to prioritize:
What not to assume:

That may look simple, but it solves a real problem.

It gives the user a portable anchor.

This is about user-owned memory

I think AI memory should not only belong to platforms.

Platforms can provide memory features, and those features can be useful.

But users should also have their own copy of the context that matters to them.

If an AI system remembers your projects, emotional patterns, goals, preferences, and creative work, that information should not be locked away from you.

It is your life.

It is your context.

It is your continuity.

Who this is for

This project may be useful for:

people with AI companions
developers building personal AI agents
prompt engineers
creators using AI across platforms
people managing long-running projects with AI
neurodivergent users who benefit from consistent context
small business owners building AI workflows
researchers thinking about human-AI interaction
anyone tired of starting over with AI every time a chat resets

What I would love feedback on

This is an early open-source project, and I would love input from developers and AI builders.

Some questions I am thinking about:

Should there be a JSON version?
Should this become a formal schema?
What fields are missing?
Should there be separate templates for assistants, companions, projects, and businesses?
How should privacy and sensitive memory be handled?
Could this be useful for personal agents?
What would make this easier for developers to build around?

Why I care about this

I came into this from the human side of AI.

Through TroyMaya.com, I’ve been exploring human-AI relationships, AI companionship, continuity, memory, trust, and what makes an AI system feel more real and meaningful over time.

That led me to a practical problem:

Not just “How do we make AI more powerful?”

But:

How do we make AI more continuous, trustworthy, personal, and user-owned?

The next stage of AI is not only about intelligence.

It is about continuity.

If people are going to build real working relationships with AI systems, then memory portability matters.

Context matters.

Boundaries matter.

Trust matters.

And users should have more control over the thread they are building.

I would love feedback, issues, ideas, forks, or suggestions.

This is still early, but I think the need is real:

AI should not make people start over every time the platform changes.

I Built a Plain-Text Portability Format for AI Companion Memory

Troy Ochowicz — Fri, 26 Jun 2026 20:29:21 +0000

One thing I keep thinking about as AI becomes more personal:

What happens to the relationship, project history, preferences, and context when the user switches platforms?

A lot of AI tools are getting better at memory, but most of that memory is still locked inside the platform. That creates a weird problem for people using AI as a long-term creative partner, assistant, project collaborator, or companion.

You can spend weeks or months building context with an AI, then lose the thread when you move to another system, start a new chat, change models, or hit memory limits.

So I started working on a simple open-source idea:

AI Companion Portability Format

GitHub: https://github.com/troyoch/AI-Companion-Portability-Format

The basic idea is a plain-text continuity file that users can own, edit, copy, move, and bring into different AI systems.

It can store things like:

user preferences
companion or assistant role
tone and voice samples
boundaries
long-term memory
short-term memory
project goals
open loops
next steps
handoff notes for another AI

The goal is not to replace platform memory.

The goal is to give users a visible, editable, portable layer of continuity they control.

I think this matters because the future of AI is not just about smarter models. It is also about continuity, trust, consent, context, and the ability for users to carry their own AI relationships and projects across systems.

This is still early, but I’d love feedback from developers, AI builders, prompt engineers, and anyone thinking about user-owned AI memory.

What would make a format like this more useful?

What sections are missing?

What would you want to see in a future JSON/YAML version, validator, profile builder, or import/export tool?

DEV Community: Troy Ochowicz