I often work for several days inside the same ChatGPT conversation.

We talk, we rephrase, we abandon a few lines of enquiry, and then, somewhere in the middle of dozens of messages, an interesting paragraph finally shows up.

At that point, I would like to be able to just say:

Persist that.

And carry on working.

Then, five days later:

Give me back everything I persisted.

It sounds obvious.

But ChatGPT does not really work that way.

The chat is not ChatGPT's memory

This is probably the least well understood point.

The conversation shown in the interface can be complete. I can scroll back through the messages and find what we said to each other three days ago.

But that does not mean ChatGPT has all those messages word for word when it replies.

Three things need to be kept apart:

• the transcript kept and displayed in the interface;
• what the model can actually use to produce its answer;
• ChatGPT's memory, which does not keep every conversation word for word.

OpenAI explains that memory keeps certain useful elements and should not be treated as exhaustive storage of everything that has been said.

Official FAQ on ChatGPT memory

So the transcript is complete for me.

ChatGPT has not necessarily kept the passages I care about word for word.

And that is exactly what I need.

If I pick out three important paragraphs today, I want to come back five days later and get precisely those three paragraphs.

"Bookmark that" is not enough

I could write:

Bookmark this paragraph.

But that does not create a real, persistent bookmark.

A few days later, ChatGPT might find what I had picked out — or it might be unable to give it back to me word for word. That is not reliable enough for what I need.

I want to find again exactly the passages I decided to keep.

That need is what justifies external persistence.

I do not want to save the whole conversation

The point is certainly not to copy every message automatically.

A long conversation contains a lot of intermediate material:

• questions;
• attempts;
• rephrasings;
• dead ends;
• answers replaced ten minutes later.

I only want to get the few valuable pieces out of the flow.

For instance:

Persist our latest definition.

or:

Persist that.

The decision to keep something stays human.

First idea: an API

My first instinct was the conventional one.

Build a small PHP service able to receive text and append it to a Markdown file.

Something like:

ChatGPT
   ↓
API
   ↓
Markdown

So I built (or rather, Claude Code built) a small Remote Persistence Store.

The server could:

• create separate contexts;
• add content;
• give the Markdown back;
• report a few details about the state of a context.

Technically, it all worked.

The problem lay elsewhere.

With ChatGPT Plus, I cannot simply call my own API

On my $20-a-month ChatGPT Plus subscription, I cannot simply ask ChatGPT to call any external API I like.

ChatGPT can build an API URL itself, adding parameters to it. But in some cases, as soon as the URL has been modified or built by ChatGPT, the web tool then refuses to call it. So the problem is not building the URL — it is being allowed to run it.

I wanted to keep using ChatGPT normally, from my phone in particular.

So I had to find another route.

Second attempt: a bit of sleight of hand

ChatGPT can visit web pages.

So I tried to hide a write behind something that looked like an ordinary page visit.

Instead of sending:

POST /persist

I built a URL along these lines:

https://my-server.example/persist
?context=my-context
&content=my-text

To ChatGPT, the request simply looked like:

Visit this web page.

To my server:

Take the parameters and write them to disk.

So I was deliberately turning a write into a fake read.

It was not particularly elegant.

But for a personal prototype, it would have done the job perfectly well.

And on the server side, it worked.

• From a browser: no problem.
• With curl: no problem.

But the moment ChatGPT had to take content from our conversation, build that new URL on the fly and then visit the matching page, its browsing safeguards blocked the operation.

Which, in the end, is fair enough.

I was doing precisely what they guard against: getting content out of the conversation and onto my own server automatically, by dressing a write up as a web page visit.

Looking at what ChatGPT already knows how to do

So I changed the question.

Instead of asking:

How do I get ChatGPT to call my server?

I asked:

Where does ChatGPT already know how to write?

In my case: Google Sheets.

I created an extremely simple Sheet:

created_at | context | content

Then I tried:

Persist "AZERTY"

And a new row appeared:

2026-09-12T15:20:44+02:00 | Remote Persistence Store | AZERTY

This time, the text really had left the conversation.

It existed independently of ChatGPT.

Google Sheets as an outbox

This was not my ideal architecture.

What I originally wanted was:

ChatGPT → API → Markdown

What I now had was:

ChatGPT → Google Sheets

But Google Sheets does not have to be my final storage.

It can simply act as an outbox.

An out-tray where ChatGPT drops the pieces of information I have decided to keep.

Later on, I can do this:

ChatGPT
   ↓
Google Sheets
   ↓
script
   ↓
Markdown
   ↓
Obsidian / Git / another AI

The problem that mattered was solved: getting a specific piece of information out of the conversation.

First version: nearly 50 seconds

It worked, but it was painfully slow.

A simple command:

Persist "test"

could take nearly 50 seconds to write three cells.

The trouble was that ChatGPT rediscovered almost everything each time round.

• It searched for the file.
• It fetched its metadata.
• It checked the tab.
• It looked at the columns.
• It worked out where to write.

