Claude's AI just got a hive mind.
Anthropic shipped it this morning: your Claude Code sessions can now message each other. One session sends a note, the other picks it up mid-task. I ran it for real — the replay is on this page.
The Messenger Pigeon Problem.
You're deep in a chat. It's going great.
The AI knows your business, your project, your style.
Then the chat fills up.
You hit the context limit, and everything it learned is stuck in that window.
So you open a fresh session and start over like a stranger. "Hi, so I run an agency, and we were working on…"
Smart people built entire routines around this.
One user in today's replies says he's done it manually for two years: at about 80 percent of the context window, he has Claude write a handoff document, then carries it to the next session himself.
Another describes the same ritual. Ask for a handoff prompt. Copy. Paste. Every time.
The smartest AI users in the world, working as messenger pigeons between their own sessions.
The Hive Mind Engine ends that job for good.
The name says code. The reality is a chat box that can actually do things on your computer — write content, organise files, handle admin. If you can send a text message, you can use it.
Your sessions can pass notes now.
A beehive works because every bee shares what it finds.
No single bee is smart. The hive is smart.
That's the update: each Claude session used to be one lonely bee with no idea the others existed.
Now one session can send another a note. The other picks it up mid-task and keeps working.
It goes both ways — you can ask another session a question and the answer comes back to the one you're in.
And Claude can message another session on its own, when a change it just made affects that session's work.
I ran it for real this morning. Here's the whole journey.
Two sessions open on related work.
Mine: a "scout" session holding the announcement facts, and a "writer" session waiting to turn facts into hooks.
You tell one session to brief the other.
One sentence from you. No copying, no window-switching.
Claude writes the summary itself.
Not the whole chat — the relevant part. My scout compressed three facts into three tight lines.
The message lands mid-task.
The other session doesn't restart. It picks the note up in the middle of what it's doing. Mine: sent 09:52:57, received 09:53:12 — fifteen seconds.
The receiving session works with it.
My writer read the summary and produced two finished hooks — proof the meaning survived the hop.
Questions flow backwards too.
Ask another session "what did you find?" and the answer returns to your active window.
Sometimes nobody asks — it just happens.
When one session's change affects another's work, Claude sends the message on its own. Your sessions cover each other's blind spots.
The official sources — read it and try it yourself.
"New in Claude Code: your sessions can now message each other. Instead of having to re-explain yourself in another session, you can now tell Claude to do it. It sends a summary (not your history or files), and the other session picks it up mid-task."
This is the tweet. Three things to catch: the feature is live today (not a preview), what travels is a summary — which is both the privacy story and why the receiving session's memory stays clean — and the thread below it confirms it works both ways, plus fires automatically when one session's change affects another. macOS and Linux now; update Claude Code and it's on.
The Hive Mind Engine — three layers.
Once you see it, you can't unsee it. Here's the mental model.
The Notes
Sessions hand each other summaries. Work carries forward without you ferrying it — the handoff routine people ran by hand for two years is now built in.
The Questions
Ask another session anything from the one you're in. "What did you find on their competitors?" — the answer comes back. No window-switching, no digging through old chats.
The Auto-Tap
The sleeper feature. When one session's change affects another's work, Claude taps that session on the shoulder by itself. Your sessions watch each other's blind spots — teamwork, from software.
The real run, replayed — and what AI teams can build.
I didn't wait to test this pattern. Below is a replay of my actual two-agent run from this morning — verbatim messages, real clock times, looping.
Not a coincidence: the top builds on my 50-task benchmark come from AI teams — the Fusion ensemble (9.0 on that dragon world) and the Hermes Mixture-of-Agents (8.6 on this DOOM build). Coordination beats solo. Today, Anthropic built coordination into the tool itself.
And this is what the hive looks like at home in my Agent OS:
What you're looking at: the Claude tab in my Agent OS — every session's output lands in one shared workspace (25 files in the selected project alone), so no session's work dies when its window closes.
What you're looking at: the Agent Kanban — a Planner breaks the goal into cards, a Builder builds each one, a Reviewer checks it landed. That's the hive-mind pattern as a daily workflow; today's update gives it a native messaging layer.
The one weakness nobody's talking about.
A summary is a summary.
The sharpest reply on the whole thread put it perfectly: handing off a summary without the underlying files is all fun and games until the second agent has to guess what "it" refers to.
If session one says "I fixed the issue with the pricing page," session two needs to know which issue, which page, which fix.
Details get lost in compression. It's like asking a friend how a movie was and getting "good." Technically an answer. Not very useful.
So no — this doesn't make context problems disappear. It automates the handoff people were doing by hand. The handoff still lives or dies on how good the summary is.
Early reports are positive — one user switched sessions mid-task and called the handoff clean, and my own run carried the full meaning across in 15 seconds. But keep expectations honest: this is version one of a feature, not a finished brain.
Single assistants were 2024. Teams are the story now.
Every major AI company is racing the same direction — agents that work together instead of alone.
One reply pointed out OpenAI's Codex already has something similar, and predicted the tools will converge on the same features. Probably right.
The pattern inside Claude Code is already clear: first agents got memory, then subagents, now messaging. Each step points one way — your AI stops being a worker and becomes a workforce.
People in the replies immediately asked for the real prize: Claude talking to Codex talking to everything else. To be clear, cross-tool messaging is not part of today's update. But the direction is set.
No — that's the biggest myth about it. The everyday 90% runs on free local models on your own machine, free API tiers slot in for more, and for frontier work it drives the CLIs you already pay for — your Claude subscription includes the Claude Code CLI, and the OS plugs straight into it. Inside the Boardroom there are token-efficiency playbooks so you never think about it again.
Get the Hive Mind Engine built for you.
We've been building this exact pattern for months, before Anthropic made it official — the Agent OS is a dashboard where your Claude, Hermes and OpenClaw agents share one memory through Obsidian. This week's tutorials cover wiring today's session messaging into it.
Three things you might be thinking.
Members inside the Boardroom already run multi-agent setups daily. Their wins are documented in a 158-page doc, in their own words.
Read the 158-page testimonials doc →Real people run this stack right now.
Yes. Today. Here's the five-minute test.
Step 1: Update Claude Code.
It's live on macOS and Linux — the feature arrives with the normal update.
Step 2: Open two sessions on related tasks.
A proposal and its research. Product descriptions and a sale post. Anything paired.
Step 3: Have one ask the other a question.
"Ask my other session what it found." Watch the answer come back without you switching windows.
Step 4: Check the summary quality for YOUR work.
That's the honest test — the catch section above is the reason. Five minutes here teaches you more than any video, including this one.
The people who figure out AI agents now, while the tools are evolving fast, are going to be way ahead when everything settles. Every update you learn compounds.
What changed today.
Run the Hive Mind Engine, don't just watch it.
The five-minute test above is the free path. The Boardroom is the fast one: the Agent OS where your Claude, Hermes and OpenClaw already share one memory — so today's messaging update isn't a feature you read about, it's a system you run.
Readers bookmark this page and keep copy-pasting between sessions. Operators join, wire it in this week, and let their sessions brief each other while they sleep.
