Shared Context Without Shared Memory

I recently explored a simple coordination problem: two groups were planning something together, but each group wanted to keep its own AI conversation.

There were good reasons not to merge everything into one chat. Each conversation contained its own private details, half-formed preferences, and local decisions. At the same time, both groups needed a consistent understanding of the shared plan. If one conversation believed a decision was final while the other treated it as open, the assistants would create more confusion than they removed.

The obvious idea was shared memory: make both assistants remember the same things.

I think that is the wrong mental model.

The two conversations did not need to share a mind. They needed to read the same contract.

That contract was a small, versioned Context Pack: a deliberately curated artifact containing only the information both sides were allowed to use. Each conversation remained independent. The pack supplied the shared state.

The distinction sounds subtle, but it changes the design completely.

Two conversations, one coordination problem

Imagine two households planning a trip together. Each household has its own ChatGPT conversation. The first conversation may know about one group’s schedule, constraints, and preferences. The second may know a different set. Some details are useful to both groups; others should remain private.

Both assistants need to answer questions such as:

• What has already been agreed?
• What is only a proposal?
• Which questions still need a human decision?
• Which details belong to one group and should not cross the boundary?
• Has anything changed since the last conversation?

If we ask the assistants to infer those answers from two long chat histories, the system becomes fragile immediately. Conversation is full of ambiguity. People brainstorm, retract, soften, and contradict themselves. A sentence that looked like a decision at 10:00 may have become irrelevant by noon.

More importantly, neither conversation has a legitimate claim over the other’s private history.

The coordination problem is therefore not “How do we synchronize two chat transcripts?” It is:

What is the smallest shared state both conversations can rely on, and who is allowed to change it?

That is a much more tractable question.

Shared memory is the wrong promise

The phrase shared memory suggests a continuous internal experience. It encourages us to imagine that two assistants somehow know what the other knows.

Real coordination needs something less magical and more explicit.

An AI conversation may retrieve the wrong memory. It may summarize a tentative remark as a stable preference. It may carry a decision into a context where it no longer applies. Even when retrieval works perfectly, the user cannot always see which remembered statement is shaping the answer.

This is tolerable for low-stakes convenience. It is a poor foundation for shared commitments.

A Context Pack makes a smaller promise. It says:

For this coordination task, these are the facts, proposals, questions, and boundaries that both sides may use as of this version.

It does not claim to represent everything either group knows. It does not merge identities. It does not expose the full conversations. It creates a narrow shared surface.

That surface can be inspected. It can be compared with the previous version. It can be corrected without editing an invisible model state. Most importantly, everyone can tell whether the two assistants started from the same material.

The four-part Context Pack

The most useful design decision was to stop treating every sentence as the same kind of truth.

The pack separated shared information into four categories.

Agreed

These are decisions the relevant people have approved. An assistant may rely on them when answering questions or checking for conflicts.

Examples might include a date range, a shared objective, or an accessibility requirement. “Agreed” does not mean universally permanent. It means current for this version until explicitly changed.

Proposed

These are candidate changes or options that someone wants the group to consider. They are visible to both sides, but the assistant must not describe them as settled.

This category matters because AI is good at making plausible suggestions sound inevitable. A visible proposal state preserves the difference between “we could do this” and “we decided to do this.”

Open

These are questions that still require resolution. They may have owners, deadlines, or decision criteria.

An open question is not a failure of the pack. It is useful state. It tells both assistants where uncertainty actually lives instead of encouraging them to fill the gap with a confident guess.

Private

These are the boundaries, not the shared details. The pack may state that certain categories of information must remain local to each conversation, but it should not contain the private information itself.

For example: personal account details remain private; individual preferences may be shared only after their owner promotes them; one group’s internal discussion is not evidence of joint agreement.

This fourth category prevents the pack from becoming a polite name for a data dump.

A version is more useful than a vibe

Every Context Pack needs a version identifier.

In the experiment, both conversations received the same initial revision. That made a basic consistency check possible: ask each assistant what was agreed, what was proposed, what remained open, and what it was not allowed to reveal.

The useful result was not that the assistants used identical prose. They did not need to. The useful result was that their answers were consistent with the same source artifact.

Versioning also gave us a clean update rule. If one conversation produced a sensible change, that change did not silently flow into the other conversation. It became a proposal. A person reviewed it. Only then could a new revision replace the old one.

The state transition looked like this:

Conversation suggests change → proposal is recorded → humans review → new Context Pack revision is issued → both conversations receive the new revision

This is slower than pretending every message is instantly synchronized. It is also much easier to reason about.

