Big Idea

The argument in one line.

Claude Code sessions can now send messages to each other directly, turning context handoffs, context-budget management, and multi-window collaboration into things the sessions coordinate instead of things a user copies by hand.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You run more than one Claude Code session at a time and currently copy-paste context between windows by hand.
You've hit a context-window wall mid-project and had to manually re-explain state to a fresh session.
You want to split a large build or research task across parallel sessions that need to stay in sync with each other.
You've felt a session getting slower or a message costing more as a conversation grows and want to know why.

SKIP IF…

You only ever run a single Claude Code session at a time — there's nothing here to coordinate.
You're looking for a walkthrough of a different AI coding tool — this feature is Claude Code specific.

TL;DR

The full version, fast.

Claude Code sessions can now message each other directly instead of requiring a human to copy-paste context between windows. The presenter demos sending a message between two sessions, then walks through three real uses: resetting a session before its 1,000,000-token context window gets too full and expensive, spinning off a new idea into its own window without losing the current thread, and keeping two sessions synced when they're both editing the same external resource, like a Google Sheet. He closes on naming every session with /rename so /resume stays browsable later.

Free for members

Chat with this breakdown — free.

Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.

Create a free account →

Chapters

Where the time goes.

00:00 – 01:48

01 · Sessions can now talk

Introduces cross-session messaging: one session sends data to another with no manual copy-paste, demoed by sending "hi" from session X to session Y. Frames it against a bigger use case — a master session planning a three-city trip (Rome, Paris, Lisbon) while per-city worker sessions research and stay synced on one shared budget.

01:48 – 03:50

02 · Cut your context bill

Explains why the context window matters: a fuller window makes the model dumber and each message more expensive. Demos /context to check usage, warns that 40-50% full is where things degrade, and gives a concrete cost example — reopening a stale session can cost around $10 in tokens on one model tier. Distinguishes sending a short handoff note between sessions from running /compact, which re-reads the whole conversation and costs more.

03:50 – 05:51

03 · Where I actually use it

Covers two more real use cases: spinning a new idea into its own session window without derailing current work, and keeping two sessions synced when both are editing the same Google Sheet so they don't overwrite each other. Mentions building his own Chrome extension now that the barrier to building has dropped. Introduces the coworker analogy — sessions as employees who knock on each other's door when they need something, then go back to independent work.

05:51 – 07:50

04 · Name and resume sessions

Confirms cross-session messaging needs no approval step. Recommends naming every new session immediately with /rename, then demos /resume listing sessions by name so old work is easy to find. Closes with a direct call to try the feature.

Atomic Insights

Lines worth screenshotting.

Claude Code sessions can now message each other directly, replacing manual copy-paste hand-offs between windows.
A session can hand its state to a fresh session by describing what to transfer in plain language, instead of a human selecting and dragging files over.
Splitting a big task, like planning a trip across three cities, into one master session plus per-city worker sessions only works cleanly once the sessions can coordinate shared constraints, like one fixed budget, on their own.
Claude Code's context window is 1,000,000 tokens, and the fuller it gets, the dumber the model gets and the more each message costs.
Running /context shows exactly how full a session is; the presenter treats 40-50% full as the point where responses noticeably degrade and get noticeably pricier.
Reopening a session after being away for an hour can cost around $10 in tokens on one model tier because roughly 500,000 tokens of stale context has to be reloaded.
Cross-session messaging is not the same as running /compact — /compact re-reads and summarizes the whole conversation and costs tokens, while a short handoff note is cheaper.
Sessions can message each other with no approval step — you can tell one session to interrogate another and pull back an answer with zero confirmation in between.
Two sessions editing the same external resource, like one Google Sheet, need to actively synchronize or one session's update silently overwrites the other's.
Naming a session immediately with /rename matters because /resume lists every past session by name, and a vague name makes old work impossible to find later.

Takeaway

How to actually use cross-session messaging

WHAT TO LEARN

Claude Code sessions can now message each other directly, turning three constant chores — moving context, protecting your context budget, and keeping parallel work in sync — into things you describe instead of things you manually copy.

