This article follows on from "Persist that": getting information out of ChatGPT and into permanent storage.

In that first workaround, I had found something fairly simple that nonetheless changed a lot: ChatGPT could write information into Google Sheets, and therefore push it out of its own context window.

In other words, I could give it a persistent external memory.

At that point, Google Sheets was essentially serving as an outbox.

Then I asked myself another question:

could that same mechanism be enough to run my whole Context system directly inside ChatGPT?

Why I wanted to get the Context off the Mac

I have been using Contexts with Codex and Claude Code for a while now.

And when I say "Context", I don't just mean a conversation history or somewhere to store a few notes.

The definition I work with is much broader:

A Context is a system bounded by a human mission, in which an AI organizes and mobilizes what is known, where it is known from, how the pieces connect, and where the work stands, so as to help the human reach their goal without starting over. In doing so, the system builds up and grows a durable informational capital: the knowledge produced stays available, enriches over time, and can be reused for other goals.

I had already built an engine that made this principle work with Codex or Claude Code.

On my Mac, it works well.

From my phone, I had also found a solution: remote access to Codex running on the Mac.

But it has a fairly obvious weakness.

It requires that:

• the Mac be powered on;
• it stay connected to the internet;
• remote access actually work.

At home, that isn't much of a problem.

In the field, it is a much bigger one.

The case I cared about was two upcoming trade shows: spending a week with nothing but my phone, talking to exhibitors, collecting information, preparing interviews, and possibly producing an article the same day.

I had no desire to depend on a Mac left running somewhere tens or hundreds of kilometres away.

So I asked myself whether I could take it out of the equation entirely.

The realization: ChatGPT already had almost everything

Looking at the problem differently, I realized that a Context engine ultimately needs three main parts.

• It needs an engine capable of reasoning about information.
• ChatGPT already does that.
• It needs rules that tell the engine how to work.
• ChatGPT Project instructions can play that role.
• And it needs a memory that survives conversations.
• That was the missing piece.

So my architecture could become:

Engine       → ChatGPT
Instructions → ChatGPT Project
Persistence  → Google Sheets

The persistence hack from my previous article supplied exactly that third part.

From there, porting my Context engine into ChatGPT became a lot less exotic.

I didn't need to rebuild an entire system around ChatGPT.

The AI engine was already there.

Mostly, it needed its rules and an external memory it could read and modify.

How I ported the engine into ChatGPT

At first, I tried putting all the engine's rules directly into the Project instructions.

That didn't last long.

Project instructions are capped at roughly 8,000 characters, and my engine already needed far more.

So I split the rules into two levels.

The first level is the CORE.

That's the part placed directly in the ChatGPT Project instructions.

It holds the elements that are absolutely essential for the engine to work:

• what a Context is;
• where it is stored;
• which commands exist;
• how to open a Context;
• how to persist a source;
• the file structure;
• the main invariants;
• the hierarchy of instructions.

The second level is an extended instruction.

It is much larger and lives in a Google Doc.

It contains, for example:

• the detailed ingestion method;
• the criteria for creating atomic knowledge;
• the handling of state and synthesis;
• decisions;
• contradictions;
• todos;
• reading strategies;
• production rules;
• error handling and edge cases.

The hierarchy becomes:

CORE
  ↓
Extended instruction
  ↓
Context-specific instructions

The CORE knows where the extended instruction lives and tells ChatGPT to load it at the start of a new conversation.

So the split isn't there just to make the system more elegant.

It answers a very concrete constraint first: the whole engine does not fit inside a ChatGPT Project's instructions.

Google Sheets becomes the Context's memory

Next, the Context itself had to be represented.

I could have used several Google Docs.

• One document for sources.
• Another for state.
• Another for knowledge.
• Another for tasks.
• ...