Only then did it add the data.

And none of that changed from one call to the next.

Stop searching for what you already know

So I put all the fixed details straight into the instruction:

• the Spreadsheet ID;
• the Sheet ID;
• the tab name;
• the three columns;
• what each of them means.

And above all:

Do not search for the file. Do not read its metadata. Do not read its headers again.

That still left the question of where to write.

My first answer was to insert every new entry at row 2.

It was fast, but the data then came out in reverse order: the most recent at the top.

Fortunately, Google Sheets offers an append mechanism.

No more hunting for the last row.

The process comes down to this:

Persist
   ↓
append
   ↓
check
   ↓
answer

In my tests, the Google calls needed to write the row and read it back now take one to two seconds in total.

ChatGPT's overall response time still varies, but we are a long way from the nearly 50 seconds of the first version.

So the problem was never really Google Sheets.

The problem was that the AI kept rediscovering a setup it already knew.

Checking after writing

I also did not want ChatGPT simply to show me:

Persisted.

without knowing what had actually been written.

So I added a rule.

After each write, ChatGPT must read back the entry it has just added.

For a short piece of text, it displays what it actually read back:

Persisted ✓

Context: Remote Persistence Store
Status: OK

Content:
AZERTY

For much longer content, it displays only a faithful summary of what it read back.

What matters is that the confirmation comes after the check.

intent
→ write
→ read back
→ check
→ confirmation

Making "Persist" available in all my chats

Obviously I did not want to paste this whole set of instructions at the start of every new conversation.

So I added it to ChatGPT's Custom instructions.

On the web:

Settings
→ Personalization
→ Custom instructions

You also have to connect Google Drive to ChatGPT so it can reach the Sheet.

Once both are set up, I can start a new conversation and write straight away:

Persist our latest definition.

The instruction then tells ChatGPT what the verb Persist means and where to send the content.

My "PERSIST" instruction

Here is an anonymised version.

You need to replace the three values between <...> with those of your own Google Sheet. You can ask ChatGPT to find them, or even to create the Google Sheet for you.

"PERSIST" INSTRUCTION

When I begin a request with "Persist", or when I explicitly ask for a piece of information to be persisted, add that information to the Google Sheet set up as the persistence store.

GOOGLE SHEET

Spreadsheet ID: <SPREADSHEET_ID>

Sheet: <SHEET_NAME>

Sheet ID: <SHEET_ID>

Fixed structure:

A = created_at
B = context
C = content

INTERPRETATION

- "Persist xxx" = persist xxx.
- "Persist our last exchange" = persist the relevant content of the last exchange.
- "Persist your last answer" = persist the last answer.
- "Persist this text" = persist the text explicitly referred to.
- "Persist in {context} xxx" = use {context} as the context.
- If no context is given, work out a short, relevant name from the current subject.
- Do not ask for confirmation if the request is clear.

WRITING

1. Set created_at from the current date and time.
2. Use the known Spreadsheet ID and Sheet directly.
3. Use a native Google Sheets append.
4. Add exactly:

   created_at | context | content

OPTIMISATION

On a "Persist" command:

- do not search for the file;
- do not read its metadata;
- do not read its headers again;
- do not search for the last row;
- do not analyse its structure before writing;
- use the known identifiers and structure directly.

Read only after writing.

CHECK

After the append:

1. Read back the added entry only.
2. Check the context and the content.
3. Confirm the persistence only after that check.

CONTENT

- Persist the requested content itself.
- Do not summarise it before storage.
- Do not rephrase or correct it unless explicitly asked.
- Keep its original structure as far as possible.

ANSWER

For short content:

Persisted ✓

Context: {context}
Status: OK

Content:
{content actually read back}

For long content:

Persisted ✓

Context: {context}
Status: OK

Summary of the content read back:
{faithful summary in a few lines}

The summary concerns the confirmation only.
The stored content remains complete.

On failure:

Persistence failed ✗

Context: {context}
Status: ERROR

Problem:
{short description of the error}

PRIORITY

direct append → targeted check → answer

Avoid any Google Drive or Google Sheets operation that is not strictly necessary.

This is not a memory for ChatGPT

I do not think of this Google Sheet as "ChatGPT's memory".

It is far simpler than that.

It is somewhere outside the chat where I can decide that a piece of a conversation deserves to be kept.

During a discussion:

we search
→ we try things
→ we rephrase
→ something becomes interesting

At that point:

Persist that.

The piece leaves the flow.

It becomes retrievable regardless of what ChatGPT still has in context five days from now.

From flow to capital

Technically, all of this ends up writing three cells into a spreadsheet.

That is not the interesting part.

What interests me is the gesture.

A conversation with an AI produces an enormous amount of temporary information.

Not all of it needs to survive.

But some of it deserves to move from the flow into something that lasts.

I do not want to ask ChatGPT to memorise everything.

I want to be able to point at something and say:

That one counts.

Then:

Persist that.

The conversation stays the space I work in.

What I take out of it can start to become an information asset.