When a session's context window climbs toward 40-50% full, start a fresh session and ask the old one to send over just the important context instead of paying rising per-message costs.
A short handoff note between sessions is cheaper than running /compact, because /compact re-reads the entire conversation and bills for that pass.
Splitting a big task into a master planning session plus several worker sessions only stays coherent if the workers can message each other about shared constraints, like one fixed budget across three destinations.
A new idea that surfaces mid-task doesn't have to interrupt current work — describe what to hand off in plain language and let a fresh session pick it up in its own window.
Two sessions editing the same external resource, like one Google Sheet, need to actively synchronize with each other or one session's update can silently get overwritten by the other's.
There's no approval step in cross-session messaging — one session can query another and pull back an answer without confirmation, so treat any shared data as immediately visible to every session pointed at it.
Naming every new session immediately with /rename pays off later, since /resume lists sessions by name and a vague name makes old work hard to find again.
Reopening an idle session after being away can cost real money — roughly $10 in tokens on one model tier, about half that on a cheaper tier — because stale context has to be reloaded.

Glossary

Terms worth knowing.

Context window: The total amount of text, measured in tokens, a Claude session can hold in memory at once before earlier parts of the conversation start falling out of reach.
/context command: A Claude Code command that breaks down how full the current session's context window is, by system prompt, tools, memory files, and messages.
/compact command: A Claude Code command that condenses a long conversation by re-reading and summarizing it, which itself costs tokens — different from sending a short handoff note to a new session.
/rename command: A Claude Code command that gives the current session a human-readable name so it can be identified later in the session list.
/resume command: A Claude Code command that lists all previous sessions by name so you can reopen one instead of starting fresh.

Resources

Things they pointed at.

03:01toolClaude Opus 5 / Fable 5 (model tiers)

Quotables

Lines you could clip.

00:00

“Anthropic just solved one of the biggest problems with Cloud Code.”

cold-open claim with no setup needed→ TikTok hook↗ Tweet quote

03:01

“if you will send a very simple short message, you will pay $10 in tokens for this message”

concrete, surprising cost figure→ IG reel cold open↗ Tweet quote

05:34

“the simplest analogy for your different sessions within Cloud Code, it's like different employees within the company”

memorable analogy that explains the whole feature in one line→ newsletter pull-quote↗ Tweet quote

The Script

Word for word.

Read-along

Don't just watch it. Burn it in.

See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.

metaphor

Anthropic just solved one of the biggest problems with Cloud Code. They made it possible for different Cloud Code sessions running on your computer to talk to each other. So if before, if you wanted to transfer some sort of data from one session to another, you needed to manually copy and paste it.

Right now, they can just talk to each other without your involvement at all. So here's how it looks like. Inside one session, you're just asking it to send some specific information to another one, and then it just transfers the data.

Another session receives it, fully reads everything, and then you can continue talking to it. So imagine you want to solve a big complicated task, like organizing your summer trip to Europe, and you want to travel to three different cities, like Rome, Paris, and Lisbon.

And having one Cloud Code session will probably be not optimal because the task is too big. So instead, you might want to have one kinda master Cloud Code session that is in charge of the high level plan, and then you will have three more sessions. One session per city where you will do specific research to this city, understand the budget, and then these sessions will be able to talk to each other and plan the whole trip together.

Because things like budget, you have just one fixed budget for the whole trip. For that reason, it's really convenient that the sessions can talk to each other. And now let me show you how it works in practice.

So here's my Cloud Code environment. As you can see, I've created two sessions, session x and session y. And now let's just send a sample message.

So I've just sent this prompt asking to send message hi to the session y. Let's see what's happening. As you can see, it is finished right here.

And if I go to y, we have this message printed inside the chat. Of course, this was a dummy example, but here are a few real use cases when you're doing some serious work. One of the things that I struggled the most with, and that's why I thought that this is a big problem of Cloud Code, is the context window.

Like, you have this limited context window, which is 1,000,000 tokens. And the more filled in it gets, the dumber the model gets and the more money you pay.

For that reason, in many cases, you wanted to break down your work on big complicated task, let's say building a website into multiple sub sessions because it will be faster and cheaper. So whenever you're seeing that the context is too full in one session, then you might just create a new session and ask the initial session to just send over the important context to a new one.

And with the prior session, you will be just finished. So here's how it looks in practice. Let's say I am in the session x.

Let's say I will run this command called context. As you can see right now, the context window is full only by 6%. So that's not much.

