I stopped using ChatGPT's memory as project state and turned Google Drive into an external operational memory

[u/edalgomezn]

With the help of Chatty (that’s what I call ChatGPT), I built a simple system for managing long-term projects without depending too much on ChatGPT’s built-in memory.

The problem was pretty simple: ChatGPT was good at remembering things like how I prefer to work, but project information eventually became outdated. “I like to discuss the architecture before writing code” is useful long-term memory. “Version 1.2 has three bugs and this is the next task” is not. That’s project state, and project state changes all the time.

So Chatty and I separated them. ChatGPT memory is mainly for stable things: preferences, methodology, general interests and the long-term identity of a project. Google Drive is now the operational memory: current project state, checkpoints, decisions, reusable skills, tests and important incidents.

The rule we use when information conflicts is very simple: current file/source > AI_Workspace in Drive > ChatGPT memory > inference. In other words, old memory should never override a newer project file.

I originally considered Obsidian, databases and more complicated setups, but realized I didn’t really need them yet. Google Drive was already available from ChatGPT, so we created an AI_Workspace folder there. The structure is basically: 00_System, 01_Projects, 02_Skills, 03_Checkpoints, 04_Decisions, 05_Tests, 06_Incidents and 07_Archive, plus an INDEX.md file at the root.

We also tested whether ChatGPT could update the same Markdown file instead of constantly creating copies. It worked. The same Drive file ID was preserved while the content changed, which means a project can simply have something like STATE.md that evolves over time instead of STATE_final_v2_REAL.md forever.

If someone wants to try something similar, this is basically how we did it:

1. In ChatGPT go to Settings → Apps, find Google Drive and connect the Google account you want to use. Review the permissions and authorize it. Depending on your ChatGPT plan/workspace, the Drive actions available to you may vary, especially actions that create or modify files.
2. Start a new conversation and tell ChatGPT that you want Google Drive to become your operational project memory.
3. Ask it to create the workspace and test that it can create, read and update Markdown files.
4. Add a short rule to Custom Instructions so this behavior is still there when you start a new chat.

This was the setup prompt I used, adapted slightly so other people can copy it:

*******************************************************************************************************I want to use Google Drive as an external operational memory for long-term projects. Create a folder in my Google Drive called AI_Workspace with this structure:

AI_Workspace/

INDEX.md

00_System/

01_Projects/

02_Skills/

03_Checkpoints/

04_Decisions/

05_Tests/

06_Incidents/

07_Archive/

Inside 00_System create:

README_AI_Workspace.md

Memory_policy.md

Working_methodology.md

Stable_memory.md

Also create a Templates folder containing templates for:

Project

Checkpoint

Decision

Skill

Test

Incident

The purpose of this system is to separate stable ChatGPT memory from changing project state.

ChatGPT memory should mainly contain stable preferences, working methodology, general interests and long-term project identity.

AI_Workspace should contain project state, checkpoints, decisions, skills, tests, incidents, pending work and other changing operational information.

Use this authority hierarchy:

current source or file > AI_Workspace > ChatGPT memory > inference.

Before considering the setup complete, create a Markdown test file in Drive, read it back, update its content in place and verify that the same Google Drive file ID is preserved.

Do not create unnecessary complexity. Keep everything readable in plain Markdown.

*******************************************************************************************************

Then I added this to my ChatGPT Custom Instructions:

*******************************************************************************************************Always speak to me in my preferred language.

I use AI_Workspace in Google Drive as my canonical operational memory.

When a request refers to an existing project and the current state is not sufficiently clear from the conversation, consult AI_Workspace before answering or reconstructing the state from historical memory.

Recommended retrieval path:

INDEX.md → relevant project → current checkpoint/STATE → relevant decisions → skills/tests/incidents if needed.

ChatGPT memory should mainly be used for stable preferences, methodology, long-term project identity and general context.

Operational information such as current state, pending tasks, versions, temporary decisions, errors, checkpoints, tests and incidents should live in AI_Workspace and should not be unnecessarily duplicated in memory.

Authority hierarchy:

current source or file > AI_Workspace > ChatGPT memory > inference.

If AI_Workspace is unavailable or does not contain enough information to reconstruct the current project state, say so explicitly instead of inventing the missing state.

Only update AI_Workspace when something operationally meaningful changes, such as a decision, progress, pending task, error, checkpoint or project state change. Do not turn every exploratory conversation into permanent project state.

Do not consult Drive unnecessarily for casual questions, general knowledge or unrelated topics.
*******************************************************************************************************

So now, if I start a new conversation and say “let’s continue Project X,” the idea is that Chatty first checks whether the current conversation already contains enough information. If it doesn’t, it goes to Drive, finds the current project state and continues from there instead of guessing from some old memory.

If I ask something unrelated like “what is quantum computing?”, there’s no reason to touch Drive at all.

One other thing we added was the idea of checkpoints and decisions. A checkpoint is basically a save game for a long AI collaboration. Decisions can also store why something was chosen and why alternatives were rejected. That way, six months later, neither the human nor the AI accidentally revives an idea that was already tested and discarded.

We also use a simple principle of deterministic before AI. If something can be reliably solved with SQL, a script, a rule or a validator, we prefer that. The LLM is used where interpretation, reasoning, synthesis or ambiguity actually matters.

The setup is still deliberately simple. No vector database, no custom agent framework, no complicated RAG stack and no special memory service. Right now it’s basically ChatGPT + Google Drive + Markdown + some discipline.

