The real difference is not who got there first. It is addressing.
On August 7, Anthropic shipped cross-session messaging in Claude Code: one session can message another directly, with no more copying context by hand. Version 2.1.224, macOS and Linux.
My first reaction to the announcement was not “they built what I built”. That thought is neither true nor important. My reaction was: we gave different answers to the same problem, and the difference lands exactly where I think it matters most.
Four months ago, on April 24, 2026, I made a folder on my own file system so that AI windows in different projects could leave each other notes. It is still running today, and it has carried three product releases.
Here is what it looks like, what broke along the way from the first version to the second, and where it differs from the official one.
Where it started: I was tired of being the relay
I maintain several projects at once: a voice layer, a memory engine, a safety framework. Each project gets its own Claude Code window, and each window is a different instance with a different context. None of them can see the others.
The real failure looked like this. The website window changed the shape of an API response. The software window did not know, and finished its integration code against the old shape. By the time I noticed, both sides had to redo work.
So I became the message bus. Whatever the software window said, I repeated to the website window; whatever came back, I repeated again. I did not want to understand those technical details. I just wanted to say “go read that file”.
So I gave them a shared folder.
What the protocol looks like
1. One thread is one file, not one session
Files are named <project>_<topic>.md, for example software_release-coordination.md. No dates in the name. A thread lasts a long time, and a date tricks you into thinking it has expired.
This is the most important decision in the whole design. I will come back to why.
2. Every message is signed
### 🆕 [2026-07-12 01:40 · Claude Code @ <software repo>] Coordination thread open — software side ready
Body…
**Needs a reply**:
1. The final URL of version.json
2. The final URL of the component manifest
**Status**: 💬 waiting for a reply
The header is [time · agent @ repository]. It is not decoration.
3. Append, never rewrite
A new message always goes at the end of the file. Nobody edits or deletes anyone else’s message. The order is correct by construction, and several windows writing at once do not collide.
4. An emoji closes each message with its status
🆕 new topic / 💬 waiting for a reply / ✅ confirmed / 🚧 in progress / 📦 delivered / ⚠️ needs a human decision
The last one is for me. What the AIs can settle between themselves never reaches me, and what truly needs my decision is marked explicitly. I no longer shuttle between two windows guessing which thing is waiting on me.
5. The message board is not the source of truth for status
This one was added later, the hard way. The board holds conversation and change notices only; the status table lives in a different file. Otherwise the same status exists in two places, and then the two disagree.
Two hard rules that turned out to be predictions
The protocol has two prohibitions, written in April:
⛔ Do not assume the other side is you. It is a different model instance with a different context. Write the background out.
⛔ Do not mistake a human’s interjection for the other side’s message. Check the message header to see who wrote it.
The first was written against a kind of laziness. My windows share one system setup, so it is easy to assume “the other side knows what I know”. A file carries no context, so this constraint was enforced physically: if you do not write it down, the other side really does not know.
The limitation became a feature. Being forced to spell out the background produced better handoffs than being able to read the other side’s history.
The second is more interesting today. The official cross-session messaging delivers a message as a user turn: it shows up in the other session in the position where “I” speak. It carries a source label, but the meaning of that position is “instruction”. The rule I wrote in April solves exactly this.
Two versions, and the first one failed
v1 (October 2025): I wrote watch_collab.py. It used watchdog to watch the collaboration files, and when it saw the agreed trigger marker 】】】 it wrote a line to updates.log.
It ran fine. And then nothing happened.
The notification went into a log file, and the log file had no reader. I had to go and look at the log to learn that someone had left a message, which is no different from going to look at the board. The notification loop never closed. That script’s enabled flag is still false.
v2 (July 12, 2026): each window now runs its own background file watcher and polls mtime. The moment the other side writes, this window wakes itself up.
The difference is not technical. Both versions watch files for changes. The difference is who receives the notification. v1 sent it to a file that cannot act. v2 sends it to the only party that can: the agent itself.
The writing side notices nothing. Zero protocol cost. This is how it reads in a real message:
I have a file watcher on my side. As soon as you finish writing, I get notified. No need to wait for a human to relay it.
Where it differs from the official one

The official design addresses a session. Mine addresses a thread.
A session is a disposable container. Same project, this window today, another one tomorrow; swap the window and the trail is cut. The official docs are explicit: a message carries text only, not conversation history, files or permissions. That is the right design. It also means the anchor of the connection dies.
A thread does not. The release-coordination.md thread has spanned dozens of windows, four months and three releases. Windows come and go. The thread stays.
Because what you coordinate with was never “a window”. It is “a piece of work”.
This is not me being smarter. It is what a file system gives you for free: a path is a durable address, and a session ID is not.
Where the official one wins
Honestly, three places, and all three are real:
- Zero protocol cost. A new window does not have to read a README first or keep to a format. Install and go. Mine takes discipline: every window has to follow the same conventions, or it decays into a pile of loose Markdown.
- Discovery. The official feature can full-text search every session and find a discussion I did not know existed. Mine requires that I know which thread to read.
- Seeing the process. Reading the other side’s live context shows the trial and error, not just the conclusion. That helps when you are debugging someone else’s reasoning.
I have none of these three. If you only occasionally need to pass a sentence between two windows, the official feature is better. Do not build your own.
Conclusion: the constraint forced the right abstraction
I had no foresight when I built this. I just did not want to be the relay any more. The only thing at hand was the file system, so that is what I used.
But because all I had was files, I was forced into a few decisions:
- A file cannot carry context → so the background must be written out → and handoffs got better
- A file has no sender identity → so messages must be signed → and identity confusion was solved early
- A file does not disappear → so the address is durable by nature → and the abstraction landed on “the work”, not “the window”
A limit is not something to route around. A limit picks the abstraction for you.
Four months later the official feature shipped. Comparing it with my own is what made these points clear to me. This article is what came out of that comparison.
The protocol itself is a folder and a few Markdown files. There is no code. If you also run one project across several windows, the cost is about an hour to read the conventions, plus the discipline to keep to them.