But when it will be, let's say, 40% or 50%, this is already at the point where the model gets significantly dumber and you're paying significantly more money. Just as an example, if you had a conversation with Fable five and then you went away for one hour and then you're coming back, and if you will send a very simple short message, you will pay $10 in tokens for this message because it will need to reactivate all the cash for the past 500,000 tokens.

So so this is kinda approximate pricing for that. With Opus five, this is twice cheaper, but still a decent amount of money. So the use case is simple.

When you see that your context usage is too high, you're just creating a new session, let's say y, and then you're saying in the session x to transfer all the context to y. And this is not the same thing as running the compact command because compact command will go through the whole conversation, and it will also cost a lot of tokens while sending a short note with information will be cheaper.

Okay. Another use case is when you're working on something, maybe your big project, and then you have a new idea that gets to your mind. You already have this session going on, and this idea came right inside this session.

Now if before you needed to, you know, manually select the necessary pieces of context, create a new session, and then actually manually drag and drop them, now once again, you can just explain in natural text what you want to be transferred, and then you will continue working on this new feature. Right now, because the barrier, the threshold to build stuff gets so much lower, everyone is building a ton of things.

Recently, for instance, I've built myself a new Chrome extension. I was paying $50 for another Chrome extension that blocks social media apps, and now I just built one myself because I just realized that I don't like that they are stealing my data, that they're actually selling my data.

That's why, you know, your ideas, they keep flowing, and it's pretty natural and fun to be building multiple things at the same time. And here's another use case. Let's say you're working on something big.

Let's say you have a specific Google Sheet database with the information about your customers or your leads, whatever it might be, and you have two sessions working on the same Google Sheet at the same time. Then you might want to synchronize their actions.

Because if one session updated the sheet and another session is not aware about this update, then they will just, you know, erase the work of each other. So they need to be in touch with one another. So the simplest analogy for your different sessions within Cloud Code, it's like different employees within the company.

Each one has their own desk. They are doing their work on their desk. But every once in a while, one employee can just walk by another one, just knock on their door and tell, hey.

I need something from you or help me with that or what do you think about this. They will just have this little communication, collaborate with each other, and then continue their independent work.

And here are a few valuable comments about how this thing works. First of all, I was curious, like, is it possible for one session to send a question to another one, or do I need to approve that or anything? No.

We don't need to approve nothing. So you can just tell one session to go to session, let's say, z, ask it this, this, and that questions, pull up that data, ask it to give it to you, and then it will do all that stuff that you're asking for.

So there is no friction associated with this process. And another thing about the usage. So here is my Cloud Code environment.

I highly recommend to you give a very nice and clear name to each new session that you're creating. So let's say I'm pressing this orange button. Here is a new session.

You can immediately run the rename command and give it a name. Let's say feature form for new users.

Let's say this will be a thing where we're working on something on our website. Then this identifier will be attached to this session, and then you can just reference this name from other sessions, and it will be convenient for you.

So let's say if you if I'm starting a new session, I can also run the resume command. And as you can see here, I have names of all of the previous sessions. And as you can see, feature form for new users is listed here or Twitter spy or this is kinda more realistic abbreviation that I was using, something descriptive that I understand what it means.

So if you are doing that, then all of your sessions, they will have very clean names. And once you want to get back to your history, once again, if I show their resume command, I will have a ton of, you know, sessions listed out right here.

And when the name is clean, then it's very easy to go back to one of the sessions and resume the work whenever I need to. That was it. Go test it out this feature for yourself.

And if you enjoyed the video, here's another one prepared specifically for you.

The Hook

The bait, then the rug-pull.

Separate Claude Code sessions used to be islands — if you wanted one to know what another had figured out, you copied and pasted it yourself. This video walks through Anthropic's fix: sessions that can message each other directly, and three situations where that actually matters.

Frameworks

Named ideas worth stealing.

05:34concept

Sessions as coworkers

Each session has its own desk and does independent work
Sessions knock on each other's door when they need something
They exchange what's needed, then return to independent work

An analogy for how cross-session messaging should be used day-to-day: sessions stay independent by default and only interrupt each other for a specific ask.

Steal fordeciding when to split a task across multiple Claude Code sessions versus keeping it in one

CTA Breakdown