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.