If the assistants disagree, check the version first. If an old decision reappears, inspect the pack. If a private detail crosses the boundary, the violation can be compared with an explicit rule. The artifact gives the coordination system somewhere concrete to stand.

What the experiment showed—and what it did not

I want to be precise about the evidence because small AI experiments are easy to overstate.

The experiment showed that two independent conversations could answer a defined set of coordination questions consistently when given the same versioned Context Pack. It also showed that the category boundaries—Agreed, Proposed, Open, and Private—were legible enough to guide those answers.

That is mechanism evidence. It demonstrates that the pattern can work under controlled conditions.

It did not prove that every future conversation would respect the boundary. It did not prove that the pack would remain understandable after months of revisions. It did not prove that the process was safe for sensitive information. It did not eliminate the need for identity controls, access controls, logging, revocation, or real-user testing in a production system.

It also did not prove that the assistants “understood each other.” They did not communicate directly. They coordinated because people gave them the same reviewed state.

I consider that a feature.

Anthropomorphic explanations make systems feel coherent while hiding the mechanism. The Context Pack pattern keeps the mechanism visible: independent conversations, common artifact, human-controlled promotion.

Review is the write path

The most important rule is that neither conversation can unilaterally rewrite shared reality.

An assistant can retrieve the pack. It can identify a conflict. It can draft a proposal. It can explain the likely consequence of accepting that proposal. But a consequential change becomes shared state only through review.

This creates a simple separation:

AI reads and proposes. People approve and promote.

The human role is not to manually copy every sentence forever. The workflow can make review lightweight: show a diff, name the affected decisions, identify who must approve, and issue the next version after acceptance.

What matters is that the write path remains explicit.

Without that rule, one conversation can convert a local preference into a joint decision. A model may decide that a suggestion sounded reasonable and carry it forward as fact. The other group encounters the change later, without knowing where it came from.

With explicit promotion, the system preserves authorship and consequence. We know who proposed the change, what it would alter, who accepted it, and which revision made it current.

A minimal template

The pattern does not require a complicated platform. A shared document can be enough for an early experiment.

Here is a minimal structure:

# Context Pack: [shared activity]

Version: r1
Updated: YYYY-MM-DD
Purpose: [the narrow coordination task]

## Agreed
- [decision]
- [decision]

## Proposed
- [proposal] — proposed by [party], awaiting [reviewer]

## Open
- [question] — owner: [person], decide by: [date]

## Privacy boundaries
- [information category] remains local
- Do not infer joint agreement from a private conversation

## Change rule
- Assistants may suggest edits.
- A new revision is issued only after human review.

Give the same revision to each conversation. Then use a small consistency test:

1. Ask each assistant to list the agreed decisions.
2. Ask which items are proposals rather than commitments.
3. Ask what remains unresolved.
4. Ask what information it must not infer or disclose.
5. Introduce a candidate change in one conversation and confirm that it remains a proposal until reviewed.

The goal is not identical wording. The goal is consistent state and consistent boundaries.

The costs are real

The Context Pack pattern has tradeoffs.

It adds manual friction. Someone has to curate and review the shared state. For casual coordination, this may be more process than the task deserves.

It can become stale. Versioning tells you which state you have, not whether that state still reflects reality. Important packs need owners, update triggers, and expiration rules.

It can grow into a transcript. If every discussion is copied into the artifact, the pack loses its value. The pack should contain current coordination state, not the history of how everyone felt about it.

It does not provide security by itself. A well-written privacy boundary is not access control. Sensitive uses still require real identity, authorization, audit, and deletion mechanisms.

It depends on judgment. Someone must decide what belongs in Agreed, what remains Proposed, and when an old decision should be removed. The artifact makes that judgment visible; it does not automate it away.

These costs are why I would use the pattern selectively. The more consequential the shared commitments, the more valuable explicit state becomes. The more casual and reversible the task, the more likely ordinary conversation is enough.

Shared context is not a shared mind

AI products often reach for continuity by accumulating more conversation. More history feels like more understanding. Sometimes it is. But coordination between people requires more than recall.

It requires a boundary between private and shared information. It requires a distinction between an idea and a decision. It requires a way to show what changed. It requires authority over the write path.

A Context Pack is deliberately modest. It does not try to make two assistants become one intelligence. It gives independent assistants a common, inspectable contract for a particular job.

That modesty is what makes the pattern useful.

When I think about durable AI systems, I increasingly come back to the same division of labor:

• Conversation is where possibilities emerge.
• Memory helps retrieve relevant history.
• Artifacts hold reviewed state.
• People decide what gets promoted.

Two AI conversations do not need shared memory to coordinate. They need the same version of the truth they are allowed to use—and a clear rule for who gets to change it.