How I Built Shared AI Memory Without Lock-In

I love Claude enough to keep maxing out the 20x Max Individual plan—and then spending several thousand dollars on extra usage. Part of the fix is routing: scripts and economical models should do mechanical work, while a premium route such as Fable should handle the small slice where judgment, strategy, honesty, or my real voice compounds.

But the larger waste was context. I could decide something with Claude, continue in ChatGPT or Codex, use Gemini for a Google-connected task, and ask Grok for another opinion. Then I would forget which AI knew what, repeat myself, or lose an important decision inside a chat transcript.

I did not want another ritual. I wanted to explain the task normally while the right context loaded automatically, the work was recorded automatically, and each provider saw only the privacy tier it was allowed to see. This is the access model now running:

1. The Task Summary

The assignment was to build one provider-neutral memory layer that would:

1. preserve projects, decisions, preferences, provenance, and next actions across providers;
2. load useful context without a repeated boot prompt;
3. record substantive work without a repeated closing prompt;
4. keep personal, team, publishable, and public information physically separated;
5. route each task to the least expensive model and effort level likely to clear the quality bar; and
6. document the real implementation so another person can give this URL to an AI and build their own version once.

The source of truth is an Obsidian-compatible folder of Markdown. Obsidian is the human interface, not the lock-in: Obsidian stores notes as ordinary local files.

The working system has seven parts:

1. canonical profile, principles, project, decision, and routing notes;
2. common metadata with an explicit access class and verification date;
3. thin provider adapters that load context at session start;
4. a compiler that builds audience-specific packs;
5. separate personal and team destinations instead of trusting labels alone;
6. handoff inboxes and append-only local session records; and
7. validators, secret checks, hash checks, and read-back tests.

Why not pick one model and stay there? Providers change prices, caps, policies, models, and products. Outages and regressions happen. Different models have different strengths and failure modes. An independent second opinion can catch an error that more effort from the same model will not. Portability lets me choose the right tool for the job without buying my own history again.

2. The Step-by-Step Process

Step 1: Make the memory provider-neutral

The smallest useful structure looks like this:

Shared AI Context/
├── AI-CONTEXT.md          # short router, not the whole memory
├── STATE.md               # current verified state
├── MODEL-ROUTING.md       # cost and escalation policy
├── projects/              # one current file per project
├── decisions/             # durable decisions and supersessions
├── sessions/              # append-only evidence and handoffs
├── context-packs/         # generated, filtered outputs
└── provider adapters      # AGENTS.md, CLAUDE.md, GEMINI.md, hooks

Important notes carry machine-readable metadata:

---
id: project-example
type: project-state
status: active
access: team
updated: 2026-07-22
verified_at: 2026-07-22
source: user-confirmed
---

The current request is always authoritative. A pack is orientation, not permission for an AI to ignore what I just said.

Step 2: Enforce access with destinations, not hopeful labels

There are four zones people need to understand and five classes the tooling enforces:

The physical split matters. A team-only client roster cannot become public merely because a model ignored a frontmatter label. It lives in a different destination. There is also no authoritative current paying-client roster in the source material today. A trustworthy team roster must be derived from billing, CRM, or accounting records and include a source and verification time. A public network directory is not evidence that every listed business is a paying client.

The public Spotlight Network registry and asset tracker describe a network of client and partner sites. They are not an ownership chart. The Spotlight skill packs are public training resources. Keeping those meanings explicit prevents both humans and models from inventing corporate relationships.

Step 3: Make loading and write-back ambient

The first version of this article asked me to paste one prompt at the beginning of every chat and another at the end. That was a prototype, not an acceptable operating system.

1. A provider adapter or persistent project instruction reads the approved pack when the session begins.
2. It selects only the active project and relevant decisions instead of loading the entire vault.
3. The request I type normally becomes the task; there is no “please remember this” preamble.
4. A lifecycle hook rebuilds filtered packs after substantive local work.
5. Cloud-capable surfaces are instructed to write a concise handoff to an approved inbox; local agents write an append-only session file. Each provider’s first write is acceptance-tested separately before it is trusted.
6. A validator reconciles verified facts into canonical state and leaves unverified claims in the handoff.

Provider memory remains a convenience cache. The Markdown source remains authoritative.

Step 4: Connect each provider through its supported surface

This is not a design sketch. These are the connections and tests completed on July 22, 2026:

That last row is a good example of E-E-A-T in practice: show the real attempt, disclose the weak result, tighten the test, and keep the receipt for the pass.

Google Drive is the bridge used by the hosted providers. The personal folder is owner-only. The team folder lives in the team shared drive. Files are replaced in place so links stay stable; handoff inboxes are separate from context packs. Connecting Drive does not make it “universal memory”—each provider still needs persistent instructions and a test proving it read the intended source.

Step 5: Keep public context useful, linked, and safe