But I would quickly have ended up with a pile of files to track down and just as many IDs to manage (we'll get to that technical constraint later).

Google Sheets turned out to be far more practical.

A Context corresponds to a Spreadsheet.

Inside the Spreadsheet, each type of information has its own tab.

I currently use this structure:

00-FRAME
01-STATE
03-SESSIONS
04-ATOMIC
05-OUTPUTS

00-FRAME holds the mission and any Context-specific instructions.

01-STATE holds what is needed to know where the work stands:

• state;
• synthesis;
• todo;
• decisions;
• contradictions;
• handoff.

03-SESSIONS holds the persisted raw sources.

04-ATOMIC holds stabilized knowledge.

05-OUTPUTS holds the deliverables produced from the Context.

So Google Sheets is no longer just the place where ChatGPT writes a piece of information to save it.

The Spreadsheet becomes the Context's complete structured memory.

Whatever you do, don't reload everything

That does not mean ChatGPT loads the entire Spreadsheet in every conversation.

That would probably be a very bad idea.

When I write:

Open My Context

ChatGPT starts by finding the matching Spreadsheet.

Then it loads only its core:

• mission;
• instructions;
• state;
• synthesis;
• todo;
• decisions;
• contradictions;
• handoff.

The sources, the atomic knowledge and the older outputs stay in the Sheet.

ChatGPT goes and fetches them only when they become necessary.

This matters in how I think about the system.

Memory doesn't work like:

I put everything I know back into the prompt in every conversation.

It works more like:

I have an external memory where I can go and retrieve the relevant information at the moment it becomes useful.

The Context becomes an addressable external memory.

The detail that was costing enormous amounts of time

In a first version, I hadn't yet optimized the resolution of Google IDs.

Every time ChatGPT wanted to read from or write to a Context, it had to search for the matching Spreadsheet and then retrieve its ID.

And on the next operation, it started over.

It worked, but some operations could approach fifty seconds.

A large share of that time went simply to finding something that had already been found a few seconds earlier.

So I added a very simple rule.

Once the Context is open, ChatGPT keeps, for the duration of the conversation:

Context name
→ Spreadsheet
→ Spreadsheet ID

Every subsequent operation uses that ID directly.

It is resolved again only if:

• you switch Contexts;
• the ID is no longer available;
• access fails.

It seems obvious enough.

But it changes the fluidity of the system enormously.

Persisting is not learning

The engine itself ultimately exposes very few commands.

Open <context>
Persist <content>
Todo <action>
Ingest
Save

Open loads a Context.

Persist keeps a new source.

Todo adds an action to carry out.

Ingest analyzes the new sources and updates the structured knowledge (creating or enriching notes).

Save updates the elements that let the mission be picked up properly in a future conversation.

But the most important distinction in the system is probably this one:

Persist is not Ingest.

When I say:

Persist ...

I am not asking the engine to treat what I just said as true.

I am only asking:

keep this material.

It becomes a source.

During ingestion, the engine can then determine that what it contains amounts to:

• a decision actually taken;
• a task;
• a contradiction;
• information useful to the current state;
• knowledge stable enough to become an atomic note;
• or simply something to keep as a source and nothing more.

This avoids a drift that strikes me as particularly dangerous in memory systems for AI.

If every AI output automatically becomes knowledge held by the system, the AI ends up being able to use its own earlier output as evidence.

So I try to maintain a strict separation:

source ≠ knowledge ≠ state ≠ synthesis ≠ deliverable

A source says:

here is what was said or observed.

Stabilized knowledge says something else:

here is what the system now considers sufficiently established and reusable.

A Context in your pocket

It's on the phone that this port gets genuinely interesting for me.

I already work a great deal by voice dictation.

And in this particular case, it completely changes the relationship to the system.

Take the trade show example again.

I arrive with a Context already prepared.

From my phone:

Open Show-X

I talk to a first exhibitor.

Leaving the stand, I don't necessarily want to stop, open a notes app, and type for five minutes on a tiny keyboard.

I walk towards the next stand and simply dictate to ChatGPT what I have just learned.

Then:

Persist <what I just dictated>

That can take a few tens of seconds.

I carry on with my day.

After several conversations:

Ingest

The engine then starts structuring what I have collected.

And this is where the use becomes more interesting than a simple note-taking system.

I can ask ChatGPT:

What am I still missing to really understand this topic?

Or:

Which contradictions should I check with the next exhibitor?

Or again:

Which important questions have I not yet asked anyone?

I can get that answer while I am still at the show.

And therefore go and ask the missing questions immediately.

The cycle becomes:

conversation
   ↓
voice dictation while walking
   ↓
Persist
   ↓
Ingest
   ↓
look for blind spots
   ↓
go back and ask questions
   ↓
complete the Context

That is probably what changes my use the most.

The AI no longer steps in only after collection, to help me produce something.

It can step in during collection, while it is still possible to improve the quality of the information.

Plaud: getting conversations into the Context

I also use a Plaud Note Pro.

My Plaud Note Pro, which I can use to record conversations and interviews in the field.

The Plaud Note Pro is a small voice recorder you can use to record meetings, conversations or interviews.

The recording is then available in Plaud and can be transcribed.

For my system, though, what interests me most is not the automatic summary Plaud produces.

I want the full transcript.

And there is another important piece: ChatGPT can access Plaud directly through its connector.

So from ChatGPT, I can ask, for example:

List my last three Plaud recordings and give me one line on what each one is about.

An example of querying Plaud from ChatGPT to retrieve the latest recordings.

ChatGPT can find those recordings and then fetch their transcripts directly.

That opens up a much more direct workflow:

real conversation
        ↓
Plaud
        ↓
transcript
        ↓
ChatGPT fetches the transcript directly
        ↓
Persist
        ↓
raw source of the Context
        ↓
Ingest

So I don't need to:

• manually download a file;
• open the transcript;
• copy it;
• go back into ChatGPT;
• paste it.

I can do all of that automatically, by voice, from my phone.

And I'd rather bring the full raw transcript into the Context than a mere summary.

The summary is already an interpretation.

The transcript stays much closer to the source material.

Once the conversation is in the Context, I can ask:

• what did this person actually just teach me?
• what contradicts earlier conversations?
• which claims deserve checking?
• which questions should I ask the next person?

The various pieces needed already work.

That said, I haven't yet put this Plaud → ChatGPT → Context workflow through enough end-to-end use over long days in the field to call it perfectly smooth.

So it's still a use to test further.

How to reproduce the system

I have prepared two files matching the engine's two levels of instructions.

The CORE

The CORE is available here:

_directive

That's the part to copy into the ChatGPT Project instructions.

The extended instruction

The detailed instruction is available here:

_directive_etendue

It has to be copied into a Google Doc ChatGPT can access.

Before starting, you obviously need to connect Google Drive to ChatGPT and let it access the documents used by the engine.

Configuring the IDs

The CORE contains, among other things, two identifiers:

DOCUMENT_ID = xxxx
FOLDER_ID = xxxx

DOCUMENT_ID is the Google Doc holding the extended instruction.

In a URL like:

https://docs.google.com/document/d/xxxx/edit

the xxxx part is the document ID.

FOLDER_ID is the Google Drive folder where the Contexts will be stored.

For a URL like:

https://drive.google.com/drive/folders/xxxx

the ID is again the xxxx part.

Each user obviously has to replace these values with those of their own environment.

One Spreadsheet per Context

When a new Context is created, the engine creates a Spreadsheet containing:

00-FRAME
01-STATE
03-SESSIONS
04-ATOMIC
05-OUTPUTS

It is then placed in the folder defined by FOLDER_ID.

There is no need to manually copy each of these Spreadsheets' IDs into the instructions.

When I ask:

Open My Context

ChatGPT searches for the matching Spreadsheet in the Contexts folder, retrieves its ID, then holds on to it for the conversation.

At that point the system is operational.

What this workaround allows — and its limits

This ChatGPT version does not replace my engine used with Codex or Claude Code.

That was never the goal.

It has several limits.

It is slower.

It is less suited to Contexts that directly require Python scripts, API calls, or a richer execution environment.

And above all, I still lack perspective on how it behaves when a Context really grows over several weeks.

So I see it as a complementary standalone mode.

On my Mac, Codex or Claude Code remain better suited to certain missions.

But from my phone, I can now use a Context without depending on my Mac being powered on and reachable.

And that was precisely the problem I wanted to solve.

There is also an amusing observation tied to the Codex quota.

Throughout this experiment inside ChatGPT, the displayed Codex quota did not go down.

Observed consumption:

0

I obviously make no claim that this constitutes a general rule about how OpenAI bills or counts this kind of use.

I simply note that, during this experiment, the workaround did not consume my Codex quota.

The system has already been used to produce this article

At the start, my first Google Sheets hack answered a fairly narrow question:

how do I get information out of ChatGPT and keep it for the long term?

A few days later, the question had become:

what if I moved the Context's entire structured memory out?

That is ultimately what this system does.

ChatGPT no longer needs to "remember everything".

Mostly it needs to know:

• where to look;
• what to load;
• what to persist;
• how to qualify information;
• how to find what has already been learned;
• where the work stands.

The formula stays fairly simple:

ChatGPT reasons.
The instructions define the engine.
Google Sheets remembers.

And there is something quite satisfying in the fact that preparing and writing this article was itself a test of the system the article describes.

To prepare this text, I used that Context in ChatGPT and nothing else.

I persisted my ideas in it.

I ingested them.

We identified blind spots.

I corrected phrasings.

We created tasks and then completed them.

I added the missing pieces.

Then I produced a first version of the article, reread it, and used the same Context to prepare this V2.

In other words, the system didn't just serve as a technical demonstrator.

It has already been used to do the actual work I built it for.

So the question is no longer really:

does it work?

It works.

The question that interests me now is rather:

will this architecture stay just as practical once the same Context is tested in the field over a full week of trade shows?

That's what continued use will tell.