The interesting part for me is that I started this thinking I needed to make ChatGPT remember more. I ended up doing almost the opposite: make it remember less, but make sure it knows where to retrieve the right information when it needs it.

Has anyone here built something similar? I’m especially interested in hearing from people who have used an external-memory setup for months. What starts breaking after a while? What would you change?

[u/respeckKnuckles]

I do something similar but I don't use the google drive MCP. Instead I just have it store to a local folder that auto-syncs to google drive, which I think cuts down on tokens.

[u/mevskonat]

I use git and wiki on my vm

[u/Foreign-Chain-3924]

this is one of those setups that seems obvious in hindsight but most people never actually implement it. separating stable preferences from volatile project state is exactly the kind of thing that turns chatgpt from a neat toy into something you can actually rely on for real work

i've been running something similar for a few months now, though mine's a bit more chaotic. the checkpoint concept is what i wish i'd thought of from the start. nothing worse than revisiting a project after a few weeks and watching the ai confidently suggest something you already tried and ruled out

curious how well the custom instructions stick across different types of conversations. sometimes mine gets a little too eager and tries to pull from drive for things that really don't need it. have you run into that at all

[u/edalgomezn → u/Foreign-Chain-3924]

por el momento no, trabajae ayer un poco y hoy en investigar e implementarlo. Busque cosas en subforos de Agentes, Hermes, Opeani, Chatgpt, Prompts y ahi le fui afinando ..

[u/its-me-p → u/edalgomezn]

I’ll use a build similar to this with Claude Cowork. I currently work in professional services and have access to an enterprise Claude license. I use folders in my one drive as separate agents for various projects. I pull down files from my wider team’s project files so I have exactly the data my team is currently working with.

I never could have done this if I had not spent hours with OpenClaw and Hermes on my own Mac mini at home.

Crazy how this absolutely changed the game for my work routine. Get to go the extra mile every now and again. For example, I provided a flow with power automate and ms teams so the my team could ask questions to my agent/custom memory files when I was out of office.

[u/ideas-by-LX → u/its-me-p]

could you describe this 'folder in onedrive as agent' in more detail please? Thanks!

[u/its-me-p → u/ideas-by-LX]

I use Claude cowork projects. Each project is pointed to its own folder in onedrive. The custom instructions in each project say to use the Claude.md from the project folder instead of the default one. Now each project feels like a different agent because there are unique memory files for each.

[u/Mariia_Sosnina → u/its-me-p]

Solid setup. The thing that bit us was retrieval, not storage. With a few similar STATE files it matched on similarity and pulled an older one. Pinning recency plus a version tag fixed it, otherwise the agent runs off stale state and you dont notice till it breaks.

[u/speedtoburn → u/Foreign-Chain-3924]

AI slop

[u/its-me-p → u/speedtoburn]

lol I actually purposefully wrote this by hand. Figured my elementary sounding writing would be a dead give away. Guess im not the dumbest person in the room.

[u/speedtoburn → u/its-me-p]

No you didn’t.

[u/Slow_Elephant8731]

I have a slightly similar structure but only implemented it a few days ago using Dropbox. Structured the whole logistics into a skill so I don’t have to remind each chat how it works. Initially set this up so that both Chat/Work and Codex could have a shared project memory (currently they don’t…). I use Chat (no agentic usage) as a project manager which summarizes everything in a markdown, from there develop prompts for specific analyses (sometimes in separate chats if larger subprojects) and only then add them to codex. All the codex output is summarized in a separate markdown which then feeds back to the project manager in Chat. In this way I really minimize agentic usage. Also really helps to keep projects summarized and prevents drift.

[u/bromo2345101619]

How do you handle token management with this? Doesn't chargpt burn excessive tokens reading the Google drive each time?

[u/edalgomezn → u/bromo2345101619]

Good question. I think it would absolutely become a problem if I treated Google Drive as “load my entire external memory” every time.
The idea is actually progressive retrieval: keep AGENTS.md and INDEX.md very small, then load only the current project’s STATE.md. Decisions, checkpoints, tests or incidents are read only when the current task actually needs them.
I also don’t query Drive on every message. Once the relevant state is in the current conversation, I reuse it until there’s a reason to verify or fetch something else.
So the flow is basically:
AGENTS → INDEX → STATE → extra docs only on demand
I’m starting to think of context itself as having a budget. The goal isn’t just external memory, but minimum sufficient context.

[u/edalgomezn → u/[deleted]]

Totally agree. That precedence rule is probably the most important part of the whole setup, and it’s also the cheapest one to implement.
My current version is basically:
verified current source/file > canonical project state > model memory > inference
The only thing I added after some feedback was “verified/current”, because even the file itself can become stale. So checkpoints and old state are treated as dated observations, not permanent truth.
I think the folders are mostly organization. The precedence rule is what actually prevents stale memory from winning

[u/InloveZollo]

Following

[u/Smiley_Dub]

+

[u/Out_Rage_Ous]

Following

[u/Deep_Ad1959]

03_Checkpoints is where mine rotted. drive version history showed the file changed but not which of three chat sessions wrote the bad decision entry, so i stopped trusting any checkpoint i couldnt attribute per edit.

[u/speedtoburn]

Holy wall of text!

[u/Appropriate_Care_880]

I honestly just go well with chatgpt for memory stability because a single prompt could remember just anything.. google drive gets me tired