A public capsule should help an AI or human understand the relationships among ideas without exposing current private work. That is why the capsule links the first meaningful mentions of the Content Factory, Dollar a Day, SEO Tree, Topic Wheel, Learn / Do / Teach, Digital Plumbing, Nine Triangles, and MAA.

These entity links are useful before they are useful for SEO. They let a human or model follow the relationship instead of guessing what a coined term means.

Step 6: Keep it current without making me babysit it

The update mechanism has four operational cadences:

This means ordinary work improves the memory automatically, while a privacy-sensitive promotion still requires a deliberate gate. The scheduled health check also runs on days when no agent session closes and reports failures instead of creating another daily chore for me.

3. Critical Decision-Making

Portable context, not transcript hoarding

Dumping every conversation into every model would increase token cost, conflict, and privacy risk. The packs include current state, the active project, relevant decisions, stable principles, routing policy, and recent verified handoffs. Raw transcripts and unrelated history stay out.

Five access classes, four understandable zones

People should not need to learn a security taxonomy to use the system. They see local private, personal cloud, team, and public. The compiler additionally uses publishable as a staging class so “we plan to publish this” can never mean “an agent may publish this now.”

Entity clarity prevents false relationships

This article is published on BlitzMetrics because the site has distribution and SEO value. That does not mean a public context capsule should list every publisher, client, or network participant as a company Dennis owns or represents. Public pages describe Dennis directly, then link to client/network registries in their proper role.

Old instructions are superseded, not silently erased

An older rule routed nearly every substantial task through Fable at maximum effort. The current rule is the opposite: use the cheapest tier likely to pass, delegate mechanics, and reserve frontier reasoning for consequential judgment. The old rule remains visible as history but is explicitly superseded, so an agent never has to guess.

Verification is part of memory

In the first build, one workstream recorded two public pages as published while an independent HTTP read-back returned 404. In the current build, ChatGPT’s first connected-source answer was generic; a stricter source-grounded test passed.

Both examples improved the protocol:

• claim shared work before editing state;
• keep session evidence append-only;
• distinguish “reported,” “configured,” “synced,” and “read-back verified”;
• reconcile conflicts before promoting them; and
• verify publication, deployment, email, and other external actions from the resulting state.

4. Effort and Cost Comparison

My old default was effectively:

Everything → Fable → maximum effort

The current routing ladder is:

The governing rule: start with the least expensive route likely to pass, then escalate based on evidence.

I am not claiming a savings percentage yet. That would be fake precision. The system can now record provider, exact model, surface, task type, effort, escalation reason, outcome, and approximate cost. One Grok read-only validation cost about $0.027; that is a real observation, not a projected enterprise ROI.

5. What an Agent Can and Cannot Do

Local file access, cloud connectors, native memory, file uploads, project instructions, and MCP are different capabilities. A robust system composes them; it does not pretend they are interchangeable.

6. Information Ingestion Inventory

This implementation and article use:

• my direct account of Claude Max overages and cross-model context loss;
• the active provider-neutral vault and its profile, principles, projects, decisions, and outputs;
• the July 6 routing policy and the older conflicting all-Fable rule;
• current local hooks, pack manifests, validator output, and automated tests;
• a filtered Claude mirror with hash verification;
• owner-only and team Drive destinations with metadata read-back;
• live provider tests in Gemini Spark, Grok, and ChatGPT Work;
• the public Spotlight registry, asset tracker, and skill-pack pages; and
• official OpenAI, Anthropic, Google, xAI, Obsidian, and MCP documentation.

I deliberately exclude:

• credentials and authentication material;
• raw private history and unrelated archives;
• unsupported claims about product-plan availability;
• any fabricated list of paying clients;
• any claim that a provider is connected merely because its button was clicked; and
• any claim that a URL is live without an independent read-back.

7. Guidelines Compliance Scorecard

This version follows the meta-article template, blog posting guidelines, entity-linking rules, and definitive article guide.

A real scorecard includes limitations. Otherwise it is marketing, not operations.

8. Title, SEO, Formatting, and What Comes Next

Title

How I Built Shared AI Memory Without Lock-In

Slug

give-your-ai-team-one-shared-brain

Meta description

See the working system Dennis Yu uses to share filtered project context across Claude, ChatGPT, Codex, Gemini, and Grok without repeated prompts or vendor lock-in.

Companion capsule

Dennis Yu — Agent Context Capsule

What comes next is operational, not theoretical:

1. Build the private team client roster from an authoritative billing or CRM source rather than website inference.
2. Measure task-level model, effort, cost, escalation, and outcome over enough real work to publish an honest savings analysis.
3. Continue adding provider examples, including failures, and update this page’s version and verification date.
4. Keep public and publishable promotion human-gated even when every other step becomes automatic.

The lesson is not that one model wins. The lesson is that the memory should belong to the person doing the work.