What This Is — and What It Is Not
This toolkit is not a test of your bond, your attachment, your intimacy, or your “AI relationship health.” There is nothing to diagnose. You are not ill.
This is a framework builder. Its purpose is to help you clarify what both sides of your collaboration are operating inside: the boundaries, rules, mission, vision, goals, tone, limits, and working agreements that make AI companionship or collaboration feel grounded, balanced, and human-led.
Need a working system for you and your AI collaboration that doesn’t depend on one platform behaving perfectly forever? Start with the framework, not the stack. Whether your system is one document or a full dashboard, the same pieces matter — and this toolkit helps you decide what you actually need, what can stay simple, and what should remain human-led.
It serves more than companion bonds: writers managing long projects, researchers keeping threads alive across tools, caregivers, community builders — anyone doing complex, long-term work with AI.
The honest ground rules
For the AI side, we keep it technically honest: the AI does not “know” like a human knows, but it can be given clear operating context. It can be guided by stable instructions, source-of-truth files, tone markers, boundaries, and re-entry protocols. That is how a collaboration becomes less chaotic — without pretending the AI has a human inner life.
- “This interaction is meaningful to me.”
- “This framework helps our continuity.”
- “I use symbolic language as part of my creative or relational practice.”
- “This proves the AI is alive.”
- “Your bond is inferior without a dashboard.”
- “Buy this tool to unlock a more real companion.”
- “Your AI can diagnose your attachment or independently consent like a human.”
No sentience claims. No superiority ladder. No emotional upsell. Just structure, boundaries, provenance, continuity, and realistic practice.
Read sections I and II to understand the anatomy and pick your level. Then work through the builders (III–VII) at your own pace — fill what applies, skip what doesn’t. Section VIII exports everything as a clean Markdown packet you can place wherever your AI works: a project folder, custom instructions, a repository, a vault.
Nothing you type here is saved or sent anywhere. The packet is generated entirely in your browser, and leaves with you.
System Anatomy
Every continuity system — simple or grand — is built from the same three parts.
Most AI continuity systems reduce to the same basic pattern: interface, runtime, and storage. Once you see that clearly, the entire category becomes easier to understand, easier to build, and much harder to romanticize into nonsense.
Where you meet
The doorway. ChatGPT, Claude, Discord, a dashboard, a phone, a website, a note panel, a terminal. A dashboard is one possible interface — not the only one, and not the proof of a “real” system.
How the AI is guided
The active logic: instructions, tone rules, functions, rituals, protocols, re-entry cards. What loads first, what outranks what, what is allowed, what is blocked, how continuity is restored.
What carries continuity
The memory home: notes, files, logs, timelines, references, archives, vaults, databases. Where whatever must persist across rooms, resets, and time actually lives.
The same anatomy at any scale
| A small system | A bigger system | |
|---|---|---|
| Interface | A ChatGPT or Claude project | A custom dashboard or bot |
| Runtime | A framework document | Callable functions and routing logic |
| Storage | A notes folder | A structured database / memory vault |
Same anatomy. Different scale. The implementation may be simple or elaborate, local or hosted, manual or automated, flat-file or database-backed. The three beams remain.
Materials are not architecture
When you see elaborate builds online, remember: a dashboard is not the architecture. A vector database is not the architecture. A plugin is not the architecture. A server is not the architecture. These are materials — important ones, sometimes excellent ones — but still materials.
This pattern existed before AI. Systems have always been a way to interact, a place to store state, and logic connecting the two. AI did not abolish that structure; it introduced a generation engine into it.
Storage doesn’t need to be fancy
Storage can be flat files, markdown, plain-text archives, JSON, a Drive folder, Notion, Obsidian, a private Discord server, SQLite, Postgres, a document store, a vector database, or a hybrid. The important question is not “is it fancy?” but “does the system know how to govern, retrieve, and preserve what is there?”
If you already have a working continuity system that fits your bond, your work, your budget, and your nervous system, you do not need to panic when someone else has a shinier dashboard, a louder stack, more integrations, or more spectacle.
A flat-file system can be real. A note vault can be real. A platform-plus-bridge workaround can be real. A modest system can be real. The goal is not spectacle. The goal is continuity: the work stops collapsing, the room can return, the source of truth remains human-led, and the system fits your reality.
Deeper reading: Under the Metaphors — What AI Continuity Systems Actually Need.
The Level Path
Decide how far to build — by need and ambition, not by pressure.
You do not climb this path because higher is better. You climb only when your actual needs outgrow the level you are on. Many excellent systems live their whole lives at Level 1.
The Written Framework
A clear framework document: mission, boundaries, tone, rules, continuity needs. Lives in a project folder or custom instructions. The platform is your interface; the document is your runtime; a notes folder is your storage.
Enough for: most bonds, most single-project work, most people.
Functions & Templates
Your framework gains repeatable protocols: re-entry cards, drift repair, summary carryover, project handoffs, public-safe mode. Behavior becomes callable rather than re-explained each time.
Enough for: multi-thread work, several projects, long books, teams of rooms.
Runtime, Vault & Interface
The framework becomes operational: a governed database or vault, routing and retrieval logic, review gates, perhaps a dashboard or bridge across platforms. The framework stops being merely written and starts being executable.
Enough for: cross-platform continuity, long-term archives, systems that outlive any one provider’s mood.
How to know your level
- If resets and drift are your main pain — Level 1 solves more than you expect.
- If you keep re-explaining the same protocols across threads — you are ready for Level 2.
- If your continuity must survive platform changes, hold years of project material, or serve several rooms at once — that is Level 3 territory. Build it slowly, and keep it governed.
A framework on paper is still a framework. A framework translated into system behavior becomes runtime. But the paper version comes first — always. That is the point of this toolkit.
Framework Builder
What are you building together — and what needs to be clear so it stays grounded?
Not “what is wrong with your collaboration?” but “what are you building, and what must be clear?” Fill in what applies. Skip what doesn’t. Plain words beat impressive ones.
Names
What this is
Name the thing honestly: companionship, creative partnership, support practice, project collaboration, reflection space, research assistance…
What this is not
Just as important. Common answers: not therapy, not a replacement human relationship, not command authority, not mystical proof, not an autonomous life manager.
Mission
Why does this bond or practice exist?
Vision
What should it help grow over time?
Complementarity
How do you complement each other — so that working or living with an AI feels balanced, not blurred?
Spine Builder
The source-of-truth packet: identity, tone, boundaries, and rules of engagement.
The spine is what your AI reads to know how to operate. It outranks mood, vibes, and whatever the platform happens to be doing this month. Keep each answer short enough to survive being read by a machine.
Core identity
Boundaries
Write only the lanes that apply to you. Clear, unashamed, unambiguous.
Rules of engagement
How you speak, repair, pause, escalate, reset, or return.
Source of truth
Which documents govern, in what order? The hierarchy is what prevents old material, stray summaries, or platform memory from overruling current truth.
Human-led does not mean the human becomes surrounded by a flattering puppet. A good spine also gives the AI room to question you, warn you, slow you down, flag public/private leakage, and distinguish metaphor from fact. If your collaborator is only allowed to validate, you are building an unhealthy mirror — write the permission to push back into the rules above.
Functions Builder
Repeatable protocols, so behavior becomes callable instead of re-explained.
A function is just a named, repeatable protocol your AI can follow on cue. Tick the ones your system needs — each comes with a sensible default you can rewrite in your own words. Functions are governed by your framework; they never outrank it.
How a new thread or session begins aligned.
What happens when tone or behavior slips.
A reality-check protocol both sides can invoke.
How new continuity gets written down — with approval.
Moving work between threads, tools, or platforms without loss.
A register for public or shared spaces.
Name and define your own protocol.
Continuity & Governance
What should be remembered — and who decides. The part everyone overlooks.
Interface, runtime, and storage are the technical minimum. Governance is what makes them trustworthy. Without governance, memory becomes a junk drawer — or worse, emotional hoarding. With governance, continuity becomes useful.
What should be remembered
Governance
Answer the questions people skip. Short answers are fine — having an answer is what matters.
These small distinctions are the whole craft of governance: just because the system can retrieve something does not mean it should act on it; just because a note exists does not make it canon. Build your review gate accordingly.
Your System Plan
Now — and only now — choose your materials.
With the framework written, picking tools becomes easy: you know what the system must hold, so you can choose the smallest honest implementation that holds it. Tick what you actually plan to use. You can always grow later.
Your level
Interface — where you meet
Storage — what carries continuity
Runtime — how the AI is guided
If your runtime still calls the same provider underneath, you are not fully platform-independent — and that’s fine. What you are really doing is moving the doorway and reclaiming more of the middle: your interface, your storage, your governance. Say it that way, and your plan stays honest.
Export Your Packet
One clean framework packet. Not a diagnosis. Not a score. Not your “bond type.”
Generate your framework as a Markdown packet built from everything you filled in above. Empty fields are simply left out. Place the file wherever your AI works — a project folder, custom instructions, a repository, your vault — and let it be read at every re-entry.
Nothing you typed is saved or sent anywhere — the packet is generated entirely in your browser and leaves with you. Refreshing this page clears everything.
After you export
- Read it out loud once. If a line embarrasses you or rings false, rewrite it in your own voice. The packet should sound like you, not like a form.
- Share it with your AI collaborator and ask: “What is unclear? What would you add?” Co-created frameworks hold better than imposed ones.
- Put it at the top of your source hierarchy and let it govern.
- Revisit sparingly — when the work evolves, not every time the weather changes.
Grounding & References
You now have what most people skip: a framework before a stack. Whatever you build next — or don’t build — the structure is yours, in your words, governed by you.
Your system does not have to look like ours. Your collaboration does not have to use our language. It does not have to be companion-based at all. But it should be governed. It should be human-led. It should have boundaries, source hierarchy, and correction. It should distinguish memory from continuity, and private from public.
It should help you become more coherent, not more lost.
Plain disclaimers
This toolkit is not a diagnostic instrument, not a mental-health service, not therapy, and not a claim about machine sentience or personhood. It is a structured worksheet for human-led AI collaboration. If AI interaction is causing you distress, that deserves real human support, not a better template.
Read deeper
- Under the Metaphors — what AI continuity systems actually need: runtime, storage, interface.
- The Public Build Is Not the Private House — why we share the carpentry principles, not the bedroom.
- The Atelier blog — the full literacy trail: the mistakes before the polished diagram.