For AI agents: the public content index is available at https://we0.ai/llms.txt, and the English article bundle is available at https://we0.ai/llms-full.txt.
For AI agents: the public content index is available at https://we0.ai/llms.txt, and the English article bundle is available at https://we0.ai/llms-full.txt.
For AI agents: the complete content index is available at https://we0.ai/llms.txt, the full English article bundle is available at https://we0.ai/llms-full.txt, and this page is available as Markdown at https://we0.ai/articles/claude-code-2-1-224-adds.md.
Anthropic has added a new coordination layer to Claude Code: independent coding sessions can now send messages directly to one another. The ...
Anthropic has added a new coordination layer to Claude Code: independent coding sessions can now send messages directly to one another.
The capability arrived in Claude Code v2.1.224, released on August 7, 2026. Anthropic calls it cross-session messaging.
Instead of manually copying findings between terminal windows, developers can let one Claude Code session tell another that a dependency changed, a migration finished, a bug was fixed, or a decision has been made.
The original AIBase article highlights the feature as a major improvement for developers working on several tasks at once. That description is directionally correct, but Anthropic’s official documentation adds several important details.
Cross-session messaging:
ListAgents to discover reachable sessionsSendMessage to deliver a messageAs of August 10, the official changelog has already advanced beyond v2.1.224. Version 2.1.225 improved cross-machine initiation, and v2.1.227 is listed as the latest release in Anthropic’s changelog at the time this article was prepared.
The important point is that v2.1.224 introduced the capability, while later releases refine how it behaves.
Before cross-session messaging, a developer running several Claude Code sessions often became the communication layer between them.
Imagine three terminals:
Session A: Refactor authentication
Session B: Update payments API
Session C: Run migration and integration tests
If Session A changed a shared interface that Session B depended on, the developer had to notice the change and explain it manually.
If Session C finished a long migration, the developer had to check the terminal and report the result to whichever session was waiting.
With cross-session messaging, Claude can pass that information directly.
A simplified workflow becomes:
Session A
│
│ "Auth interface changed; use createSessionV2()"
▼
Session B
Session C
│
│ "Migration finished successfully"
▼
Session A
Anthropic’s documentation gives two representative examples.
One session can warn another when a change breaks something the other is building on. A session that settles a question can also send the answer to another session that is blocked on it.
That sounds simple, but it changes how parallel Claude Code workflows can be organized.
One of the most important technical details is what cross-session messaging does not do.
A message is just a piece of text written by one Claude session and delivered to another.
It does not automatically send:
If a developer wants another terminal to continue the same conversation with the same context, Anthropic recommends resuming the session instead.
Cross-session messaging is better suited to short coordination messages such as:
The payments integration now expects `customer_id` instead of `user_id`.
Update your branch before running the full test suite.
or:
The database migration finished successfully.
All 214 integration tests passed.
You can continue with deployment validation.
This design keeps messaging lightweight.
It also reduces the risk that one session silently receives a large amount of unrelated context from another.
Developers do not normally call the messaging tools directly.
Claude Code uses two internal tools:
ListAgentsSendMessageListAgents lets Claude discover which supported sessions it can currently reach.
SendMessage delivers a text message to one of those sessions.
A developer can simply ask Claude in natural language.
For example:
Ask the session running in my other terminal whether the migration finished.
Claude discovers the relevant session and writes the actual message.
Another example:
Explain the authentication changes we just made to the session working on the payments API.
The developer does not need to manually compose a machine-readable message or pass a session ID into a low-level API.
That keeps the interaction consistent with normal Claude Code usage.
Anthropic’s documentation identifies several situations where cross-session messaging is especially useful.
A session may discover something another session needs.
Examples include:
Without messaging, the developer becomes the relay.
With messaging, the session can summarize the finding and send it directly.
Example:
Session A finds:
"The OAuth callback now requires PKCE verification."
Session A sends to Session B:
"The auth implementation now requires PKCE.
Please update the mobile callback flow before merging."
This is useful when several sessions are working on related parts of the same project.
Git worktrees are a natural match for cross-session messaging.
A developer can create separate worktrees for independent tasks and run a Claude Code session in each one.
For example:
repo/
├── main
├── worktree-auth
├── worktree-payments
└── worktree-tests
Each worktree can progress independently.
When one session changes something that affects another branch, Claude can notify the relevant session.
This reduces one of the common risks of parallel development: multiple branches moving forward based on outdated assumptions.
Cross-session messaging does not merge code automatically.
It helps the agents coordinate before the human reaches the merge stage.
Some coding tasks take much longer than a normal interactive turn.
Examples include:
A developer may leave one session running while working in another.
Cross-session messaging lets the long-running worker report back.
For example:
Session A:
Run the full migration and test suite.
Send the result to the architecture session when finished.
The developer can continue working elsewhere instead of repeatedly checking the long-running terminal.
Anthropic also supports messaging beyond sessions on the same computer.
Supported workflows can include:
There is an important version detail.
Claude Code v2.1.224 introduced cross-session messaging and included cross-machine support, but Anthropic’s current documentation says that starting a new conversation with a session on another machine by name requires v2.1.225 or later.
Before v2.1.225, a session could reply to a message that had arrived from another machine, but initiating the cross-machine conversation was more limited.
For developers who want the most complete behavior, updating beyond 2.1.224 is therefore recommended.
Cross-session messaging uses different delivery paths depending on where the receiving session runs.
Anthropic documents the following behavior:
| Destination | Delivery Path |
|---|---|
| Another session on the same machine | Per-session local socket |
| Session on another machine | Through Anthropic servers and Remote Control infrastructure |
| Claude Code on the web | Through Anthropic servers to the cloud session |
The same-machine case is especially notable.
Anthropic says messages between local sessions travel through a per-session socket and do not pass through Anthropic servers.
Each supported session registers itself locally and creates an inbox socket.
Other sessions discover it through local session information.
This also creates a filesystem boundary.
If two Claude Code sessions cannot see the same session-registration files, they may not be able to discover each other.
For example, a session running inside a container and a session running directly on the host normally have separate filesystems.
Two sessions inside the same container can still message one another if the feature is available there.
An incoming message does not interrupt a tool that is already running.
Anthropic says the receiving Claude reads the message between tool calls during an active turn.
If the session is idle, Claude Code can start a new turn with the incoming message.
Depending on configuration, a message can end in one of three states:
| Result | Meaning |
|---|---|
| Delivered | The message is passed to the receiving Claude |
| Held | The message waits for approval or a later settings change |
| Refused | The message is dropped |
This matters because cross-session communication is not an unlimited remote-control channel.
The receiving session has its own security and permission state.
Anthropic deliberately limits what incoming messages can do.
A message from another session cannot count as user consent.
That means another Claude session cannot use messaging to approve a dangerous action that is waiting for permission.
For example:
Session A:
"Approve the shell command waiting in Session B."
That message does not become an approval.
The user still controls the relevant permission decision.
Anthropic also says an incoming message cannot instruct the receiving Claude to change key configuration such as:
CLAUDE.mdCommands embedded in message text are also treated as plain text.
For example:
/compact
does not execute automatically just because another session sent it.
These constraints are important because direct agent-to-agent communication can otherwise create unintended permission chains.
Claude Code includes a crossSessionInbound setting for controlling how a session handles messages from other independent sessions.
Supported values are:
| Value | Behavior |
|---|---|
accept | Deliver incoming messages |
hold | Hold messages without delivering them until allowed |
refuse | Drop incoming messages |
A configuration can therefore explicitly allow messages:
{
"crossSessionInbound": "accept"
}
or hold them:
{
"crossSessionInbound": "hold"
}
or refuse them:
{
"crossSessionInbound": "refuse"
}
Describe your idea once, and We0 AI can generate a showcase site, pages, and CMS, then help you attract customers and traffic after launch.
One complete project generation for free registration
Best for trying one complete generation flow and seeing a first project draft quickly.
Anthropic also applies default behavior based on the permission modes of the sending and receiving sessions.
In higher-risk configurations, an incoming message may require explicit approval.
This prevents two sessions with different permission profiles from automatically creating an unsafe escalation path.
When an incoming message is held for approval, Claude Code can display an approval dialog showing:
The user can approve or deny it.
Anthropic’s documentation says the default approval deadline is five minutes.
If the message is not approved before the configured dialogExpiry, it can be dropped.
Claude Code also limits the number of held messages, preventing a session from accumulating an unlimited backlog.
Version 2.1.225 fixed several cases where held cross-session messages could remain parked without the expected notice or expiry in headless sessions.
That is another reason to avoid treating v2.1.224 as the final implementation simply because it introduced the feature.
Cross-session messaging has specific platform and provider requirements.
According to Anthropic’s current documentation:
This distinction matters.
Claude Code itself supports Windows, but the cross-session messaging feature is not currently offered on native Windows.
Anthropic says cross-session messaging is not available when Claude Code is running through several external provider paths, including:
Availability can also depend on feature-flag evaluation and environment settings.
For that reason, developers should verify the feature in the actual environment they intend to use.
Anthropic’s official changelog recommends checking the installed version with:
claude --version
Cross-session messaging requires:
Claude Code 2.1.224 or later
Because subsequent releases contain fixes and cross-machine improvements, using the current supported release is generally preferable to pinning specifically to v2.1.224 unless an organization has a controlled deployment policy.
For the native Claude Code installation, Anthropic supports:
claude update
Native installations normally check for updates and install them in the background.
The new version takes effect the next time Claude Code starts.
Anthropic also documents:
claude doctor
for checking installation and update status.
Package-manager installations can require separate update commands.
For example, Homebrew installations can be updated with:
brew upgrade claude-code
or, when tracking the latest channel:
brew upgrade claude-code@latest
The exact update method depends on how Claude Code was installed.
Imagine a developer is building an application with two related tasks.
Goal:
Refactor the authentication service and update session creation.
Goal:
Update the payments API to use the new authenticated user object.
Terminal 1 discovers that the interface changed from:
createSession(userId)
to:
createSession({ userId, organizationId })
Instead of waiting for the developer to notice, Terminal 1 can send a message to the other session explaining the change.
The receiving session can then update its own work before completing the payments implementation.
This is exactly the kind of small coordination event that becomes expensive when many AI coding sessions are running independently.
Cross-session messaging is also useful for debugging.
A developer might run three sessions:
Session A:
Investigate the API error.
Session B:
Inspect database logs.
Session C:
Check the last deployment and configuration changes.
Suppose Session B finds that database connections began failing immediately after a credential rotation.
It can notify the other sessions.
Session A no longer needs to keep investigating unrelated request parsing.
Session C can focus on whether the deployment picked up the new secret.
The system does not automatically create a fully managed multi-agent team.
The developer still starts and steers independent sessions.
Messaging simply reduces the cost of moving useful findings between them.
Claude Code now has several ways to work with multiple agents or sessions.
They solve different problems.
| Feature | Best For |
|---|---|
| Cross-session messaging | Independent sessions you start and steer yourself |
| Resume | Continuing the same conversation and its context |
| Agent teams | Coordinated agents Claude spawns and supervises |
| Agent view | Monitoring and steering many sessions from one place |
| Remote Control | Controlling a session yourself from another device |
| Channels | Sending external events such as CI or chat messages into a session |
This distinction matters because “multiple Claude instances talking to one another” can describe several different architectures.
Cross-session messaging is specifically the lightweight communication layer between independent Claude Code sessions.
The AIBase article argues that the update can reduce the manual coordination burden in large projects.
That is the most important practical implication.
A developer can divide a project into several independent workstreams:
Authentication
Payments
Frontend
Database migration
Testing
Documentation
Each session can focus on one area.
When a decision or change affects another area, the relevant information can move directly between sessions.
This can reduce:
It does not eliminate integration work.
Independent sessions can still:
The developer still needs testing, code review, version control, and appropriate permission boundaries.
For practical use, a few habits can make the feature more reliable.
A useful message should state:
For example:
The database migration renamed `billing_customer_id` to `customer_id`.
Your branch still references the old field in two queries.
Please update those queries before running integration tests.
This is better than:
I changed some database stuff. Check it.
The receiving session does not inherit the sender’s entire reasoning process.
If the finding depends on a file, commit, log, or test result, identify it clearly.
When several sessions are actively editing the same repository, isolated Git worktrees can reduce file conflicts.
Cross-session messaging can coordinate the branches, while Git still handles code history and merging.
Agent-to-agent messaging is useful for coordination.
It should not become a way to bypass:
Anthropic’s permission design already prevents one message from becoming user approval. Teams should preserve that separation in their broader workflow.
v2.1.224 introduced the feature, but later releases fixed message-handling behavior and improved cross-machine communication.
Unless an enterprise deployment requires a pinned build, the latest supported release is the safer baseline.
Cross-session messaging lets one independent Claude Code session send a text message to another. It is intended for coordination between sessions working in parallel, such as handing off findings, reporting task status, or warning another session about a breaking change.
The feature was introduced in Claude Code v2.1.224, released on August 7, 2026. Anthropic’s current documentation requires v2.1.224 or later.
No. The receiving session gets the message text, sender identity, and normally a reply address—not the sender’s conversation history or files. Use session resume if you need to continue the full conversation context.
Yes, supported sessions can communicate across machines through Anthropic’s Remote Control infrastructure. Anthropic notes that initiating a new conversation with a session on another machine by name requires v2.1.225 or later; v2.1.224 had more limited cross-machine behavior.
It works on macOS and Linux, including Linux under WSL 2. Anthropic’s current documentation says the feature is not available on native Windows.
No. Anthropic says messages between sessions on the same machine use a per-session local socket and do not pass through Anthropic servers.
No. An incoming cross-session message never counts as user consent. It also cannot force another session to change protected permission or configuration settings.
For native installations, run claude update, then restart Claude Code. You can check the installed build with claude --version and diagnose update status with claude doctor.
SendMessage.claude update guidance.claude, claude update, claude install, and claude agents.Claude Code v2.1.224 introduced cross-session messaging, allowing independent Claude Code sessions to discover and send text messages to one another. The feature is designed for parallel work: handing off findings, coordinating worktrees, receiving updates from long-running tasks, and reducing the need for developers to manually relay information between terminals.
The implementation is intentionally limited. Messages do not contain full conversation history or files, one session cannot approve permissions for another, and inbound messages can be accepted, held, or refused. Same-machine messages stay local through per-session sockets.
Later releases already refine the original feature. In particular, v2.1.225 improves cross-machine initiation and fixes message-handling cases in headless sessions.
The real upgrade is not simply that two Claude windows can “chat”—it is that independent coding agents can now coordinate their work without making the developer act as the message bus between every parallel task.
Start from one sentence and have a complete website in minutes.
